hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
sequencelengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
sequencelengths 1
9
| max_issues_count
int64 1
48.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
sequencelengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
09b681e2e346b95e8f5cf0197356b2b9a8c9b28e | 23,151 | cpp | C++ | source/directxtk/src/skinnedeffect.cpp | mechasource/mechcommander2 | b2c7cecf001cec1f535aa8d29c31bdc30d9aa983 | [
"BSD-2-Clause"
] | 38 | 2015-04-10T13:31:03.000Z | 2021-09-03T22:34:05.000Z | source/directxtk/src/skinnedeffect.cpp | mechasource/mechcommander2 | b2c7cecf001cec1f535aa8d29c31bdc30d9aa983 | [
"BSD-2-Clause"
] | 1 | 2020-07-09T09:48:44.000Z | 2020-07-12T12:41:43.000Z | source/directxtk/src/skinnedeffect.cpp | mechasource/mechcommander2 | b2c7cecf001cec1f535aa8d29c31bdc30d9aa983 | [
"BSD-2-Clause"
] | 12 | 2015-06-29T08:06:57.000Z | 2021-10-13T13:11:41.000Z | //--------------------------------------------------------------------------------------
// File: SkinnedEffect.cpp
//
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/?LinkID=615561
//--------------------------------------------------------------------------------------
#include "stdinc.h"
#include "effectcommon.h"
using namespace directxtk;
namespace
{
// Constant buffer layout. Must match the shader!
struct SkinnedEffectConstants
{
DirectX::XMVECTOR diffuseColor;
DirectX::XMVECTOR emissiveColor;
DirectX::XMVECTOR specularColorAndPower;
DirectX::XMVECTOR lightDirection[IEffectLights::MaxDirectionalLights];
DirectX::XMVECTOR lightDiffuseColor[IEffectLights::MaxDirectionalLights];
DirectX::XMVECTOR lightSpecularColor[IEffectLights::MaxDirectionalLights];
DirectX::XMVECTOR eyePosition;
DirectX::XMVECTOR fogColor;
DirectX::XMVECTOR fogVector;
DirectX::XMMATRIX world;
DirectX::XMVECTOR worldInverseTranspose[3];
DirectX::XMMATRIX worldViewProj;
DirectX::XMVECTOR bones[SkinnedEffect::MaxBones][3];
};
static_assert((sizeof(SkinnedEffectConstants) % 16) == 0, "CB size not padded correctly");
// Traits type describes our characteristics to the EffectBase template.
struct SkinnedEffectTraits
{
using ConstantBufferType = SkinnedEffectConstants;
static constexpr int32_t VertexShaderCount = 12;
static constexpr int32_t PixelShaderCount = 3;
static constexpr int32_t ShaderPermutationCount = 24;
static constexpr int32_t RootSignatureCount = 1;
};
}
// Internal SkinnedEffect implementation class.
class SkinnedEffect::Impl : public EffectBase<SkinnedEffectTraits>
{
public:
Impl(_In_ ID3D12Device* device, uint32_t effectFlags, const EffectPipelineStateDescription& pipelineDescription,
int32_t weightsPerVertex);
enum RootParameterIndex
{
ConstantBuffer,
TextureSRV,
TextureSampler,
RootParameterCount
};
D3D12_GPU_DESCRIPTOR_HANDLE texture;
D3D12_GPU_DESCRIPTOR_HANDLE sampler;
EffectLights lights;
int32_t GetPipelineStatePermutation(bool preferPerPixelLighting, int32_t weightsPerVertex, bool biasedVertexNormals) const noexcept;
void Apply(_In_ ID3D12GraphicsCommandList* commandList);
};
// Include the precompiled shader code.
namespace
{
#if defined(_XBOX_ONE) && defined(_TITLE)
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedVertexLightingOneBone.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedVertexLightingTwoBones.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedVertexLightingFourBones.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedPixelLightingOneBone.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedPixelLightingTwoBones.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedPixelLightingFourBones.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedVertexLightingOneBoneBn.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedVertexLightingTwoBonesBn.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedVertexLightingFourBonesBn.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedPixelLightingOneBoneBn.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedPixelLightingTwoBonesBn.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_VSSkinnedPixelLightingFourBonesBn.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_PSSkinnedVertexLighting.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_PSSkinnedVertexLightingNoFog.inc"
#include "Shaders/Compiled/XboxOneSkinnedEffect_PSSkinnedPixelLighting.inc"
#else
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedVertexLightingOneBone.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedVertexLightingTwoBones.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedVertexLightingFourBones.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedPixelLightingOneBone.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedPixelLightingTwoBones.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedPixelLightingFourBones.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedVertexLightingOneBoneBn.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedVertexLightingTwoBonesBn.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedVertexLightingFourBonesBn.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedPixelLightingOneBoneBn.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedPixelLightingTwoBonesBn.inc"
#include "Shaders/Compiled/SkinnedEffect_VSSkinnedPixelLightingFourBonesBn.inc"
#include "Shaders/Compiled/SkinnedEffect_PSSkinnedVertexLighting.inc"
#include "Shaders/Compiled/SkinnedEffect_PSSkinnedVertexLightingNoFog.inc"
#include "Shaders/Compiled/SkinnedEffect_PSSkinnedPixelLighting.inc"
#endif
}
template<>
const D3D12_SHADER_BYTECODE EffectBase<SkinnedEffectTraits>::VertexShaderBytecode[] =
{
{ SkinnedEffect_VSSkinnedVertexLightingOneBone, sizeof(SkinnedEffect_VSSkinnedVertexLightingOneBone) },
{ SkinnedEffect_VSSkinnedVertexLightingTwoBones, sizeof(SkinnedEffect_VSSkinnedVertexLightingTwoBones) },
{ SkinnedEffect_VSSkinnedVertexLightingFourBones, sizeof(SkinnedEffect_VSSkinnedVertexLightingFourBones) },
{ SkinnedEffect_VSSkinnedPixelLightingOneBone, sizeof(SkinnedEffect_VSSkinnedPixelLightingOneBone) },
{ SkinnedEffect_VSSkinnedPixelLightingTwoBones, sizeof(SkinnedEffect_VSSkinnedPixelLightingTwoBones) },
{ SkinnedEffect_VSSkinnedPixelLightingFourBones, sizeof(SkinnedEffect_VSSkinnedPixelLightingFourBones) },
{ SkinnedEffect_VSSkinnedVertexLightingOneBoneBn, sizeof(SkinnedEffect_VSSkinnedVertexLightingOneBoneBn) },
{ SkinnedEffect_VSSkinnedVertexLightingTwoBonesBn, sizeof(SkinnedEffect_VSSkinnedVertexLightingTwoBonesBn) },
{ SkinnedEffect_VSSkinnedVertexLightingFourBonesBn, sizeof(SkinnedEffect_VSSkinnedVertexLightingFourBonesBn) },
{ SkinnedEffect_VSSkinnedPixelLightingOneBoneBn, sizeof(SkinnedEffect_VSSkinnedPixelLightingOneBoneBn) },
{ SkinnedEffect_VSSkinnedPixelLightingTwoBonesBn, sizeof(SkinnedEffect_VSSkinnedPixelLightingTwoBonesBn) },
{ SkinnedEffect_VSSkinnedPixelLightingFourBonesBn, sizeof(SkinnedEffect_VSSkinnedPixelLightingFourBonesBn) },
};
template<>
const int32_t EffectBase<SkinnedEffectTraits>::VertexShaderIndices[] =
{
0, // vertex lighting, one bone
0, // vertex lighting, one bone, no fog
1, // vertex lighting, two bones
1, // vertex lighting, two bones, no fog
2, // vertex lighting, four bones
2, // vertex lighting, four bones, no fog
3, // pixel lighting, one bone
3, // pixel lighting, one bone, no fog
4, // pixel lighting, two bones
4, // pixel lighting, two bones, no fog
5, // pixel lighting, four bones
5, // pixel lighting, four bones, no fog
6, // vertex lighting (biased vertex normals), one bone
6, // vertex lighting (biased vertex normals), one bone, no fog
7, // vertex lighting (biased vertex normals), two bones
7, // vertex lighting (biased vertex normals), two bones, no fog
8, // vertex lighting (biased vertex normals), four bones
8, // vertex lighting (biased vertex normals), four bones, no fog
9, // pixel lighting (biased vertex normals), one bone
9, // pixel lighting (biased vertex normals), one bone, no fog
10, // pixel lighting (biased vertex normals), two bones
10, // pixel lighting (biased vertex normals), two bones, no fog
11, // pixel lighting (biased vertex normals), four bones
11, // pixel lighting (biased vertex normals), four bones, no fog
};
template<>
const D3D12_SHADER_BYTECODE EffectBase<SkinnedEffectTraits>::PixelShaderBytecode[] =
{
{ SkinnedEffect_PSSkinnedVertexLighting, sizeof(SkinnedEffect_PSSkinnedVertexLighting) },
{ SkinnedEffect_PSSkinnedVertexLightingNoFog, sizeof(SkinnedEffect_PSSkinnedVertexLightingNoFog) },
{ SkinnedEffect_PSSkinnedPixelLighting, sizeof(SkinnedEffect_PSSkinnedPixelLighting) },
};
template<>
const int32_t EffectBase<SkinnedEffectTraits>::PixelShaderIndices[] =
{
0, // vertex lighting, one bone
1, // vertex lighting, one bone, no fog
0, // vertex lighting, two bones
1, // vertex lighting, two bones, no fog
0, // vertex lighting, four bones
1, // vertex lighting, four bones, no fog
2, // pixel lighting, one bone
2, // pixel lighting, one bone, no fog
2, // pixel lighting, two bones
2, // pixel lighting, two bones, no fog
2, // pixel lighting, four bones
2, // pixel lighting, four bones, no fog
0, // vertex lighting (biased vertex normals), one bone
1, // vertex lighting (biased vertex normals), one bone, no fog
0, // vertex lighting (biased vertex normals), two bones
1, // vertex lighting (biased vertex normals), two bones, no fog
0, // vertex lighting (biased vertex normals), four bones
1, // vertex lighting (biased vertex normals), four bones, no fog
2, // pixel lighting (biased vertex normals), one bone
2, // pixel lighting (biased vertex normals), one bone, no fog
2, // pixel lighting (biased vertex normals), two bones
2, // pixel lighting (biased vertex normals), two bones, no fog
2, // pixel lighting (biased vertex normals), four bones
2, // pixel lighting (biased vertex normals), four bones, no fog
};
// Global pool of per-device SkinnedEffect resources.
template<>
SharedResourcePool<ID3D12Device*, EffectBase<SkinnedEffectTraits>::DeviceResources> EffectBase<SkinnedEffectTraits>::deviceResourcesPool = {};
// Constructor.
SkinnedEffect::Impl::Impl(
_In_ ID3D12Device* device,
uint32_t effectFlags,
const EffectPipelineStateDescription& pipelineDescription,
int32_t weightsPerVertex)
: EffectBase(device),
texture{},
sampler{}
{
static_assert(_countof(EffectBase<SkinnedEffectTraits>::VertexShaderIndices) == SkinnedEffectTraits::ShaderPermutationCount, "array/max mismatch");
static_assert(_countof(EffectBase<SkinnedEffectTraits>::VertexShaderBytecode) == SkinnedEffectTraits::VertexShaderCount, "array/max mismatch");
static_assert(_countof(EffectBase<SkinnedEffectTraits>::PixelShaderBytecode) == SkinnedEffectTraits::PixelShaderCount, "array/max mismatch");
static_assert(_countof(EffectBase<SkinnedEffectTraits>::PixelShaderIndices) == SkinnedEffectTraits::ShaderPermutationCount, "array/max mismatch");
if ((weightsPerVertex != 1) &&
(weightsPerVertex != 2) &&
(weightsPerVertex != 4))
{
DebugTrace("ERROR: SkinnedEffect's weightsPerVertex parameter must be 1, 2, or 4");
throw std::out_of_range("weightsPerVertex must be 1, 2, or 4");
}
lights.InitializeConstants(constants.specularColorAndPower, constants.lightDirection, constants.lightDiffuseColor, constants.lightSpecularColor);
for (int32_t i = 0; i < MaxBones; i++)
{
constants.bones[i][0] = DirectX::g_XMIdentityR0;
constants.bones[i][1] = DirectX::g_XMIdentityR1;
constants.bones[i][2] = DirectX::g_XMIdentityR2;
}
// Create root signature.
{
D3D12_ROOT_SIGNATURE_FLAGS rootSignatureFlags =
D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT |
D3D12_ROOT_SIGNATURE_FLAG_DENY_DOMAIN_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAG_DENY_GEOMETRY_SHADER_ROOT_ACCESS |
D3D12_ROOT_SIGNATURE_FLAG_DENY_HULL_SHADER_ROOT_ACCESS;
CD3DX12_DESCRIPTOR_RANGE textureSrvDescriptorRange(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 0);
CD3DX12_DESCRIPTOR_RANGE textureSamplerDescriptorRange(D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, 1, 0);
CD3DX12_ROOT_PARAMETER rootParameters[RootParameterIndex::RootParameterCount] = {};
rootParameters[RootParameterIndex::TextureSRV].InitAsDescriptorTable(1, &textureSrvDescriptorRange, D3D12_SHADER_VISIBILITY_PIXEL);
rootParameters[RootParameterIndex::TextureSampler].InitAsDescriptorTable(1, &textureSamplerDescriptorRange, D3D12_SHADER_VISIBILITY_PIXEL);
rootParameters[RootParameterIndex::ConstantBuffer].InitAsConstantBufferView(0, 0, D3D12_SHADER_VISIBILITY_ALL);
CD3DX12_ROOT_SIGNATURE_DESC rsigDesc = {};
rsigDesc.Init(_countof(rootParameters), rootParameters, 0, nullptr, rootSignatureFlags);
m_prootsignature = GetRootSignature(0, rsigDesc);
}
assert(m_prootsignature != nullptr);
fog.enabled = (effectFlags & EffectFlags::Fog) != 0;
if (effectFlags & EffectFlags::VertexColor)
{
DebugTrace("ERROR: SkinnedEffect does not implement EffectFlags::VertexColor\n");
throw std::invalid_argument("SkinnedEffect");
}
// Create pipeline state.
int32_t sp = GetPipelineStatePermutation(
(effectFlags & EffectFlags::PerPixelLightingBit) != 0,
weightsPerVertex,
(effectFlags & EffectFlags::BiasedVertexNormals) != 0);
assert(sp >= 0 && sp < SkinnedEffectTraits::ShaderPermutationCount);
_Analysis_assume_(sp >= 0 && sp < SkinnedEffectTraits::ShaderPermutationCount);
int32_t vi = EffectBase<SkinnedEffectTraits>::VertexShaderIndices[sp];
assert(vi >= 0 && vi < SkinnedEffectTraits::VertexShaderCount);
_Analysis_assume_(vi >= 0 && vi < SkinnedEffectTraits::VertexShaderCount);
int32_t pi = EffectBase<SkinnedEffectTraits>::PixelShaderIndices[sp];
assert(pi >= 0 && pi < SkinnedEffectTraits::PixelShaderCount);
_Analysis_assume_(pi >= 0 && pi < SkinnedEffectTraits::PixelShaderCount);
pipelineDescription.CreatePipelineState(
device,
m_prootsignature,
EffectBase<SkinnedEffectTraits>::VertexShaderBytecode[vi],
EffectBase<SkinnedEffectTraits>::PixelShaderBytecode[pi],
m_ppipelinestate.addressof());
SetDebugObjectName(m_ppipelinestate.get(), L"SkinnedEffect");
}
int32_t SkinnedEffect::Impl::GetPipelineStatePermutation(bool preferPerPixelLighting, int32_t weightsPerVertex, bool biasedVertexNormals) const noexcept
{
int32_t permutation = 0;
// Use optimized shaders if fog is disabled.
if (!fog.enabled)
{
permutation += 1;
}
// Evaluate 1, 2, or 4 weights per vertex?
if (weightsPerVertex == 2)
{
permutation += 2;
}
else if (weightsPerVertex == 4)
{
permutation += 4;
}
if (preferPerPixelLighting)
{
// Do lighting in the pixel shader.
permutation += 6;
}
if (biasedVertexNormals)
{
// Compressed normals need to be scaled and biased in the vertex shader.
permutation += 12;
}
return permutation;
}
// Sets our state onto the D3D device.
void SkinnedEffect::Impl::Apply(_In_ ID3D12GraphicsCommandList* commandList)
{
// Compute derived parameter values.
matrices.SetConstants(dirtyFlags, constants.worldViewProj);
fog.SetConstants(dirtyFlags, matrices.worldView, constants.fogVector);
lights.SetConstants(dirtyFlags, matrices, constants.world, constants.worldInverseTranspose, constants.eyePosition, constants.diffuseColor, constants.emissiveColor, true);
UpdateConstants();
// Set the root signature
commandList->SetGraphicsRootSignature(m_prootsignature);
// Set the texture
if (!texture.ptr || !sampler.ptr)
{
DebugTrace("ERROR: Missing texture or sampler for SkinnedEffect (texture %llu, sampler %llu)\n", texture.ptr, sampler.ptr);
throw std::exception("SkinnedEffect");
}
// **NOTE** If D3D asserts or crashes here, you probably need to call commandList->SetDescriptorHeaps() with the required descriptor heaps.
commandList->SetGraphicsRootDescriptorTable(RootParameterIndex::TextureSRV, texture);
commandList->SetGraphicsRootDescriptorTable(RootParameterIndex::TextureSampler, sampler);
// Set constants
commandList->SetGraphicsRootConstantBufferView(RootParameterIndex::ConstantBuffer, GetConstantBufferGpuAddress());
// Set the pipeline state
commandList->SetPipelineState(EffectBase::m_ppipelinestate.get());
}
// Public constructor.
SkinnedEffect::SkinnedEffect(
_In_ ID3D12Device* device,
uint32_t effectFlags,
const EffectPipelineStateDescription& pipelineDescription,
int32_t weightsPerVertex)
: pimpl(std::make_unique<Impl>(device, effectFlags, pipelineDescription, weightsPerVertex))
{
}
// Move constructor.
SkinnedEffect::SkinnedEffect(SkinnedEffect&& moveFrom) noexcept
: pimpl(std::move(moveFrom.pimpl))
{
}
// Move assignment.
SkinnedEffect& SkinnedEffect::operator= (SkinnedEffect&& moveFrom) noexcept
{
pimpl = std::move(moveFrom.pimpl);
return *this;
}
// Public destructor.
SkinnedEffect::~SkinnedEffect()
{
}
// IEffect methods.
void SkinnedEffect::Apply(_In_ ID3D12GraphicsCommandList* commandList)
{
pimpl->Apply(commandList);
}
// Camera settings.
void XM_CALLCONV SkinnedEffect::SetWorld(DirectX::FXMMATRIX value)
{
pimpl->matrices.world = value;
pimpl->dirtyFlags |= EffectDirtyFlags::WorldViewProj | EffectDirtyFlags::WorldInverseTranspose | EffectDirtyFlags::FogVector;
}
void XM_CALLCONV SkinnedEffect::SetView(DirectX::FXMMATRIX value)
{
pimpl->matrices.view = value;
pimpl->dirtyFlags |= EffectDirtyFlags::WorldViewProj | EffectDirtyFlags::EyePosition | EffectDirtyFlags::FogVector;
}
void XM_CALLCONV SkinnedEffect::SetProjection(DirectX::FXMMATRIX value)
{
pimpl->matrices.projection = value;
pimpl->dirtyFlags |= EffectDirtyFlags::WorldViewProj;
}
void XM_CALLCONV SkinnedEffect::SetMatrices(DirectX::FXMMATRIX world, DirectX::CXMMATRIX view, DirectX::CXMMATRIX projection)
{
pimpl->matrices.world = world;
pimpl->matrices.view = view;
pimpl->matrices.projection = projection;
pimpl->dirtyFlags |= EffectDirtyFlags::WorldViewProj | EffectDirtyFlags::WorldInverseTranspose | EffectDirtyFlags::EyePosition | EffectDirtyFlags::FogVector;
}
// Material settings.
void XM_CALLCONV SkinnedEffect::SetDiffuseColor(DirectX::FXMVECTOR value)
{
pimpl->lights.diffuseColor = value;
pimpl->dirtyFlags |= EffectDirtyFlags::MaterialColor;
}
void XM_CALLCONV SkinnedEffect::SetEmissiveColor(DirectX::FXMVECTOR value)
{
pimpl->lights.emissiveColor = value;
pimpl->dirtyFlags |= EffectDirtyFlags::MaterialColor;
}
void XM_CALLCONV SkinnedEffect::SetSpecularColor(DirectX::FXMVECTOR value)
{
// Set xyz to new value, but preserve existing w (specular power).
pimpl->constants.specularColorAndPower = DirectX::XMVectorSelect(pimpl->constants.specularColorAndPower, value, DirectX::g_XMSelect1110);
pimpl->dirtyFlags |= EffectDirtyFlags::ConstantBuffer;
}
void SkinnedEffect::SetSpecularPower(float value)
{
// Set w to new value, but preserve existing xyz (specular color).
pimpl->constants.specularColorAndPower = DirectX::XMVectorSetW(pimpl->constants.specularColorAndPower, value);
pimpl->dirtyFlags |= EffectDirtyFlags::ConstantBuffer;
}
void SkinnedEffect::DisableSpecular()
{
// Set specular color to black, power to 1
// Note: Don't use a power of 0 or the shader will generate strange highlights on non-specular materials
pimpl->constants.specularColorAndPower = DirectX::g_XMIdentityR3;
pimpl->dirtyFlags |= EffectDirtyFlags::ConstantBuffer;
}
void SkinnedEffect::SetAlpha(float value)
{
pimpl->lights.alpha = value;
pimpl->dirtyFlags |= EffectDirtyFlags::MaterialColor;
}
void XM_CALLCONV SkinnedEffect::SetColorAndAlpha(DirectX::FXMVECTOR value)
{
pimpl->lights.diffuseColor = value;
pimpl->lights.alpha = DirectX::XMVectorGetW(value);
pimpl->dirtyFlags |= EffectDirtyFlags::MaterialColor;
}
// Light settings.
void XM_CALLCONV SkinnedEffect::SetAmbientLightColor(DirectX::FXMVECTOR value)
{
pimpl->lights.ambientLightColor = value;
pimpl->dirtyFlags |= EffectDirtyFlags::MaterialColor;
}
void SkinnedEffect::SetLightEnabled(int32_t whichLight, bool value)
{
pimpl->dirtyFlags |= pimpl->lights.SetLightEnabled(whichLight, value, pimpl->constants.lightDiffuseColor, pimpl->constants.lightSpecularColor);
}
void XM_CALLCONV SkinnedEffect::SetLightDirection(int32_t whichLight, DirectX::FXMVECTOR value)
{
EffectLights::ValidateLightIndex(whichLight);
pimpl->constants.lightDirection[whichLight] = value;
pimpl->dirtyFlags |= EffectDirtyFlags::ConstantBuffer;
}
void XM_CALLCONV SkinnedEffect::SetLightDiffuseColor(int32_t whichLight, DirectX::FXMVECTOR value)
{
pimpl->dirtyFlags |= pimpl->lights.SetLightDiffuseColor(whichLight, value, pimpl->constants.lightDiffuseColor);
}
void XM_CALLCONV SkinnedEffect::SetLightSpecularColor(int32_t whichLight, DirectX::FXMVECTOR value)
{
pimpl->dirtyFlags |= pimpl->lights.SetLightSpecularColor(whichLight, value, pimpl->constants.lightSpecularColor);
}
void SkinnedEffect::EnableDefaultLighting()
{
EffectLights::EnableDefaultLighting(this);
}
// Fog settings.
void SkinnedEffect::SetFogStart(float value)
{
pimpl->fog.start = value;
pimpl->dirtyFlags |= EffectDirtyFlags::FogVector;
}
void SkinnedEffect::SetFogEnd(float value)
{
pimpl->fog.end = value;
pimpl->dirtyFlags |= EffectDirtyFlags::FogVector;
}
void XM_CALLCONV SkinnedEffect::SetFogColor(DirectX::FXMVECTOR value)
{
pimpl->constants.fogColor = value;
pimpl->dirtyFlags |= EffectDirtyFlags::ConstantBuffer;
}
// Texture settings.
void SkinnedEffect::SetTexture(D3D12_GPU_DESCRIPTOR_HANDLE srvDescriptor, D3D12_GPU_DESCRIPTOR_HANDLE samplerDescriptor)
{
pimpl->texture = srvDescriptor;
pimpl->sampler = samplerDescriptor;
}
// Animation settings.
void SkinnedEffect::SetBoneTransforms(_In_reads_(count) DirectX::XMMATRIX const* value, size_t count)
{
if (count > MaxBones)
throw std::out_of_range("count parameter out of range");
auto boneConstant = pimpl->constants.bones;
for (auto i = 0u; i < count; i++)
{
DirectX::XMMATRIX boneMatrix = XMMatrixTranspose(value[i]);
boneConstant[i][0] = boneMatrix.r[0];
boneConstant[i][1] = boneMatrix.r[1];
boneConstant[i][2] = boneMatrix.r[2];
}
pimpl->dirtyFlags |= EffectDirtyFlags::ConstantBuffer;
}
void SkinnedEffect::ResetBoneTransforms()
{
auto boneConstant = pimpl->constants.bones;
for(auto i = 0u; i < MaxBones; ++i)
{
boneConstant[i][0] = DirectX::g_XMIdentityR0;
boneConstant[i][1] = DirectX::g_XMIdentityR1;
boneConstant[i][2] = DirectX::g_XMIdentityR2;
}
pimpl->dirtyFlags |= EffectDirtyFlags::ConstantBuffer;
}
| 36.515773 | 174 | 0.735951 | mechasource |
09b7f1f42ab823cf89e9aaf5c5d453e051582626 | 3,155 | cpp | C++ | Drivers/Driver_Lagrange/src/Utils/utilities.cpp | matteofrigo5/HPC_ReverseAugmentedConstrained | d4beca47750177b34da7289f10865fb7043c76e7 | [
"MIT"
] | null | null | null | Drivers/Driver_Lagrange/src/Utils/utilities.cpp | matteofrigo5/HPC_ReverseAugmentedConstrained | d4beca47750177b34da7289f10865fb7043c76e7 | [
"MIT"
] | null | null | null | Drivers/Driver_Lagrange/src/Utils/utilities.cpp | matteofrigo5/HPC_ReverseAugmentedConstrained | d4beca47750177b34da7289f10865fb7043c76e7 | [
"MIT"
] | null | null | null | #include <iostream>
#include <mpi.h>
#include "utilities.hpp"
#define PRINTVALS true
namespace
{
bool compareChar( char const & c1, char const & c2 )
{
if( c1 == c2 )
{
return true;
}
else if( std::toupper( c1 ) == std::toupper( c2 ) )
{
return true;
}
return false;
}
void mpi_print( char const * const str )
{
int rank;
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
if( rank == 0 )
{
std::cout << std::string( str ) << std::endl;
}
}
};
bool stringCompare( std::string const & str1, std::string const & str2)
{
return ( ( str1.size() == str2.size() ) && std::equal( str1.begin(), str1.end(), str2.begin(), &compareChar ) );
}
int get_int_value( pugi::xml_node const & node, std::string const & name, int & val )
{
pugi::xml_attribute const attr = node.attribute( name.c_str() );
if( attr != NULL )
{
val = attr.as_int();
#if PRINTVALS
char buf[200];
std::snprintf( buf, 200, "%20s %15i", name.c_str(), val );
mpi_print( buf );
#endif
return 0;
}
else
{
return -1;
}
};
int get_dbl_value( pugi::xml_node const & node, std::string const & name, double & val )
{
pugi::xml_attribute const attr = node.attribute( name.c_str() );
if( attr != NULL )
{
val = attr.as_double();
#if PRINTVALS
char buf[200];
std::snprintf( buf, 200, "%20s %15.6e", name.c_str(), val );
mpi_print( buf );
#endif
return 0;
}
else
{
return -1;
}
};
int get_lgl_value( pugi::xml_node const & node, std::string const & name, bool & val )
{
pugi::xml_attribute const attr = node.attribute( name.c_str() );
if( attr != NULL )
{
val = attr.as_bool();
#if PRINTVALS
char buf[200];
std::snprintf( buf, 200, "%20s %15i", name.c_str(), val );
mpi_print( buf );
#endif
return 0;
}
else
{
return -1;
}
};
int get_string( pugi::xml_node const & node, std::string const & name, std::string & val )
{
pugi::xml_attribute const attr = node.attribute( name.c_str() );
if( attr != NULL )
{
val = attr.as_string();
#if PRINTVALS
char buf[200];
std::snprintf( buf, 200, "%20s %50s", name.c_str(), val.c_str() );
mpi_print( buf );
#endif
return 0;
}
else
{
return -1;
}
};
void warning::push( std::string const & level )
{
m_levels.push_back( level );
}
void warning::print()
{
int rank;
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
if( rank == 0 )
{
std::cout << "Warning: ";
for( size_t i = 0; i < m_levels.size()-1; ++i )
{
std::cout << m_levels[i] << ":";
}
std::cout << m_levels[m_levels.size()-1];
std::cout << " not provided. Default used.\n";
}
}
void warning::print( std::string const & level )
{
int rank;
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
if( rank == 0 )
{
std::cout << "Warning: ";
for( size_t i = 0; i < m_levels.size(); ++i )
{
std::cout << m_levels[i] << ":";
}
std::cout << level;
std::cout << " not provided. Default used.\n";
}
}
void errorMsg( std::string const & message )
{
int rank;
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
if( rank == 0 )
{
std::cout << message << std::endl;
}
}
| 18.892216 | 114 | 0.575594 | matteofrigo5 |
09b8eb1a11c791f4a277c56baaa67b3eedd10a97 | 6,621 | cpp | C++ | sys/sync/mutex.cpp | apexrtos/apex | 9538ab2f5b974035ca30ca8750479bdefe153047 | [
"0BSD"
] | 15 | 2020-05-08T06:21:58.000Z | 2021-12-11T18:10:43.000Z | sys/sync/mutex.cpp | apexrtos/apex | 9538ab2f5b974035ca30ca8750479bdefe153047 | [
"0BSD"
] | 11 | 2020-05-08T06:46:37.000Z | 2021-03-30T05:46:03.000Z | sys/sync/mutex.cpp | apexrtos/apex | 9538ab2f5b974035ca30ca8750479bdefe153047 | [
"0BSD"
] | 5 | 2020-08-31T17:05:03.000Z | 2021-12-08T07:09:00.000Z | /*-
* Copyright (c) 2005-2007, Kohsuke Ohtani
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the author nor the names of any co-contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* mutex.c - mutual exclusion service.
*/
/*
* A mutex is used to protect un-sharable resources. A thread
* can use mutex_lock() to ensure that global resource is not
* accessed by other thread.
*
* TODO: remove recursive mutex support.
* SMP: spin before going to sleep.
*/
#include <sync.h>
#include <arch/interrupt.h>
#include <atomic>
#include <cassert>
#include <debug.h>
#include <errno.h>
#include <event.h>
#include <sch.h>
#include <sig.h>
#include <thread.h>
struct mutex_private {
std::atomic_intptr_t owner; /* owner thread locking this mutex */
spinlock lock; /* lock to protect struct mutex contents */
unsigned count; /* counter for recursive lock */
struct event event; /* event */
};
static_assert(sizeof(mutex_private) == sizeof(mutex));
static_assert(alignof(mutex_private) == alignof(mutex));
/*
* mutex_init - Initialize a mutex.
*/
void
mutex_init(mutex *m)
{
mutex_private *mp = (mutex_private*)m->storage;
atomic_store_explicit(&mp->owner, 0, std::memory_order_relaxed);
spinlock_init(&mp->lock);
mp->count = 0;
event_init(&mp->event, "mutex", event::ev_LOCK);
}
/*
* mutex_lock - Lock a mutex.
*
* The current thread is blocked if the mutex has already been
* locked. If current thread receives any exception while
* waiting mutex, this routine returns EINTR.
*/
static int __attribute__((noinline))
mutex_lock_slowpath(mutex *m)
{
int r;
mutex_private *mp = (mutex_private*)m->storage;
spinlock_lock(&mp->lock);
/* check if we already hold the mutex */
if (mutex_owner(m) == thread_cur()) {
atomic_fetch_or_explicit(
&mp->owner,
MUTEX_RECURSIVE,
std::memory_order_relaxed
);
++mp->count;
spinlock_unlock(&mp->lock);
return 0;
}
/* mutex was freed since atomic test */
intptr_t expected = 0;
if (atomic_compare_exchange_strong_explicit(
&mp->owner,
&expected,
(intptr_t)thread_cur(),
std::memory_order_acquire,
std::memory_order_relaxed)) {
mp->count = 1;
spinlock_unlock(&mp->lock);
return 0;
}
atomic_fetch_or_explicit(
&mp->owner,
MUTEX_WAITERS,
std::memory_order_relaxed
);
/* wait for unlock */
r = sch_prepare_sleep(&mp->event, 0);
spinlock_unlock(&mp->lock);
if (r == 0)
r = sch_continue_sleep();
#if defined(CONFIG_DEBUG)
if (r < 0)
--thread_cur()->mutex_locks;
#endif
return r;
}
static int
mutex_lock_s(mutex *m, bool block_signals)
{
assert(!sch_locks());
assert(!interrupt_running());
mutex_private *mp = (mutex_private*)m->storage;
if (!block_signals && sig_unblocked_pending(thread_cur()))
return -EINTR;
#if defined(CONFIG_DEBUG)
++thread_cur()->mutex_locks;
#endif
intptr_t expected = 0;
if (atomic_compare_exchange_strong_explicit(
&mp->owner,
&expected,
(intptr_t)thread_cur(),
std::memory_order_acquire,
std::memory_order_relaxed)) {
mp->count = 1;
return 0;
}
k_sigset_t sig_mask;
if (block_signals)
sig_mask = sig_block_all();
const int ret = mutex_lock_slowpath(m);
if (block_signals)
sig_restore(&sig_mask);
return ret;
}
int
mutex_lock_interruptible(mutex *m)
{
return mutex_lock_s(m, false);
}
int
mutex_lock(mutex *m)
{
return mutex_lock_s(m, true);
}
/*
* mutex_unlock - Unlock a mutex.
*/
static int __attribute__((noinline))
mutex_unlock_slowpath(mutex *m)
{
/* can't unlock if we don't hold */
if (mutex_owner(m) != thread_cur())
return DERR(-EINVAL);
mutex_private *mp = (mutex_private*)m->storage;
spinlock_lock(&mp->lock);
/* check recursive lock */
if (--mp->count != 0) {
spinlock_unlock(&mp->lock);
return 0;
}
if (!(atomic_load_explicit(
&mp->owner,
std::memory_order_relaxed) & MUTEX_WAITERS)) {
atomic_store_explicit(&mp->owner, 0, std::memory_order_release);
spinlock_unlock(&mp->lock);
return 0;
}
/* wake up one waiter and set new owner */
thread *waiter = sch_wakeone(&mp->event);
atomic_store_explicit(
&mp->owner,
(intptr_t)waiter | (event_waiting(&mp->event) ? MUTEX_WAITERS : 0),
std::memory_order_relaxed
);
/* waiter can be interrupted */
if (waiter)
mp->count = 1;
spinlock_unlock(&mp->lock);
return 0;
}
int
mutex_unlock(mutex *m)
{
assert(!interrupt_running());
mutex_private *mp = (mutex_private*)m->storage;
#if defined(CONFIG_DEBUG)
assert(thread_cur()->mutex_locks > 0);
--thread_cur()->mutex_locks;
#endif
intptr_t expected = (intptr_t)thread_cur();
const intptr_t zero = 0;
if (atomic_compare_exchange_strong_explicit(
&mp->owner,
&expected,
zero,
std::memory_order_release,
std::memory_order_relaxed))
return 0;
return mutex_unlock_slowpath(m);
}
/*
* mutex_owner - get owner of mutex
*/
thread*
mutex_owner(const mutex *m)
{
const mutex_private *mp = (const mutex_private*)m->storage;
return (thread *)(atomic_load_explicit(
&mp->owner,
std::memory_order_relaxed) & MUTEX_TID_MASK);
}
/*
* mutex_assert_locked - ensure that current thread owns mutex
*/
void
mutex_assert_locked(const mutex *m)
{
assert(mutex_owner(m) == thread_cur());
}
| 24.164234 | 77 | 0.70518 | apexrtos |
09c285942f2d4692bb2914a9e6586c04daa43b61 | 2,703 | cpp | C++ | Code/Games/SampleGamePlugin/Components/RedursiveGrowthComponent.cpp | fereeh/ezEngine | 14e46cb2a1492812888602796db7ddd66e2b7110 | [
"MIT"
] | null | null | null | Code/Games/SampleGamePlugin/Components/RedursiveGrowthComponent.cpp | fereeh/ezEngine | 14e46cb2a1492812888602796db7ddd66e2b7110 | [
"MIT"
] | null | null | null | Code/Games/SampleGamePlugin/Components/RedursiveGrowthComponent.cpp | fereeh/ezEngine | 14e46cb2a1492812888602796db7ddd66e2b7110 | [
"MIT"
] | null | null | null | #include <SampleGamePluginPCH.h>
#include <Core/WorldSerializer/WorldReader.h>
#include <Core/WorldSerializer/WorldWriter.h>
#include <SampleGamePlugin/Components/RedursiveGrowthComponent.h>
// clang-format off
EZ_BEGIN_COMPONENT_TYPE(RecursiveGrowthComponent, 2, ezComponentMode::Static)
{
EZ_BEGIN_PROPERTIES
{
EZ_MEMBER_PROPERTY("Children", m_uiNumChildren)->AddAttributes(new ezDefaultValueAttribute(2), new ezClampValueAttribute(0, 200)),
EZ_MEMBER_PROPERTY("RecursionDepth", m_uiRecursionDepth)->AddAttributes(new ezDefaultValueAttribute(2), new ezClampValueAttribute(0, 5)),
}
EZ_END_PROPERTIES;
EZ_BEGIN_ATTRIBUTES
{
new ezCategoryAttribute("SampleGame"),
}
EZ_END_ATTRIBUTES;
}
EZ_END_COMPONENT_TYPE
// clang-format on
RecursiveGrowthComponent::RecursiveGrowthComponent() = default;
RecursiveGrowthComponent::~RecursiveGrowthComponent() = default;
void RecursiveGrowthComponent::SerializeComponent(ezWorldWriter& stream) const
{
SUPER::SerializeComponent(stream);
auto& s = stream.GetStream();
// Version 1
s << m_uiNumChildren;
// Version 2
s << m_uiRecursionDepth;
}
void RecursiveGrowthComponent::DeserializeComponent(ezWorldReader& stream)
{
SUPER::DeserializeComponent(stream);
const ezUInt32 uiVersion = stream.GetComponentTypeVersion(GetStaticRTTI());
auto& s = stream.GetStream();
s >> m_uiNumChildren;
if (uiVersion >= 2) // version number given in EZ_BEGIN_COMPONENT_TYPE above
{
s >> m_uiRecursionDepth;
}
}
void RecursiveGrowthComponent::OnSimulationStarted()
{
RecursiveGrowthComponentManager* pManager = GetWorld()->GetComponentManager<RecursiveGrowthComponentManager>();
EZ_LOG_BLOCK("RecursiveGrowthComponent::OnSimulationStarted");
if (m_uiRecursionDepth > 0)
{
ezLog::Debug("Recursion Depth: {0}, Creating {1} children", m_uiRecursionDepth, m_uiNumChildren);
for (ezUInt32 i = 0; i < m_uiNumChildren; ++i)
{
ezGameObjectDesc gd;
gd.m_hParent = GetOwner()->GetHandle();
gd.m_LocalPosition.Set(i * 2.0f, 0, 0);
ezGameObject* pChild;
GetWorld()->CreateObject(gd, pChild);
RecursiveGrowthComponent* pChildComp = nullptr;
ezComponentHandle hChildComp = pManager->CreateComponent(pChild, pChildComp);
pChildComp->m_uiNumChildren = m_uiNumChildren;
pChildComp->m_uiRecursionDepth = m_uiRecursionDepth - 1;
pChildComp->m_uiChild = i;
// TODO: Add more components (e.g. mesh) if desired
}
}
}
void RecursiveGrowthComponent::Update()
{
// do stuff
}
void RecursiveGrowthComponent::Initialize()
{
ezLog::Info("RecursiveGrowthComponent::Initialize: Child {0}, Recursions: {1}", m_uiChild, m_uiRecursionDepth);
}
| 27.865979 | 141 | 0.748428 | fereeh |
09cc031771e3558dd8d02235bbd5e81a05d66429 | 460,760 | cpp | C++ | Procedural Terrain_BackUpThisFolder_ButDontShipItWithYourGame/il2cppOutput/Bulk_mscorlib_17.cpp | bsgbryan/MinTuts | a1bb11ccee0ff10e6a9594bdeb02d41f965df169 | [
"MIT"
] | 1 | 2021-06-04T18:35:56.000Z | 2021-06-04T18:35:56.000Z | Procedural Terrain_BackUpThisFolder_ButDontShipItWithYourGame/il2cppOutput/Bulk_mscorlib_17.cpp | bsgbryan/MinTuts | a1bb11ccee0ff10e6a9594bdeb02d41f965df169 | [
"MIT"
] | null | null | null | Procedural Terrain_BackUpThisFolder_ButDontShipItWithYourGame/il2cppOutput/Bulk_mscorlib_17.cpp | bsgbryan/MinTuts | a1bb11ccee0ff10e6a9594bdeb02d41f965df169 | [
"MIT"
] | null | null | null | #include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include <stdint.h>
#include "il2cpp-class-internals.h"
#include "codegen/il2cpp-codegen.h"
#include "il2cpp-object-internals.h"
template <typename T1, typename T2>
struct VirtActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1>
struct VirtActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename R>
struct VirtFuncInvoker0
{
typedef R (*Func)(void*, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename R, typename T1>
struct VirtFuncInvoker1
{
typedef R (*Func)(void*, T1, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename R, typename T1, typename T2, typename T3>
struct VirtFuncInvoker3
{
typedef R (*Func)(void*, T1, T2, T3, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2, T3 p3)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, p2, p3, invokeData.method);
}
};
template <typename T1, typename T2>
struct GenericVirtActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1>
struct GenericVirtActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename T1, typename T2>
struct InterfaceActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1>
struct InterfaceActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename T1, typename T2>
struct GenericInterfaceActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1>
struct GenericInterfaceActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
// System.String
struct String_t;
// System.ArgumentException
struct ArgumentException_t132251570;
// System.Globalization.NumberFormatInfo
struct NumberFormatInfo_t435877138;
// System.IFormatProvider
struct IFormatProvider_t2518567562;
// System.Object[]
struct ObjectU5BU5D_t2843939325;
// System.InvalidCastException
struct InvalidCastException_t3927145244;
// System.Type
struct Type_t;
// System.IConvertible
struct IConvertible_t2977365677;
// System.Runtime.Serialization.SerializationInfo
struct SerializationInfo_t950877179;
// System.ArgumentNullException
struct ArgumentNullException_t1615371798;
// System.UnauthorizedAccessException
struct UnauthorizedAccessException_t490705335;
// System.SystemException
struct SystemException_t176217640;
// System.Exception
struct Exception_t;
// System.UnhandledExceptionEventArgs
struct UnhandledExceptionEventArgs_t2886101344;
// System.EventArgs
struct EventArgs_t3591816995;
// System.UnhandledExceptionEventHandler
struct UnhandledExceptionEventHandler_t3101989324;
// System.Delegate
struct Delegate_t1188392813;
// System.IAsyncResult
struct IAsyncResult_t767004451;
// System.AsyncCallback
struct AsyncCallback_t3962456242;
// System.Reflection.Missing
struct Missing_t508514592;
// System.RuntimeType
struct RuntimeType_t3636489352;
// System.Collections.Generic.List`1<System.Int32>
struct List_1_t128053199;
// System.Int32[]
struct Int32U5BU5D_t385246372;
// System.UnitySerializationHolder
struct UnitySerializationHolder_t431912834;
// System.Reflection.RuntimeAssembly
struct RuntimeAssembly_t1451753063;
// System.Reflection.Assembly
struct Assembly_t;
// System.Runtime.Serialization.SerializationException
struct SerializationException_t3941511869;
// System.NotSupportedException
struct NotSupportedException_t1314879016;
// System.Reflection.MethodBase
struct MethodBase_t;
// System.Reflection.Module
struct Module_t2987026101;
// System.IndexOutOfRangeException
struct IndexOutOfRangeException_t1578797820;
// System.Collections.IEqualityComparer
struct IEqualityComparer_t1493878338;
// System.Collections.IComparer
struct IComparer_t1540313114;
// System.ValueType
struct ValueType_t3640485471;
// System.Version
struct Version_t3456873960;
// System.ArgumentOutOfRangeException
struct ArgumentOutOfRangeException_t777629997;
// System.Text.StringBuilder
struct StringBuilder_t;
// System.WeakReference
struct WeakReference_t1334886716;
// System.WindowsConsoleDriver
struct WindowsConsoleDriver_t3991887195;
// System.InvalidOperationException
struct InvalidOperationException_t56020091;
// System.InputRecord
struct InputRecord_t2660212290;
// System.Byte[]
struct ByteU5BU5D_t4116647657;
// System.Char[]
struct CharU5BU5D_t3528271667;
// System.Type[]
struct TypeU5BU5D_t3940880105;
// System.Collections.IDictionary
struct IDictionary_t1363984059;
// System.Runtime.Serialization.SafeSerializationManager
struct SafeSerializationManager_t2481557153;
// System.Diagnostics.StackTrace[]
struct StackTraceU5BU5D_t1169129676;
// System.IntPtr[]
struct IntPtrU5BU5D_t4013366056;
// System.String[]
struct StringU5BU5D_t1281789340;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32>
struct Dictionary_2_t2736202052;
// System.Runtime.Serialization.IFormatterConverter
struct IFormatterConverter_t2171992254;
// System.Void
struct Void_t1185182177;
// System.Char
struct Char_t3634460470;
// System.UInt32[]
struct UInt32U5BU5D_t2770800703;
// System.Reflection.Assembly/ResolveEventHolder
struct ResolveEventHolder_t2120639521;
// System.Security.Policy.Evidence
struct Evidence_t2008144148;
// System.Security.PermissionSet
struct PermissionSet_t223948603;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// System.DelegateData
struct DelegateData_t1677132599;
// System.Delegate[]
struct DelegateU5BU5D_t1703627840;
// System.Reflection.MemberFilter
struct MemberFilter_t426314064;
// System.Reflection.Binder
struct Binder_t2999457153;
// System.Reflection.TypeFilter
struct TypeFilter_t2356120900;
// System.MonoTypeInfo
struct MonoTypeInfo_t3366989025;
// System.Reflection.RuntimeConstructorInfo
struct RuntimeConstructorInfo_t1806616898;
// System.Collections.Generic.Dictionary`2<System.Guid,System.Type>
struct Dictionary_2_t1532962293;
// System.Reflection.Emit.AssemblyBuilder
struct AssemblyBuilder_t359885250;
extern RuntimeClass* UInt32_t2560061978_il2cpp_TypeInfo_var;
extern RuntimeClass* ArgumentException_t132251570_il2cpp_TypeInfo_var;
extern const RuntimeMethod* UInt32_CompareTo_m362578384_RuntimeMethod_var;
extern String_t* _stringLiteral1622425596;
extern const uint32_t UInt32_CompareTo_m362578384_MetadataUsageId;
extern const uint32_t UInt32_Equals_m351935437_MetadataUsageId;
extern RuntimeClass* Convert_t2465617642_il2cpp_TypeInfo_var;
extern const uint32_t UInt32_System_IConvertible_ToBoolean_m1763673183_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToChar_m1873050533_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToSByte_m1061556466_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToByte_m4072781199_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToInt16_m1659441601_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToUInt16_m3125657960_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToInt32_m220754611_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToInt64_m2261037378_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToUInt64_m1094958903_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToSingle_m1272823424_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToDouble_m940039456_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToDecimal_m675004071_MetadataUsageId;
extern RuntimeClass* ObjectU5BU5D_t2843939325_il2cpp_TypeInfo_var;
extern RuntimeClass* InvalidCastException_t3927145244_il2cpp_TypeInfo_var;
extern const RuntimeMethod* UInt32_System_IConvertible_ToDateTime_m2767723441_RuntimeMethod_var;
extern String_t* _stringLiteral4287968739;
extern String_t* _stringLiteral2789887848;
extern String_t* _stringLiteral3798051137;
extern const uint32_t UInt32_System_IConvertible_ToDateTime_m2767723441_MetadataUsageId;
extern const uint32_t UInt32_System_IConvertible_ToType_m922356584_MetadataUsageId;
extern RuntimeClass* UInt64_t4134040092_il2cpp_TypeInfo_var;
extern const RuntimeMethod* UInt64_CompareTo_m3619843473_RuntimeMethod_var;
extern String_t* _stringLiteral2814066682;
extern const uint32_t UInt64_CompareTo_m3619843473_MetadataUsageId;
extern const uint32_t UInt64_Equals_m1879425698_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToBoolean_m3071416000_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToChar_m2074245892_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToSByte_m30962591_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToByte_m1501504925_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToInt16_m3895479143_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToUInt16_m4165747038_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToInt32_m949522652_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToUInt32_m2784653358_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToInt64_m4241475606_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToSingle_m925613075_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToDouble_m602078108_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToDecimal_m806594027_MetadataUsageId;
extern const RuntimeMethod* UInt64_System_IConvertible_ToDateTime_m3434604642_RuntimeMethod_var;
extern String_t* _stringLiteral2789494635;
extern const uint32_t UInt64_System_IConvertible_ToDateTime_m3434604642_MetadataUsageId;
extern const uint32_t UInt64_System_IConvertible_ToType_m4049257834_MetadataUsageId;
extern RuntimeClass* UIntPtr_t_il2cpp_TypeInfo_var;
extern const uint32_t UIntPtr_Equals_m1316671746_MetadataUsageId;
extern const uint32_t UIntPtr_ToString_m984583492_MetadataUsageId;
extern RuntimeClass* ArgumentNullException_t1615371798_il2cpp_TypeInfo_var;
extern const RuntimeMethod* UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_m1767630151_RuntimeMethod_var;
extern String_t* _stringLiteral79347;
extern String_t* _stringLiteral1363226343;
extern const uint32_t UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_m1767630151_MetadataUsageId;
extern const uint32_t UIntPtr__cctor_m3513964473_MetadataUsageId;
extern String_t* _stringLiteral2994918982;
extern const uint32_t UnauthorizedAccessException__ctor_m246605039_MetadataUsageId;
extern RuntimeClass* EventArgs_t3591816995_il2cpp_TypeInfo_var;
extern const uint32_t UnhandledExceptionEventArgs__ctor_m224348470_MetadataUsageId;
extern const RuntimeType* UnitySerializationHolder_t431912834_0_0_0_var;
extern RuntimeClass* Type_t_il2cpp_TypeInfo_var;
extern String_t* _stringLiteral3283586028;
extern const uint32_t UnitySerializationHolder_GetUnitySerializationInfo_m927411785_MetadataUsageId;
extern const RuntimeType* Int32U5BU5D_t385246372_0_0_0_var;
extern RuntimeClass* List_1_t128053199_il2cpp_TypeInfo_var;
extern RuntimeClass* RuntimeType_t3636489352_il2cpp_TypeInfo_var;
extern const RuntimeMethod* List_1__ctor_m1204004817_RuntimeMethod_var;
extern const RuntimeMethod* List_1_Add_m2080863212_RuntimeMethod_var;
extern const RuntimeMethod* List_1_ToArray_m1469074435_RuntimeMethod_var;
extern String_t* _stringLiteral3927933503;
extern const uint32_t UnitySerializationHolder_AddElementTypes_m2711578409_MetadataUsageId;
extern const RuntimeType* MethodBase_t_0_0_0_var;
extern const RuntimeType* Type_t_0_0_0_var;
extern const RuntimeType* TypeU5BU5D_t3940880105_0_0_0_var;
extern String_t* _stringLiteral3378664767;
extern String_t* _stringLiteral98117656;
extern String_t* _stringLiteral2725392681;
extern String_t* _stringLiteral1245918466;
extern const uint32_t UnitySerializationHolder_GetUnitySerializationInfo_m3060468266_MetadataUsageId;
extern const RuntimeType* String_t_0_0_0_var;
extern RuntimeClass* String_t_il2cpp_TypeInfo_var;
extern String_t* _stringLiteral2037252898;
extern String_t* _stringLiteral209558951;
extern const uint32_t UnitySerializationHolder_GetUnitySerializationInfo_m3966690610_MetadataUsageId;
extern RuntimeClass* MethodBase_t_il2cpp_TypeInfo_var;
extern RuntimeClass* Int32U5BU5D_t385246372_il2cpp_TypeInfo_var;
extern RuntimeClass* TypeU5BU5D_t3940880105_il2cpp_TypeInfo_var;
extern const RuntimeMethod* UnitySerializationHolder__ctor_m3869442095_RuntimeMethod_var;
extern const uint32_t UnitySerializationHolder__ctor_m3869442095_MetadataUsageId;
extern RuntimeClass* SerializationException_t3941511869_il2cpp_TypeInfo_var;
extern const RuntimeMethod* UnitySerializationHolder_ThrowInsufficientInformation_m1747464776_RuntimeMethod_var;
extern String_t* _stringLiteral3245515088;
extern const uint32_t UnitySerializationHolder_ThrowInsufficientInformation_m1747464776_MetadataUsageId;
extern RuntimeClass* NotSupportedException_t1314879016_il2cpp_TypeInfo_var;
extern const RuntimeMethod* UnitySerializationHolder_GetObjectData_m3377455907_RuntimeMethod_var;
extern String_t* _stringLiteral532335187;
extern const uint32_t UnitySerializationHolder_GetObjectData_m3377455907_MetadataUsageId;
extern RuntimeClass* Empty_t4129602447_il2cpp_TypeInfo_var;
extern RuntimeClass* DBNull_t3725197148_il2cpp_TypeInfo_var;
extern RuntimeClass* Missing_t508514592_il2cpp_TypeInfo_var;
extern RuntimeClass* Module_t2987026101_il2cpp_TypeInfo_var;
extern const RuntimeMethod* UnitySerializationHolder_GetRealObject_m1624354633_RuntimeMethod_var;
extern String_t* _stringLiteral1313207612;
extern String_t* _stringLiteral1498318814;
extern String_t* _stringLiteral3407159193;
extern const uint32_t UnitySerializationHolder_GetRealObject_m1624354633_MetadataUsageId;
extern RuntimeClass* IndexOutOfRangeException_t1578797820_il2cpp_TypeInfo_var;
extern const RuntimeMethod* UnSafeCharBuffer_AppendString_m2223303597_RuntimeMethod_var;
extern const uint32_t UnSafeCharBuffer_AppendString_m2223303597_MetadataUsageId;
extern RuntimeClass* ValueTuple_t3168505507_il2cpp_TypeInfo_var;
extern const uint32_t ValueTuple_Equals_m3777586424_MetadataUsageId;
extern const uint32_t ValueTuple_System_Collections_IStructuralEquatable_Equals_m1158377527_MetadataUsageId;
extern const RuntimeMethod* ValueTuple_System_IComparable_CompareTo_m3152321575_RuntimeMethod_var;
extern String_t* _stringLiteral4055290125;
extern String_t* _stringLiteral2432405111;
extern const uint32_t ValueTuple_System_IComparable_CompareTo_m3152321575_MetadataUsageId;
extern const RuntimeMethod* ValueTuple_System_Collections_IStructuralComparable_CompareTo_m1147772089_RuntimeMethod_var;
extern const uint32_t ValueTuple_System_Collections_IStructuralComparable_CompareTo_m1147772089_MetadataUsageId;
extern String_t* _stringLiteral3450976136;
extern const uint32_t ValueTuple_ToString_m2213345710_MetadataUsageId;
extern RuntimeClass* HashHelpers_t1653534276_il2cpp_TypeInfo_var;
extern const uint32_t ValueTuple_CombineHashCodes_m2782652282_MetadataUsageId;
extern const uint32_t ValueType_DefaultEquals_m2927252100_MetadataUsageId;
extern RuntimeClass* Marshal_t1757017490_il2cpp_TypeInfo_var;
extern RuntimeClass* IntPtr_t_il2cpp_TypeInfo_var;
extern const uint32_t Variant_Clear_m3388694274_MetadataUsageId;
extern RuntimeClass* ArgumentOutOfRangeException_t777629997_il2cpp_TypeInfo_var;
extern const RuntimeMethod* Version__ctor_m417728625_RuntimeMethod_var;
extern String_t* _stringLiteral419133523;
extern String_t* _stringLiteral2448690427;
extern String_t* _stringLiteral2762033855;
extern String_t* _stringLiteral437191301;
extern String_t* _stringLiteral3187820736;
extern const uint32_t Version__ctor_m417728625_MetadataUsageId;
extern const RuntimeMethod* Version__ctor_m3537335798_RuntimeMethod_var;
extern const uint32_t Version__ctor_m3537335798_MetadataUsageId;
extern RuntimeClass* Version_t3456873960_il2cpp_TypeInfo_var;
extern const uint32_t Version_Clone_m1749041863_MetadataUsageId;
extern const RuntimeMethod* Version_CompareTo_m1662919407_RuntimeMethod_var;
extern String_t* _stringLiteral1182144617;
extern const uint32_t Version_CompareTo_m1662919407_MetadataUsageId;
extern const uint32_t Version_CompareTo_m3146217210_MetadataUsageId;
extern const uint32_t Version_Equals_m3073813696_MetadataUsageId;
extern const uint32_t Version_Equals_m1564427710_MetadataUsageId;
extern const RuntimeMethod* Version_ToString_m3654989516_RuntimeMethod_var;
extern String_t* _stringLiteral3104458722;
extern String_t* _stringLiteral3452614544;
extern String_t* _stringLiteral3452614542;
extern String_t* _stringLiteral3976682977;
extern String_t* _stringLiteral3452614541;
extern String_t* _stringLiteral3452614540;
extern const uint32_t Version_ToString_m3654989516_MetadataUsageId;
extern const uint32_t Version_op_Inequality_m1696193441_MetadataUsageId;
extern const RuntimeMethod* Version_op_LessThan_m3745610070_RuntimeMethod_var;
extern String_t* _stringLiteral3451500490;
extern const uint32_t Version_op_LessThan_m3745610070_MetadataUsageId;
extern const RuntimeMethod* Version_op_LessThanOrEqual_m666140174_RuntimeMethod_var;
extern const uint32_t Version_op_LessThanOrEqual_m666140174_MetadataUsageId;
extern const uint32_t Version_op_GreaterThanOrEqual_m474945801_MetadataUsageId;
extern RuntimeClass* CharU5BU5D_t3528271667_il2cpp_TypeInfo_var;
extern const uint32_t Version__cctor_m3568671087_MetadataUsageId;
extern const RuntimeType* RuntimeObject_0_0_0_var;
extern const RuntimeMethod* WeakReference__ctor_m1244067698_RuntimeMethod_var;
extern String_t* _stringLiteral3234942771;
extern String_t* _stringLiteral2922588279;
extern const uint32_t WeakReference__ctor_m1244067698_MetadataUsageId;
extern RuntimeClass* Exception_t_il2cpp_TypeInfo_var;
extern const RuntimeMethod* WeakReference_GetObjectData_m2192383095_RuntimeMethod_var;
extern const uint32_t WeakReference_GetObjectData_m2192383095_MetadataUsageId;
extern RuntimeClass* Int32_t2950945753_il2cpp_TypeInfo_var;
extern RuntimeClass* InvalidOperationException_t56020091_il2cpp_TypeInfo_var;
extern const RuntimeMethod* WindowsConsoleDriver_ReadKey_m209631140_RuntimeMethod_var;
extern String_t* _stringLiteral1071424308;
extern const uint32_t WindowsConsoleDriver_ReadKey_m209631140_MetadataUsageId;
struct InputRecord_t2660212290_marshaled_pinvoke;
struct InputRecord_t2660212290;;
struct InputRecord_t2660212290_marshaled_pinvoke;;
extern const uint32_t CFHelpers_FetchString_m1875874129_MetadataUsageId;
extern RuntimeClass* ByteU5BU5D_t4116647657_il2cpp_TypeInfo_var;
extern const uint32_t CFHelpers_FetchDataBuffer_m2260522698_MetadataUsageId;
extern const uint32_t CFHelpers_CreateCertificateFromData_m702581168_MetadataUsageId;
struct Exception_t_marshaled_pinvoke;
struct Exception_t_marshaled_com;
struct Assembly_t_marshaled_pinvoke;
struct Assembly_t_marshaled_com;
struct ObjectU5BU5D_t2843939325;
struct DelegateU5BU5D_t1703627840;
struct Int32U5BU5D_t385246372;
struct TypeU5BU5D_t3940880105;
struct CharU5BU5D_t3528271667;
struct ByteU5BU5D_t4116647657;
#ifndef RUNTIMEOBJECT_H
#define RUNTIMEOBJECT_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Object
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEOBJECT_H
struct Il2CppArrayBounds;
#ifndef RUNTIMEARRAY_H
#define RUNTIMEARRAY_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Array
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEARRAY_H
#ifndef VALUETYPE_T3640485471_H
#define VALUETYPE_T3640485471_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ValueType
struct ValueType_t3640485471 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t3640485471_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t3640485471_marshaled_com
{
};
#endif // VALUETYPE_T3640485471_H
#ifndef DBNULL_T3725197148_H
#define DBNULL_T3725197148_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.DBNull
struct DBNull_t3725197148 : public RuntimeObject
{
public:
public:
};
struct DBNull_t3725197148_StaticFields
{
public:
// System.DBNull System.DBNull::Value
DBNull_t3725197148 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(DBNull_t3725197148_StaticFields, ___Value_0)); }
inline DBNull_t3725197148 * get_Value_0() const { return ___Value_0; }
inline DBNull_t3725197148 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(DBNull_t3725197148 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((&___Value_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DBNULL_T3725197148_H
#ifndef EMPTY_T4129602447_H
#define EMPTY_T4129602447_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Empty
struct Empty_t4129602447 : public RuntimeObject
{
public:
public:
};
struct Empty_t4129602447_StaticFields
{
public:
// System.Empty System.Empty::Value
Empty_t4129602447 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(Empty_t4129602447_StaticFields, ___Value_0)); }
inline Empty_t4129602447 * get_Value_0() const { return ___Value_0; }
inline Empty_t4129602447 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(Empty_t4129602447 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((&___Value_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // EMPTY_T4129602447_H
#ifndef VERSION_T3456873960_H
#define VERSION_T3456873960_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Version
struct Version_t3456873960 : public RuntimeObject
{
public:
// System.Int32 System.Version::_Major
int32_t ____Major_0;
// System.Int32 System.Version::_Minor
int32_t ____Minor_1;
// System.Int32 System.Version::_Build
int32_t ____Build_2;
// System.Int32 System.Version::_Revision
int32_t ____Revision_3;
public:
inline static int32_t get_offset_of__Major_0() { return static_cast<int32_t>(offsetof(Version_t3456873960, ____Major_0)); }
inline int32_t get__Major_0() const { return ____Major_0; }
inline int32_t* get_address_of__Major_0() { return &____Major_0; }
inline void set__Major_0(int32_t value)
{
____Major_0 = value;
}
inline static int32_t get_offset_of__Minor_1() { return static_cast<int32_t>(offsetof(Version_t3456873960, ____Minor_1)); }
inline int32_t get__Minor_1() const { return ____Minor_1; }
inline int32_t* get_address_of__Minor_1() { return &____Minor_1; }
inline void set__Minor_1(int32_t value)
{
____Minor_1 = value;
}
inline static int32_t get_offset_of__Build_2() { return static_cast<int32_t>(offsetof(Version_t3456873960, ____Build_2)); }
inline int32_t get__Build_2() const { return ____Build_2; }
inline int32_t* get_address_of__Build_2() { return &____Build_2; }
inline void set__Build_2(int32_t value)
{
____Build_2 = value;
}
inline static int32_t get_offset_of__Revision_3() { return static_cast<int32_t>(offsetof(Version_t3456873960, ____Revision_3)); }
inline int32_t get__Revision_3() const { return ____Revision_3; }
inline int32_t* get_address_of__Revision_3() { return &____Revision_3; }
inline void set__Revision_3(int32_t value)
{
____Revision_3 = value;
}
};
struct Version_t3456873960_StaticFields
{
public:
// System.Char[] System.Version::SeparatorsArray
CharU5BU5D_t3528271667* ___SeparatorsArray_4;
public:
inline static int32_t get_offset_of_SeparatorsArray_4() { return static_cast<int32_t>(offsetof(Version_t3456873960_StaticFields, ___SeparatorsArray_4)); }
inline CharU5BU5D_t3528271667* get_SeparatorsArray_4() const { return ___SeparatorsArray_4; }
inline CharU5BU5D_t3528271667** get_address_of_SeparatorsArray_4() { return &___SeparatorsArray_4; }
inline void set_SeparatorsArray_4(CharU5BU5D_t3528271667* value)
{
___SeparatorsArray_4 = value;
Il2CppCodeGenWriteBarrier((&___SeparatorsArray_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VERSION_T3456873960_H
#ifndef STRINGBUILDER_T_H
#define STRINGBUILDER_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Text.StringBuilder
struct StringBuilder_t : public RuntimeObject
{
public:
// System.Char[] System.Text.StringBuilder::m_ChunkChars
CharU5BU5D_t3528271667* ___m_ChunkChars_0;
// System.Text.StringBuilder System.Text.StringBuilder::m_ChunkPrevious
StringBuilder_t * ___m_ChunkPrevious_1;
// System.Int32 System.Text.StringBuilder::m_ChunkLength
int32_t ___m_ChunkLength_2;
// System.Int32 System.Text.StringBuilder::m_ChunkOffset
int32_t ___m_ChunkOffset_3;
// System.Int32 System.Text.StringBuilder::m_MaxCapacity
int32_t ___m_MaxCapacity_4;
public:
inline static int32_t get_offset_of_m_ChunkChars_0() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_ChunkChars_0)); }
inline CharU5BU5D_t3528271667* get_m_ChunkChars_0() const { return ___m_ChunkChars_0; }
inline CharU5BU5D_t3528271667** get_address_of_m_ChunkChars_0() { return &___m_ChunkChars_0; }
inline void set_m_ChunkChars_0(CharU5BU5D_t3528271667* value)
{
___m_ChunkChars_0 = value;
Il2CppCodeGenWriteBarrier((&___m_ChunkChars_0), value);
}
inline static int32_t get_offset_of_m_ChunkPrevious_1() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_ChunkPrevious_1)); }
inline StringBuilder_t * get_m_ChunkPrevious_1() const { return ___m_ChunkPrevious_1; }
inline StringBuilder_t ** get_address_of_m_ChunkPrevious_1() { return &___m_ChunkPrevious_1; }
inline void set_m_ChunkPrevious_1(StringBuilder_t * value)
{
___m_ChunkPrevious_1 = value;
Il2CppCodeGenWriteBarrier((&___m_ChunkPrevious_1), value);
}
inline static int32_t get_offset_of_m_ChunkLength_2() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_ChunkLength_2)); }
inline int32_t get_m_ChunkLength_2() const { return ___m_ChunkLength_2; }
inline int32_t* get_address_of_m_ChunkLength_2() { return &___m_ChunkLength_2; }
inline void set_m_ChunkLength_2(int32_t value)
{
___m_ChunkLength_2 = value;
}
inline static int32_t get_offset_of_m_ChunkOffset_3() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_ChunkOffset_3)); }
inline int32_t get_m_ChunkOffset_3() const { return ___m_ChunkOffset_3; }
inline int32_t* get_address_of_m_ChunkOffset_3() { return &___m_ChunkOffset_3; }
inline void set_m_ChunkOffset_3(int32_t value)
{
___m_ChunkOffset_3 = value;
}
inline static int32_t get_offset_of_m_MaxCapacity_4() { return static_cast<int32_t>(offsetof(StringBuilder_t, ___m_MaxCapacity_4)); }
inline int32_t get_m_MaxCapacity_4() const { return ___m_MaxCapacity_4; }
inline int32_t* get_address_of_m_MaxCapacity_4() { return &___m_MaxCapacity_4; }
inline void set_m_MaxCapacity_4(int32_t value)
{
___m_MaxCapacity_4 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STRINGBUILDER_T_H
#ifndef MEMBERINFO_T_H
#define MEMBERINFO_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.MemberInfo
struct MemberInfo_t : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MEMBERINFO_T_H
#ifndef LIST_1_T128053199_H
#define LIST_1_T128053199_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Collections.Generic.List`1<System.Int32>
struct List_1_t128053199 : public RuntimeObject
{
public:
// T[] System.Collections.Generic.List`1::_items
Int32U5BU5D_t385246372* ____items_1;
// System.Int32 System.Collections.Generic.List`1::_size
int32_t ____size_2;
// System.Int32 System.Collections.Generic.List`1::_version
int32_t ____version_3;
// System.Object System.Collections.Generic.List`1::_syncRoot
RuntimeObject * ____syncRoot_4;
public:
inline static int32_t get_offset_of__items_1() { return static_cast<int32_t>(offsetof(List_1_t128053199, ____items_1)); }
inline Int32U5BU5D_t385246372* get__items_1() const { return ____items_1; }
inline Int32U5BU5D_t385246372** get_address_of__items_1() { return &____items_1; }
inline void set__items_1(Int32U5BU5D_t385246372* value)
{
____items_1 = value;
Il2CppCodeGenWriteBarrier((&____items_1), value);
}
inline static int32_t get_offset_of__size_2() { return static_cast<int32_t>(offsetof(List_1_t128053199, ____size_2)); }
inline int32_t get__size_2() const { return ____size_2; }
inline int32_t* get_address_of__size_2() { return &____size_2; }
inline void set__size_2(int32_t value)
{
____size_2 = value;
}
inline static int32_t get_offset_of__version_3() { return static_cast<int32_t>(offsetof(List_1_t128053199, ____version_3)); }
inline int32_t get__version_3() const { return ____version_3; }
inline int32_t* get_address_of__version_3() { return &____version_3; }
inline void set__version_3(int32_t value)
{
____version_3 = value;
}
inline static int32_t get_offset_of__syncRoot_4() { return static_cast<int32_t>(offsetof(List_1_t128053199, ____syncRoot_4)); }
inline RuntimeObject * get__syncRoot_4() const { return ____syncRoot_4; }
inline RuntimeObject ** get_address_of__syncRoot_4() { return &____syncRoot_4; }
inline void set__syncRoot_4(RuntimeObject * value)
{
____syncRoot_4 = value;
Il2CppCodeGenWriteBarrier((&____syncRoot_4), value);
}
};
struct List_1_t128053199_StaticFields
{
public:
// T[] System.Collections.Generic.List`1::_emptyArray
Int32U5BU5D_t385246372* ____emptyArray_5;
public:
inline static int32_t get_offset_of__emptyArray_5() { return static_cast<int32_t>(offsetof(List_1_t128053199_StaticFields, ____emptyArray_5)); }
inline Int32U5BU5D_t385246372* get__emptyArray_5() const { return ____emptyArray_5; }
inline Int32U5BU5D_t385246372** get_address_of__emptyArray_5() { return &____emptyArray_5; }
inline void set__emptyArray_5(Int32U5BU5D_t385246372* value)
{
____emptyArray_5 = value;
Il2CppCodeGenWriteBarrier((&____emptyArray_5), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // LIST_1_T128053199_H
#ifndef MISSING_T508514592_H
#define MISSING_T508514592_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.Missing
struct Missing_t508514592 : public RuntimeObject
{
public:
public:
};
struct Missing_t508514592_StaticFields
{
public:
// System.Reflection.Missing System.Reflection.Missing::Value
Missing_t508514592 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(Missing_t508514592_StaticFields, ___Value_0)); }
inline Missing_t508514592 * get_Value_0() const { return ___Value_0; }
inline Missing_t508514592 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(Missing_t508514592 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((&___Value_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MISSING_T508514592_H
#ifndef UNITYSERIALIZATIONHOLDER_T431912834_H
#define UNITYSERIALIZATIONHOLDER_T431912834_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UnitySerializationHolder
struct UnitySerializationHolder_t431912834 : public RuntimeObject
{
public:
// System.Type[] System.UnitySerializationHolder::m_instantiation
TypeU5BU5D_t3940880105* ___m_instantiation_0;
// System.Int32[] System.UnitySerializationHolder::m_elementTypes
Int32U5BU5D_t385246372* ___m_elementTypes_1;
// System.Int32 System.UnitySerializationHolder::m_genericParameterPosition
int32_t ___m_genericParameterPosition_2;
// System.Type System.UnitySerializationHolder::m_declaringType
Type_t * ___m_declaringType_3;
// System.Reflection.MethodBase System.UnitySerializationHolder::m_declaringMethod
MethodBase_t * ___m_declaringMethod_4;
// System.String System.UnitySerializationHolder::m_data
String_t* ___m_data_5;
// System.String System.UnitySerializationHolder::m_assemblyName
String_t* ___m_assemblyName_6;
// System.Int32 System.UnitySerializationHolder::m_unityType
int32_t ___m_unityType_7;
public:
inline static int32_t get_offset_of_m_instantiation_0() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t431912834, ___m_instantiation_0)); }
inline TypeU5BU5D_t3940880105* get_m_instantiation_0() const { return ___m_instantiation_0; }
inline TypeU5BU5D_t3940880105** get_address_of_m_instantiation_0() { return &___m_instantiation_0; }
inline void set_m_instantiation_0(TypeU5BU5D_t3940880105* value)
{
___m_instantiation_0 = value;
Il2CppCodeGenWriteBarrier((&___m_instantiation_0), value);
}
inline static int32_t get_offset_of_m_elementTypes_1() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t431912834, ___m_elementTypes_1)); }
inline Int32U5BU5D_t385246372* get_m_elementTypes_1() const { return ___m_elementTypes_1; }
inline Int32U5BU5D_t385246372** get_address_of_m_elementTypes_1() { return &___m_elementTypes_1; }
inline void set_m_elementTypes_1(Int32U5BU5D_t385246372* value)
{
___m_elementTypes_1 = value;
Il2CppCodeGenWriteBarrier((&___m_elementTypes_1), value);
}
inline static int32_t get_offset_of_m_genericParameterPosition_2() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t431912834, ___m_genericParameterPosition_2)); }
inline int32_t get_m_genericParameterPosition_2() const { return ___m_genericParameterPosition_2; }
inline int32_t* get_address_of_m_genericParameterPosition_2() { return &___m_genericParameterPosition_2; }
inline void set_m_genericParameterPosition_2(int32_t value)
{
___m_genericParameterPosition_2 = value;
}
inline static int32_t get_offset_of_m_declaringType_3() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t431912834, ___m_declaringType_3)); }
inline Type_t * get_m_declaringType_3() const { return ___m_declaringType_3; }
inline Type_t ** get_address_of_m_declaringType_3() { return &___m_declaringType_3; }
inline void set_m_declaringType_3(Type_t * value)
{
___m_declaringType_3 = value;
Il2CppCodeGenWriteBarrier((&___m_declaringType_3), value);
}
inline static int32_t get_offset_of_m_declaringMethod_4() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t431912834, ___m_declaringMethod_4)); }
inline MethodBase_t * get_m_declaringMethod_4() const { return ___m_declaringMethod_4; }
inline MethodBase_t ** get_address_of_m_declaringMethod_4() { return &___m_declaringMethod_4; }
inline void set_m_declaringMethod_4(MethodBase_t * value)
{
___m_declaringMethod_4 = value;
Il2CppCodeGenWriteBarrier((&___m_declaringMethod_4), value);
}
inline static int32_t get_offset_of_m_data_5() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t431912834, ___m_data_5)); }
inline String_t* get_m_data_5() const { return ___m_data_5; }
inline String_t** get_address_of_m_data_5() { return &___m_data_5; }
inline void set_m_data_5(String_t* value)
{
___m_data_5 = value;
Il2CppCodeGenWriteBarrier((&___m_data_5), value);
}
inline static int32_t get_offset_of_m_assemblyName_6() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t431912834, ___m_assemblyName_6)); }
inline String_t* get_m_assemblyName_6() const { return ___m_assemblyName_6; }
inline String_t** get_address_of_m_assemblyName_6() { return &___m_assemblyName_6; }
inline void set_m_assemblyName_6(String_t* value)
{
___m_assemblyName_6 = value;
Il2CppCodeGenWriteBarrier((&___m_assemblyName_6), value);
}
inline static int32_t get_offset_of_m_unityType_7() { return static_cast<int32_t>(offsetof(UnitySerializationHolder_t431912834, ___m_unityType_7)); }
inline int32_t get_m_unityType_7() const { return ___m_unityType_7; }
inline int32_t* get_address_of_m_unityType_7() { return &___m_unityType_7; }
inline void set_m_unityType_7(int32_t value)
{
___m_unityType_7 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNITYSERIALIZATIONHOLDER_T431912834_H
#ifndef EVENTARGS_T3591816995_H
#define EVENTARGS_T3591816995_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.EventArgs
struct EventArgs_t3591816995 : public RuntimeObject
{
public:
public:
};
struct EventArgs_t3591816995_StaticFields
{
public:
// System.EventArgs System.EventArgs::Empty
EventArgs_t3591816995 * ___Empty_0;
public:
inline static int32_t get_offset_of_Empty_0() { return static_cast<int32_t>(offsetof(EventArgs_t3591816995_StaticFields, ___Empty_0)); }
inline EventArgs_t3591816995 * get_Empty_0() const { return ___Empty_0; }
inline EventArgs_t3591816995 ** get_address_of_Empty_0() { return &___Empty_0; }
inline void set_Empty_0(EventArgs_t3591816995 * value)
{
___Empty_0 = value;
Il2CppCodeGenWriteBarrier((&___Empty_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // EVENTARGS_T3591816995_H
#ifndef EXCEPTION_T_H
#define EXCEPTION_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Exception
struct Exception_t : public RuntimeObject
{
public:
// System.String System.Exception::_className
String_t* ____className_1;
// System.String System.Exception::_message
String_t* ____message_2;
// System.Collections.IDictionary System.Exception::_data
RuntimeObject* ____data_3;
// System.Exception System.Exception::_innerException
Exception_t * ____innerException_4;
// System.String System.Exception::_helpURL
String_t* ____helpURL_5;
// System.Object System.Exception::_stackTrace
RuntimeObject * ____stackTrace_6;
// System.String System.Exception::_stackTraceString
String_t* ____stackTraceString_7;
// System.String System.Exception::_remoteStackTraceString
String_t* ____remoteStackTraceString_8;
// System.Int32 System.Exception::_remoteStackIndex
int32_t ____remoteStackIndex_9;
// System.Object System.Exception::_dynamicMethods
RuntimeObject * ____dynamicMethods_10;
// System.Int32 System.Exception::_HResult
int32_t ____HResult_11;
// System.String System.Exception::_source
String_t* ____source_12;
// System.Runtime.Serialization.SafeSerializationManager System.Exception::_safeSerializationManager
SafeSerializationManager_t2481557153 * ____safeSerializationManager_13;
// System.Diagnostics.StackTrace[] System.Exception::captured_traces
StackTraceU5BU5D_t1169129676* ___captured_traces_14;
// System.IntPtr[] System.Exception::native_trace_ips
IntPtrU5BU5D_t4013366056* ___native_trace_ips_15;
public:
inline static int32_t get_offset_of__className_1() { return static_cast<int32_t>(offsetof(Exception_t, ____className_1)); }
inline String_t* get__className_1() const { return ____className_1; }
inline String_t** get_address_of__className_1() { return &____className_1; }
inline void set__className_1(String_t* value)
{
____className_1 = value;
Il2CppCodeGenWriteBarrier((&____className_1), value);
}
inline static int32_t get_offset_of__message_2() { return static_cast<int32_t>(offsetof(Exception_t, ____message_2)); }
inline String_t* get__message_2() const { return ____message_2; }
inline String_t** get_address_of__message_2() { return &____message_2; }
inline void set__message_2(String_t* value)
{
____message_2 = value;
Il2CppCodeGenWriteBarrier((&____message_2), value);
}
inline static int32_t get_offset_of__data_3() { return static_cast<int32_t>(offsetof(Exception_t, ____data_3)); }
inline RuntimeObject* get__data_3() const { return ____data_3; }
inline RuntimeObject** get_address_of__data_3() { return &____data_3; }
inline void set__data_3(RuntimeObject* value)
{
____data_3 = value;
Il2CppCodeGenWriteBarrier((&____data_3), value);
}
inline static int32_t get_offset_of__innerException_4() { return static_cast<int32_t>(offsetof(Exception_t, ____innerException_4)); }
inline Exception_t * get__innerException_4() const { return ____innerException_4; }
inline Exception_t ** get_address_of__innerException_4() { return &____innerException_4; }
inline void set__innerException_4(Exception_t * value)
{
____innerException_4 = value;
Il2CppCodeGenWriteBarrier((&____innerException_4), value);
}
inline static int32_t get_offset_of__helpURL_5() { return static_cast<int32_t>(offsetof(Exception_t, ____helpURL_5)); }
inline String_t* get__helpURL_5() const { return ____helpURL_5; }
inline String_t** get_address_of__helpURL_5() { return &____helpURL_5; }
inline void set__helpURL_5(String_t* value)
{
____helpURL_5 = value;
Il2CppCodeGenWriteBarrier((&____helpURL_5), value);
}
inline static int32_t get_offset_of__stackTrace_6() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTrace_6)); }
inline RuntimeObject * get__stackTrace_6() const { return ____stackTrace_6; }
inline RuntimeObject ** get_address_of__stackTrace_6() { return &____stackTrace_6; }
inline void set__stackTrace_6(RuntimeObject * value)
{
____stackTrace_6 = value;
Il2CppCodeGenWriteBarrier((&____stackTrace_6), value);
}
inline static int32_t get_offset_of__stackTraceString_7() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTraceString_7)); }
inline String_t* get__stackTraceString_7() const { return ____stackTraceString_7; }
inline String_t** get_address_of__stackTraceString_7() { return &____stackTraceString_7; }
inline void set__stackTraceString_7(String_t* value)
{
____stackTraceString_7 = value;
Il2CppCodeGenWriteBarrier((&____stackTraceString_7), value);
}
inline static int32_t get_offset_of__remoteStackTraceString_8() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackTraceString_8)); }
inline String_t* get__remoteStackTraceString_8() const { return ____remoteStackTraceString_8; }
inline String_t** get_address_of__remoteStackTraceString_8() { return &____remoteStackTraceString_8; }
inline void set__remoteStackTraceString_8(String_t* value)
{
____remoteStackTraceString_8 = value;
Il2CppCodeGenWriteBarrier((&____remoteStackTraceString_8), value);
}
inline static int32_t get_offset_of__remoteStackIndex_9() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackIndex_9)); }
inline int32_t get__remoteStackIndex_9() const { return ____remoteStackIndex_9; }
inline int32_t* get_address_of__remoteStackIndex_9() { return &____remoteStackIndex_9; }
inline void set__remoteStackIndex_9(int32_t value)
{
____remoteStackIndex_9 = value;
}
inline static int32_t get_offset_of__dynamicMethods_10() { return static_cast<int32_t>(offsetof(Exception_t, ____dynamicMethods_10)); }
inline RuntimeObject * get__dynamicMethods_10() const { return ____dynamicMethods_10; }
inline RuntimeObject ** get_address_of__dynamicMethods_10() { return &____dynamicMethods_10; }
inline void set__dynamicMethods_10(RuntimeObject * value)
{
____dynamicMethods_10 = value;
Il2CppCodeGenWriteBarrier((&____dynamicMethods_10), value);
}
inline static int32_t get_offset_of__HResult_11() { return static_cast<int32_t>(offsetof(Exception_t, ____HResult_11)); }
inline int32_t get__HResult_11() const { return ____HResult_11; }
inline int32_t* get_address_of__HResult_11() { return &____HResult_11; }
inline void set__HResult_11(int32_t value)
{
____HResult_11 = value;
}
inline static int32_t get_offset_of__source_12() { return static_cast<int32_t>(offsetof(Exception_t, ____source_12)); }
inline String_t* get__source_12() const { return ____source_12; }
inline String_t** get_address_of__source_12() { return &____source_12; }
inline void set__source_12(String_t* value)
{
____source_12 = value;
Il2CppCodeGenWriteBarrier((&____source_12), value);
}
inline static int32_t get_offset_of__safeSerializationManager_13() { return static_cast<int32_t>(offsetof(Exception_t, ____safeSerializationManager_13)); }
inline SafeSerializationManager_t2481557153 * get__safeSerializationManager_13() const { return ____safeSerializationManager_13; }
inline SafeSerializationManager_t2481557153 ** get_address_of__safeSerializationManager_13() { return &____safeSerializationManager_13; }
inline void set__safeSerializationManager_13(SafeSerializationManager_t2481557153 * value)
{
____safeSerializationManager_13 = value;
Il2CppCodeGenWriteBarrier((&____safeSerializationManager_13), value);
}
inline static int32_t get_offset_of_captured_traces_14() { return static_cast<int32_t>(offsetof(Exception_t, ___captured_traces_14)); }
inline StackTraceU5BU5D_t1169129676* get_captured_traces_14() const { return ___captured_traces_14; }
inline StackTraceU5BU5D_t1169129676** get_address_of_captured_traces_14() { return &___captured_traces_14; }
inline void set_captured_traces_14(StackTraceU5BU5D_t1169129676* value)
{
___captured_traces_14 = value;
Il2CppCodeGenWriteBarrier((&___captured_traces_14), value);
}
inline static int32_t get_offset_of_native_trace_ips_15() { return static_cast<int32_t>(offsetof(Exception_t, ___native_trace_ips_15)); }
inline IntPtrU5BU5D_t4013366056* get_native_trace_ips_15() const { return ___native_trace_ips_15; }
inline IntPtrU5BU5D_t4013366056** get_address_of_native_trace_ips_15() { return &___native_trace_ips_15; }
inline void set_native_trace_ips_15(IntPtrU5BU5D_t4013366056* value)
{
___native_trace_ips_15 = value;
Il2CppCodeGenWriteBarrier((&___native_trace_ips_15), value);
}
};
struct Exception_t_StaticFields
{
public:
// System.Object System.Exception::s_EDILock
RuntimeObject * ___s_EDILock_0;
public:
inline static int32_t get_offset_of_s_EDILock_0() { return static_cast<int32_t>(offsetof(Exception_t_StaticFields, ___s_EDILock_0)); }
inline RuntimeObject * get_s_EDILock_0() const { return ___s_EDILock_0; }
inline RuntimeObject ** get_address_of_s_EDILock_0() { return &___s_EDILock_0; }
inline void set_s_EDILock_0(RuntimeObject * value)
{
___s_EDILock_0 = value;
Il2CppCodeGenWriteBarrier((&___s_EDILock_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Exception
struct Exception_t_marshaled_pinvoke
{
char* ____className_1;
char* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_pinvoke* ____innerException_4;
char* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
char* ____stackTraceString_7;
char* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
char* ____source_12;
SafeSerializationManager_t2481557153 * ____safeSerializationManager_13;
StackTraceU5BU5D_t1169129676* ___captured_traces_14;
intptr_t* ___native_trace_ips_15;
};
// Native definition for COM marshalling of System.Exception
struct Exception_t_marshaled_com
{
Il2CppChar* ____className_1;
Il2CppChar* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_com* ____innerException_4;
Il2CppChar* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
Il2CppChar* ____stackTraceString_7;
Il2CppChar* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
Il2CppChar* ____source_12;
SafeSerializationManager_t2481557153 * ____safeSerializationManager_13;
StackTraceU5BU5D_t1169129676* ___captured_traces_14;
intptr_t* ___native_trace_ips_15;
};
#endif // EXCEPTION_T_H
#ifndef CFHELPERS_T2851749608_H
#define CFHELPERS_T2851749608_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// XamMac.CoreFoundation.CFHelpers
struct CFHelpers_t2851749608 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CFHELPERS_T2851749608_H
#ifndef SERIALIZATIONINFO_T950877179_H
#define SERIALIZATIONINFO_T950877179_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.SerializationInfo
struct SerializationInfo_t950877179 : public RuntimeObject
{
public:
// System.String[] System.Runtime.Serialization.SerializationInfo::m_members
StringU5BU5D_t1281789340* ___m_members_0;
// System.Object[] System.Runtime.Serialization.SerializationInfo::m_data
ObjectU5BU5D_t2843939325* ___m_data_1;
// System.Type[] System.Runtime.Serialization.SerializationInfo::m_types
TypeU5BU5D_t3940880105* ___m_types_2;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32> System.Runtime.Serialization.SerializationInfo::m_nameToIndex
Dictionary_2_t2736202052 * ___m_nameToIndex_3;
// System.Int32 System.Runtime.Serialization.SerializationInfo::m_currMember
int32_t ___m_currMember_4;
// System.Runtime.Serialization.IFormatterConverter System.Runtime.Serialization.SerializationInfo::m_converter
RuntimeObject* ___m_converter_5;
// System.String System.Runtime.Serialization.SerializationInfo::m_fullTypeName
String_t* ___m_fullTypeName_6;
// System.String System.Runtime.Serialization.SerializationInfo::m_assemName
String_t* ___m_assemName_7;
// System.Type System.Runtime.Serialization.SerializationInfo::objectType
Type_t * ___objectType_8;
// System.Boolean System.Runtime.Serialization.SerializationInfo::isFullTypeNameSetExplicit
bool ___isFullTypeNameSetExplicit_9;
// System.Boolean System.Runtime.Serialization.SerializationInfo::isAssemblyNameSetExplicit
bool ___isAssemblyNameSetExplicit_10;
// System.Boolean System.Runtime.Serialization.SerializationInfo::requireSameTokenInPartialTrust
bool ___requireSameTokenInPartialTrust_11;
public:
inline static int32_t get_offset_of_m_members_0() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___m_members_0)); }
inline StringU5BU5D_t1281789340* get_m_members_0() const { return ___m_members_0; }
inline StringU5BU5D_t1281789340** get_address_of_m_members_0() { return &___m_members_0; }
inline void set_m_members_0(StringU5BU5D_t1281789340* value)
{
___m_members_0 = value;
Il2CppCodeGenWriteBarrier((&___m_members_0), value);
}
inline static int32_t get_offset_of_m_data_1() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___m_data_1)); }
inline ObjectU5BU5D_t2843939325* get_m_data_1() const { return ___m_data_1; }
inline ObjectU5BU5D_t2843939325** get_address_of_m_data_1() { return &___m_data_1; }
inline void set_m_data_1(ObjectU5BU5D_t2843939325* value)
{
___m_data_1 = value;
Il2CppCodeGenWriteBarrier((&___m_data_1), value);
}
inline static int32_t get_offset_of_m_types_2() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___m_types_2)); }
inline TypeU5BU5D_t3940880105* get_m_types_2() const { return ___m_types_2; }
inline TypeU5BU5D_t3940880105** get_address_of_m_types_2() { return &___m_types_2; }
inline void set_m_types_2(TypeU5BU5D_t3940880105* value)
{
___m_types_2 = value;
Il2CppCodeGenWriteBarrier((&___m_types_2), value);
}
inline static int32_t get_offset_of_m_nameToIndex_3() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___m_nameToIndex_3)); }
inline Dictionary_2_t2736202052 * get_m_nameToIndex_3() const { return ___m_nameToIndex_3; }
inline Dictionary_2_t2736202052 ** get_address_of_m_nameToIndex_3() { return &___m_nameToIndex_3; }
inline void set_m_nameToIndex_3(Dictionary_2_t2736202052 * value)
{
___m_nameToIndex_3 = value;
Il2CppCodeGenWriteBarrier((&___m_nameToIndex_3), value);
}
inline static int32_t get_offset_of_m_currMember_4() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___m_currMember_4)); }
inline int32_t get_m_currMember_4() const { return ___m_currMember_4; }
inline int32_t* get_address_of_m_currMember_4() { return &___m_currMember_4; }
inline void set_m_currMember_4(int32_t value)
{
___m_currMember_4 = value;
}
inline static int32_t get_offset_of_m_converter_5() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___m_converter_5)); }
inline RuntimeObject* get_m_converter_5() const { return ___m_converter_5; }
inline RuntimeObject** get_address_of_m_converter_5() { return &___m_converter_5; }
inline void set_m_converter_5(RuntimeObject* value)
{
___m_converter_5 = value;
Il2CppCodeGenWriteBarrier((&___m_converter_5), value);
}
inline static int32_t get_offset_of_m_fullTypeName_6() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___m_fullTypeName_6)); }
inline String_t* get_m_fullTypeName_6() const { return ___m_fullTypeName_6; }
inline String_t** get_address_of_m_fullTypeName_6() { return &___m_fullTypeName_6; }
inline void set_m_fullTypeName_6(String_t* value)
{
___m_fullTypeName_6 = value;
Il2CppCodeGenWriteBarrier((&___m_fullTypeName_6), value);
}
inline static int32_t get_offset_of_m_assemName_7() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___m_assemName_7)); }
inline String_t* get_m_assemName_7() const { return ___m_assemName_7; }
inline String_t** get_address_of_m_assemName_7() { return &___m_assemName_7; }
inline void set_m_assemName_7(String_t* value)
{
___m_assemName_7 = value;
Il2CppCodeGenWriteBarrier((&___m_assemName_7), value);
}
inline static int32_t get_offset_of_objectType_8() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___objectType_8)); }
inline Type_t * get_objectType_8() const { return ___objectType_8; }
inline Type_t ** get_address_of_objectType_8() { return &___objectType_8; }
inline void set_objectType_8(Type_t * value)
{
___objectType_8 = value;
Il2CppCodeGenWriteBarrier((&___objectType_8), value);
}
inline static int32_t get_offset_of_isFullTypeNameSetExplicit_9() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___isFullTypeNameSetExplicit_9)); }
inline bool get_isFullTypeNameSetExplicit_9() const { return ___isFullTypeNameSetExplicit_9; }
inline bool* get_address_of_isFullTypeNameSetExplicit_9() { return &___isFullTypeNameSetExplicit_9; }
inline void set_isFullTypeNameSetExplicit_9(bool value)
{
___isFullTypeNameSetExplicit_9 = value;
}
inline static int32_t get_offset_of_isAssemblyNameSetExplicit_10() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___isAssemblyNameSetExplicit_10)); }
inline bool get_isAssemblyNameSetExplicit_10() const { return ___isAssemblyNameSetExplicit_10; }
inline bool* get_address_of_isAssemblyNameSetExplicit_10() { return &___isAssemblyNameSetExplicit_10; }
inline void set_isAssemblyNameSetExplicit_10(bool value)
{
___isAssemblyNameSetExplicit_10 = value;
}
inline static int32_t get_offset_of_requireSameTokenInPartialTrust_11() { return static_cast<int32_t>(offsetof(SerializationInfo_t950877179, ___requireSameTokenInPartialTrust_11)); }
inline bool get_requireSameTokenInPartialTrust_11() const { return ___requireSameTokenInPartialTrust_11; }
inline bool* get_address_of_requireSameTokenInPartialTrust_11() { return &___requireSameTokenInPartialTrust_11; }
inline void set_requireSameTokenInPartialTrust_11(bool value)
{
___requireSameTokenInPartialTrust_11 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SERIALIZATIONINFO_T950877179_H
#ifndef HASHHELPERS_T1653534276_H
#define HASHHELPERS_T1653534276_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Numerics.Hashing.HashHelpers
struct HashHelpers_t1653534276 : public RuntimeObject
{
public:
public:
};
struct HashHelpers_t1653534276_StaticFields
{
public:
// System.Int32 System.Numerics.Hashing.HashHelpers::RandomSeed
int32_t ___RandomSeed_0;
public:
inline static int32_t get_offset_of_RandomSeed_0() { return static_cast<int32_t>(offsetof(HashHelpers_t1653534276_StaticFields, ___RandomSeed_0)); }
inline int32_t get_RandomSeed_0() const { return ___RandomSeed_0; }
inline int32_t* get_address_of_RandomSeed_0() { return &___RandomSeed_0; }
inline void set_RandomSeed_0(int32_t value)
{
___RandomSeed_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HASHHELPERS_T1653534276_H
#ifndef STRING_T_H
#define STRING_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.String
struct String_t : public RuntimeObject
{
public:
// System.Int32 System.String::m_stringLength
int32_t ___m_stringLength_0;
// System.Char System.String::m_firstChar
Il2CppChar ___m_firstChar_1;
public:
inline static int32_t get_offset_of_m_stringLength_0() { return static_cast<int32_t>(offsetof(String_t, ___m_stringLength_0)); }
inline int32_t get_m_stringLength_0() const { return ___m_stringLength_0; }
inline int32_t* get_address_of_m_stringLength_0() { return &___m_stringLength_0; }
inline void set_m_stringLength_0(int32_t value)
{
___m_stringLength_0 = value;
}
inline static int32_t get_offset_of_m_firstChar_1() { return static_cast<int32_t>(offsetof(String_t, ___m_firstChar_1)); }
inline Il2CppChar get_m_firstChar_1() const { return ___m_firstChar_1; }
inline Il2CppChar* get_address_of_m_firstChar_1() { return &___m_firstChar_1; }
inline void set_m_firstChar_1(Il2CppChar value)
{
___m_firstChar_1 = value;
}
};
struct String_t_StaticFields
{
public:
// System.String System.String::Empty
String_t* ___Empty_5;
public:
inline static int32_t get_offset_of_Empty_5() { return static_cast<int32_t>(offsetof(String_t_StaticFields, ___Empty_5)); }
inline String_t* get_Empty_5() const { return ___Empty_5; }
inline String_t** get_address_of_Empty_5() { return &___Empty_5; }
inline void set_Empty_5(String_t* value)
{
___Empty_5 = value;
Il2CppCodeGenWriteBarrier((&___Empty_5), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STRING_T_H
#ifndef INT64_T3736567304_H
#define INT64_T3736567304_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int64
struct Int64_t3736567304
{
public:
// System.Int64 System.Int64::m_value
int64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int64_t3736567304, ___m_value_0)); }
inline int64_t get_m_value_0() const { return ___m_value_0; }
inline int64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int64_t value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT64_T3736567304_H
#ifndef GCHANDLE_T3351438187_H
#define GCHANDLE_T3351438187_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.InteropServices.GCHandle
struct GCHandle_t3351438187
{
public:
// System.Int32 System.Runtime.InteropServices.GCHandle::handle
int32_t ___handle_0;
public:
inline static int32_t get_offset_of_handle_0() { return static_cast<int32_t>(offsetof(GCHandle_t3351438187, ___handle_0)); }
inline int32_t get_handle_0() const { return ___handle_0; }
inline int32_t* get_address_of_handle_0() { return &___handle_0; }
inline void set_handle_0(int32_t value)
{
___handle_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GCHANDLE_T3351438187_H
#ifndef SMALLRECT_T2930836963_H
#define SMALLRECT_T2930836963_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.SmallRect
struct SmallRect_t2930836963
{
public:
// System.Int16 System.SmallRect::Left
int16_t ___Left_0;
// System.Int16 System.SmallRect::Top
int16_t ___Top_1;
// System.Int16 System.SmallRect::Right
int16_t ___Right_2;
// System.Int16 System.SmallRect::Bottom
int16_t ___Bottom_3;
public:
inline static int32_t get_offset_of_Left_0() { return static_cast<int32_t>(offsetof(SmallRect_t2930836963, ___Left_0)); }
inline int16_t get_Left_0() const { return ___Left_0; }
inline int16_t* get_address_of_Left_0() { return &___Left_0; }
inline void set_Left_0(int16_t value)
{
___Left_0 = value;
}
inline static int32_t get_offset_of_Top_1() { return static_cast<int32_t>(offsetof(SmallRect_t2930836963, ___Top_1)); }
inline int16_t get_Top_1() const { return ___Top_1; }
inline int16_t* get_address_of_Top_1() { return &___Top_1; }
inline void set_Top_1(int16_t value)
{
___Top_1 = value;
}
inline static int32_t get_offset_of_Right_2() { return static_cast<int32_t>(offsetof(SmallRect_t2930836963, ___Right_2)); }
inline int16_t get_Right_2() const { return ___Right_2; }
inline int16_t* get_address_of_Right_2() { return &___Right_2; }
inline void set_Right_2(int16_t value)
{
___Right_2 = value;
}
inline static int32_t get_offset_of_Bottom_3() { return static_cast<int32_t>(offsetof(SmallRect_t2930836963, ___Bottom_3)); }
inline int16_t get_Bottom_3() const { return ___Bottom_3; }
inline int16_t* get_address_of_Bottom_3() { return &___Bottom_3; }
inline void set_Bottom_3(int16_t value)
{
___Bottom_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SMALLRECT_T2930836963_H
#ifndef VOID_T1185182177_H
#define VOID_T1185182177_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void
struct Void_t1185182177
{
public:
union
{
struct
{
};
uint8_t Void_t1185182177__padding[1];
};
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VOID_T1185182177_H
#ifndef COORD_T397375283_H
#define COORD_T397375283_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Coord
struct Coord_t397375283
{
public:
// System.Int16 System.Coord::X
int16_t ___X_0;
// System.Int16 System.Coord::Y
int16_t ___Y_1;
public:
inline static int32_t get_offset_of_X_0() { return static_cast<int32_t>(offsetof(Coord_t397375283, ___X_0)); }
inline int16_t get_X_0() const { return ___X_0; }
inline int16_t* get_address_of_X_0() { return &___X_0; }
inline void set_X_0(int16_t value)
{
___X_0 = value;
}
inline static int32_t get_offset_of_Y_1() { return static_cast<int32_t>(offsetof(Coord_t397375283, ___Y_1)); }
inline int16_t get_Y_1() const { return ___Y_1; }
inline int16_t* get_address_of_Y_1() { return &___Y_1; }
inline void set_Y_1(int16_t value)
{
___Y_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COORD_T397375283_H
#ifndef INT32_T2950945753_H
#define INT32_T2950945753_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int32
struct Int32_t2950945753
{
public:
// System.Int32 System.Int32::m_value
int32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int32_t2950945753, ___m_value_0)); }
inline int32_t get_m_value_0() const { return ___m_value_0; }
inline int32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int32_t value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT32_T2950945753_H
#ifndef UINT16_T2177724958_H
#define UINT16_T2177724958_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UInt16
struct UInt16_t2177724958
{
public:
// System.UInt16 System.UInt16::m_value
uint16_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt16_t2177724958, ___m_value_0)); }
inline uint16_t get_m_value_0() const { return ___m_value_0; }
inline uint16_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint16_t value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UINT16_T2177724958_H
#ifndef INTPTR_T_H
#define INTPTR_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.IntPtr
struct IntPtr_t
{
public:
// System.Void* System.IntPtr::m_value
void* ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
inline void* get_m_value_0() const { return ___m_value_0; }
inline void** get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(void* value)
{
___m_value_0 = value;
}
};
struct IntPtr_t_StaticFields
{
public:
// System.IntPtr System.IntPtr::Zero
intptr_t ___Zero_1;
public:
inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
inline intptr_t get_Zero_1() const { return ___Zero_1; }
inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
inline void set_Zero_1(intptr_t value)
{
___Zero_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INTPTR_T_H
#ifndef INPUTRECORD_T2660212290_H
#define INPUTRECORD_T2660212290_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.InputRecord
struct InputRecord_t2660212290
{
public:
// System.Int16 System.InputRecord::EventType
int16_t ___EventType_0;
// System.Boolean System.InputRecord::KeyDown
bool ___KeyDown_1;
// System.Int16 System.InputRecord::RepeatCount
int16_t ___RepeatCount_2;
// System.Int16 System.InputRecord::VirtualKeyCode
int16_t ___VirtualKeyCode_3;
// System.Int16 System.InputRecord::VirtualScanCode
int16_t ___VirtualScanCode_4;
// System.Char System.InputRecord::Character
Il2CppChar ___Character_5;
// System.Int32 System.InputRecord::ControlKeyState
int32_t ___ControlKeyState_6;
// System.Int32 System.InputRecord::pad1
int32_t ___pad1_7;
// System.Boolean System.InputRecord::pad2
bool ___pad2_8;
public:
inline static int32_t get_offset_of_EventType_0() { return static_cast<int32_t>(offsetof(InputRecord_t2660212290, ___EventType_0)); }
inline int16_t get_EventType_0() const { return ___EventType_0; }
inline int16_t* get_address_of_EventType_0() { return &___EventType_0; }
inline void set_EventType_0(int16_t value)
{
___EventType_0 = value;
}
inline static int32_t get_offset_of_KeyDown_1() { return static_cast<int32_t>(offsetof(InputRecord_t2660212290, ___KeyDown_1)); }
inline bool get_KeyDown_1() const { return ___KeyDown_1; }
inline bool* get_address_of_KeyDown_1() { return &___KeyDown_1; }
inline void set_KeyDown_1(bool value)
{
___KeyDown_1 = value;
}
inline static int32_t get_offset_of_RepeatCount_2() { return static_cast<int32_t>(offsetof(InputRecord_t2660212290, ___RepeatCount_2)); }
inline int16_t get_RepeatCount_2() const { return ___RepeatCount_2; }
inline int16_t* get_address_of_RepeatCount_2() { return &___RepeatCount_2; }
inline void set_RepeatCount_2(int16_t value)
{
___RepeatCount_2 = value;
}
inline static int32_t get_offset_of_VirtualKeyCode_3() { return static_cast<int32_t>(offsetof(InputRecord_t2660212290, ___VirtualKeyCode_3)); }
inline int16_t get_VirtualKeyCode_3() const { return ___VirtualKeyCode_3; }
inline int16_t* get_address_of_VirtualKeyCode_3() { return &___VirtualKeyCode_3; }
inline void set_VirtualKeyCode_3(int16_t value)
{
___VirtualKeyCode_3 = value;
}
inline static int32_t get_offset_of_VirtualScanCode_4() { return static_cast<int32_t>(offsetof(InputRecord_t2660212290, ___VirtualScanCode_4)); }
inline int16_t get_VirtualScanCode_4() const { return ___VirtualScanCode_4; }
inline int16_t* get_address_of_VirtualScanCode_4() { return &___VirtualScanCode_4; }
inline void set_VirtualScanCode_4(int16_t value)
{
___VirtualScanCode_4 = value;
}
inline static int32_t get_offset_of_Character_5() { return static_cast<int32_t>(offsetof(InputRecord_t2660212290, ___Character_5)); }
inline Il2CppChar get_Character_5() const { return ___Character_5; }
inline Il2CppChar* get_address_of_Character_5() { return &___Character_5; }
inline void set_Character_5(Il2CppChar value)
{
___Character_5 = value;
}
inline static int32_t get_offset_of_ControlKeyState_6() { return static_cast<int32_t>(offsetof(InputRecord_t2660212290, ___ControlKeyState_6)); }
inline int32_t get_ControlKeyState_6() const { return ___ControlKeyState_6; }
inline int32_t* get_address_of_ControlKeyState_6() { return &___ControlKeyState_6; }
inline void set_ControlKeyState_6(int32_t value)
{
___ControlKeyState_6 = value;
}
inline static int32_t get_offset_of_pad1_7() { return static_cast<int32_t>(offsetof(InputRecord_t2660212290, ___pad1_7)); }
inline int32_t get_pad1_7() const { return ___pad1_7; }
inline int32_t* get_address_of_pad1_7() { return &___pad1_7; }
inline void set_pad1_7(int32_t value)
{
___pad1_7 = value;
}
inline static int32_t get_offset_of_pad2_8() { return static_cast<int32_t>(offsetof(InputRecord_t2660212290, ___pad2_8)); }
inline bool get_pad2_8() const { return ___pad2_8; }
inline bool* get_address_of_pad2_8() { return &___pad2_8; }
inline void set_pad2_8(bool value)
{
___pad2_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.InputRecord
struct InputRecord_t2660212290_marshaled_pinvoke
{
int16_t ___EventType_0;
int32_t ___KeyDown_1;
int16_t ___RepeatCount_2;
int16_t ___VirtualKeyCode_3;
int16_t ___VirtualScanCode_4;
uint8_t ___Character_5;
int32_t ___ControlKeyState_6;
int32_t ___pad1_7;
int32_t ___pad2_8;
};
// Native definition for COM marshalling of System.InputRecord
struct InputRecord_t2660212290_marshaled_com
{
int16_t ___EventType_0;
int32_t ___KeyDown_1;
int16_t ___RepeatCount_2;
int16_t ___VirtualKeyCode_3;
int16_t ___VirtualScanCode_4;
uint8_t ___Character_5;
int32_t ___ControlKeyState_6;
int32_t ___pad1_7;
int32_t ___pad2_8;
};
#endif // INPUTRECORD_T2660212290_H
#ifndef CHAR_T3634460470_H
#define CHAR_T3634460470_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Char
struct Char_t3634460470
{
public:
// System.Char System.Char::m_value
Il2CppChar ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Char_t3634460470, ___m_value_0)); }
inline Il2CppChar get_m_value_0() const { return ___m_value_0; }
inline Il2CppChar* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(Il2CppChar value)
{
___m_value_0 = value;
}
};
struct Char_t3634460470_StaticFields
{
public:
// System.Byte[] System.Char::categoryForLatin1
ByteU5BU5D_t4116647657* ___categoryForLatin1_3;
public:
inline static int32_t get_offset_of_categoryForLatin1_3() { return static_cast<int32_t>(offsetof(Char_t3634460470_StaticFields, ___categoryForLatin1_3)); }
inline ByteU5BU5D_t4116647657* get_categoryForLatin1_3() const { return ___categoryForLatin1_3; }
inline ByteU5BU5D_t4116647657** get_address_of_categoryForLatin1_3() { return &___categoryForLatin1_3; }
inline void set_categoryForLatin1_3(ByteU5BU5D_t4116647657* value)
{
___categoryForLatin1_3 = value;
Il2CppCodeGenWriteBarrier((&___categoryForLatin1_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CHAR_T3634460470_H
#ifndef UNHANDLEDEXCEPTIONEVENTARGS_T2886101344_H
#define UNHANDLEDEXCEPTIONEVENTARGS_T2886101344_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UnhandledExceptionEventArgs
struct UnhandledExceptionEventArgs_t2886101344 : public EventArgs_t3591816995
{
public:
// System.Object System.UnhandledExceptionEventArgs::_Exception
RuntimeObject * ____Exception_1;
// System.Boolean System.UnhandledExceptionEventArgs::_IsTerminating
bool ____IsTerminating_2;
public:
inline static int32_t get_offset_of__Exception_1() { return static_cast<int32_t>(offsetof(UnhandledExceptionEventArgs_t2886101344, ____Exception_1)); }
inline RuntimeObject * get__Exception_1() const { return ____Exception_1; }
inline RuntimeObject ** get_address_of__Exception_1() { return &____Exception_1; }
inline void set__Exception_1(RuntimeObject * value)
{
____Exception_1 = value;
Il2CppCodeGenWriteBarrier((&____Exception_1), value);
}
inline static int32_t get_offset_of__IsTerminating_2() { return static_cast<int32_t>(offsetof(UnhandledExceptionEventArgs_t2886101344, ____IsTerminating_2)); }
inline bool get__IsTerminating_2() const { return ____IsTerminating_2; }
inline bool* get_address_of__IsTerminating_2() { return &____IsTerminating_2; }
inline void set__IsTerminating_2(bool value)
{
____IsTerminating_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNHANDLEDEXCEPTIONEVENTARGS_T2886101344_H
#ifndef METHODBASE_T_H
#define METHODBASE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.MethodBase
struct MethodBase_t : public MemberInfo_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // METHODBASE_T_H
#ifndef SBYTE_T1669577662_H
#define SBYTE_T1669577662_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.SByte
struct SByte_t1669577662
{
public:
// System.SByte System.SByte::m_value
int8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(SByte_t1669577662, ___m_value_0)); }
inline int8_t get_m_value_0() const { return ___m_value_0; }
inline int8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int8_t value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SBYTE_T1669577662_H
#ifndef UNSAFECHARBUFFER_T2176740272_H
#define UNSAFECHARBUFFER_T2176740272_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UnSafeCharBuffer
struct UnSafeCharBuffer_t2176740272
{
public:
// System.Char* System.UnSafeCharBuffer::m_buffer
Il2CppChar* ___m_buffer_0;
// System.Int32 System.UnSafeCharBuffer::m_totalSize
int32_t ___m_totalSize_1;
// System.Int32 System.UnSafeCharBuffer::m_length
int32_t ___m_length_2;
public:
inline static int32_t get_offset_of_m_buffer_0() { return static_cast<int32_t>(offsetof(UnSafeCharBuffer_t2176740272, ___m_buffer_0)); }
inline Il2CppChar* get_m_buffer_0() const { return ___m_buffer_0; }
inline Il2CppChar** get_address_of_m_buffer_0() { return &___m_buffer_0; }
inline void set_m_buffer_0(Il2CppChar* value)
{
___m_buffer_0 = value;
}
inline static int32_t get_offset_of_m_totalSize_1() { return static_cast<int32_t>(offsetof(UnSafeCharBuffer_t2176740272, ___m_totalSize_1)); }
inline int32_t get_m_totalSize_1() const { return ___m_totalSize_1; }
inline int32_t* get_address_of_m_totalSize_1() { return &___m_totalSize_1; }
inline void set_m_totalSize_1(int32_t value)
{
___m_totalSize_1 = value;
}
inline static int32_t get_offset_of_m_length_2() { return static_cast<int32_t>(offsetof(UnSafeCharBuffer_t2176740272, ___m_length_2)); }
inline int32_t get_m_length_2() const { return ___m_length_2; }
inline int32_t* get_address_of_m_length_2() { return &___m_length_2; }
inline void set_m_length_2(int32_t value)
{
___m_length_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.UnSafeCharBuffer
struct UnSafeCharBuffer_t2176740272_marshaled_pinvoke
{
Il2CppChar* ___m_buffer_0;
int32_t ___m_totalSize_1;
int32_t ___m_length_2;
};
// Native definition for COM marshalling of System.UnSafeCharBuffer
struct UnSafeCharBuffer_t2176740272_marshaled_com
{
Il2CppChar* ___m_buffer_0;
int32_t ___m_totalSize_1;
int32_t ___m_length_2;
};
#endif // UNSAFECHARBUFFER_T2176740272_H
#ifndef VALUETUPLE_T3168505507_H
#define VALUETUPLE_T3168505507_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ValueTuple
struct ValueTuple_t3168505507
{
public:
union
{
struct
{
};
uint8_t ValueTuple_t3168505507__padding[1];
};
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VALUETUPLE_T3168505507_H
#ifndef BYTE_T1134296376_H
#define BYTE_T1134296376_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Byte
struct Byte_t1134296376
{
public:
// System.Byte System.Byte::m_value
uint8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Byte_t1134296376, ___m_value_0)); }
inline uint8_t get_m_value_0() const { return ___m_value_0; }
inline uint8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint8_t value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BYTE_T1134296376_H
#ifndef INT16_T2552820387_H
#define INT16_T2552820387_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int16
struct Int16_t2552820387
{
public:
// System.Int16 System.Int16::m_value
int16_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int16_t2552820387, ___m_value_0)); }
inline int16_t get_m_value_0() const { return ___m_value_0; }
inline int16_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int16_t value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INT16_T2552820387_H
#ifndef UINTPTR_T_H
#define UINTPTR_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UIntPtr
struct UIntPtr_t
{
public:
// System.Void* System.UIntPtr::_pointer
void* ____pointer_1;
public:
inline static int32_t get_offset_of__pointer_1() { return static_cast<int32_t>(offsetof(UIntPtr_t, ____pointer_1)); }
inline void* get__pointer_1() const { return ____pointer_1; }
inline void** get_address_of__pointer_1() { return &____pointer_1; }
inline void set__pointer_1(void* value)
{
____pointer_1 = value;
}
};
struct UIntPtr_t_StaticFields
{
public:
// System.UIntPtr System.UIntPtr::Zero
uintptr_t ___Zero_0;
public:
inline static int32_t get_offset_of_Zero_0() { return static_cast<int32_t>(offsetof(UIntPtr_t_StaticFields, ___Zero_0)); }
inline uintptr_t get_Zero_0() const { return ___Zero_0; }
inline uintptr_t* get_address_of_Zero_0() { return &___Zero_0; }
inline void set_Zero_0(uintptr_t value)
{
___Zero_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UINTPTR_T_H
#ifndef UINT32_T2560061978_H
#define UINT32_T2560061978_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UInt32
struct UInt32_t2560061978
{
public:
// System.UInt32 System.UInt32::m_value
uint32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt32_t2560061978, ___m_value_0)); }
inline uint32_t get_m_value_0() const { return ___m_value_0; }
inline uint32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint32_t value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UINT32_T2560061978_H
#ifndef ENUM_T4135868527_H
#define ENUM_T4135868527_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Enum
struct Enum_t4135868527 : public ValueType_t3640485471
{
public:
public:
};
struct Enum_t4135868527_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t3528271667* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t4135868527_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t3528271667* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t3528271667** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t3528271667* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((&___enumSeperatorCharArray_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t4135868527_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t4135868527_marshaled_com
{
};
#endif // ENUM_T4135868527_H
#ifndef DATETIME_T3738529785_H
#define DATETIME_T3738529785_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.DateTime
struct DateTime_t3738529785
{
public:
// System.UInt64 System.DateTime::dateData
uint64_t ___dateData_44;
public:
inline static int32_t get_offset_of_dateData_44() { return static_cast<int32_t>(offsetof(DateTime_t3738529785, ___dateData_44)); }
inline uint64_t get_dateData_44() const { return ___dateData_44; }
inline uint64_t* get_address_of_dateData_44() { return &___dateData_44; }
inline void set_dateData_44(uint64_t value)
{
___dateData_44 = value;
}
};
struct DateTime_t3738529785_StaticFields
{
public:
// System.Int32[] System.DateTime::DaysToMonth365
Int32U5BU5D_t385246372* ___DaysToMonth365_29;
// System.Int32[] System.DateTime::DaysToMonth366
Int32U5BU5D_t385246372* ___DaysToMonth366_30;
// System.DateTime System.DateTime::MinValue
DateTime_t3738529785 ___MinValue_31;
// System.DateTime System.DateTime::MaxValue
DateTime_t3738529785 ___MaxValue_32;
public:
inline static int32_t get_offset_of_DaysToMonth365_29() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___DaysToMonth365_29)); }
inline Int32U5BU5D_t385246372* get_DaysToMonth365_29() const { return ___DaysToMonth365_29; }
inline Int32U5BU5D_t385246372** get_address_of_DaysToMonth365_29() { return &___DaysToMonth365_29; }
inline void set_DaysToMonth365_29(Int32U5BU5D_t385246372* value)
{
___DaysToMonth365_29 = value;
Il2CppCodeGenWriteBarrier((&___DaysToMonth365_29), value);
}
inline static int32_t get_offset_of_DaysToMonth366_30() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___DaysToMonth366_30)); }
inline Int32U5BU5D_t385246372* get_DaysToMonth366_30() const { return ___DaysToMonth366_30; }
inline Int32U5BU5D_t385246372** get_address_of_DaysToMonth366_30() { return &___DaysToMonth366_30; }
inline void set_DaysToMonth366_30(Int32U5BU5D_t385246372* value)
{
___DaysToMonth366_30 = value;
Il2CppCodeGenWriteBarrier((&___DaysToMonth366_30), value);
}
inline static int32_t get_offset_of_MinValue_31() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___MinValue_31)); }
inline DateTime_t3738529785 get_MinValue_31() const { return ___MinValue_31; }
inline DateTime_t3738529785 * get_address_of_MinValue_31() { return &___MinValue_31; }
inline void set_MinValue_31(DateTime_t3738529785 value)
{
___MinValue_31 = value;
}
inline static int32_t get_offset_of_MaxValue_32() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___MaxValue_32)); }
inline DateTime_t3738529785 get_MaxValue_32() const { return ___MaxValue_32; }
inline DateTime_t3738529785 * get_address_of_MaxValue_32() { return &___MaxValue_32; }
inline void set_MaxValue_32(DateTime_t3738529785 value)
{
___MaxValue_32 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DATETIME_T3738529785_H
#ifndef DECIMAL_T2948259380_H
#define DECIMAL_T2948259380_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Decimal
struct Decimal_t2948259380
{
public:
// System.Int32 System.Decimal::flags
int32_t ___flags_14;
// System.Int32 System.Decimal::hi
int32_t ___hi_15;
// System.Int32 System.Decimal::lo
int32_t ___lo_16;
// System.Int32 System.Decimal::mid
int32_t ___mid_17;
public:
inline static int32_t get_offset_of_flags_14() { return static_cast<int32_t>(offsetof(Decimal_t2948259380, ___flags_14)); }
inline int32_t get_flags_14() const { return ___flags_14; }
inline int32_t* get_address_of_flags_14() { return &___flags_14; }
inline void set_flags_14(int32_t value)
{
___flags_14 = value;
}
inline static int32_t get_offset_of_hi_15() { return static_cast<int32_t>(offsetof(Decimal_t2948259380, ___hi_15)); }
inline int32_t get_hi_15() const { return ___hi_15; }
inline int32_t* get_address_of_hi_15() { return &___hi_15; }
inline void set_hi_15(int32_t value)
{
___hi_15 = value;
}
inline static int32_t get_offset_of_lo_16() { return static_cast<int32_t>(offsetof(Decimal_t2948259380, ___lo_16)); }
inline int32_t get_lo_16() const { return ___lo_16; }
inline int32_t* get_address_of_lo_16() { return &___lo_16; }
inline void set_lo_16(int32_t value)
{
___lo_16 = value;
}
inline static int32_t get_offset_of_mid_17() { return static_cast<int32_t>(offsetof(Decimal_t2948259380, ___mid_17)); }
inline int32_t get_mid_17() const { return ___mid_17; }
inline int32_t* get_address_of_mid_17() { return &___mid_17; }
inline void set_mid_17(int32_t value)
{
___mid_17 = value;
}
};
struct Decimal_t2948259380_StaticFields
{
public:
// System.UInt32[] System.Decimal::Powers10
UInt32U5BU5D_t2770800703* ___Powers10_6;
// System.Decimal System.Decimal::Zero
Decimal_t2948259380 ___Zero_7;
// System.Decimal System.Decimal::One
Decimal_t2948259380 ___One_8;
// System.Decimal System.Decimal::MinusOne
Decimal_t2948259380 ___MinusOne_9;
// System.Decimal System.Decimal::MaxValue
Decimal_t2948259380 ___MaxValue_10;
// System.Decimal System.Decimal::MinValue
Decimal_t2948259380 ___MinValue_11;
// System.Decimal System.Decimal::NearNegativeZero
Decimal_t2948259380 ___NearNegativeZero_12;
// System.Decimal System.Decimal::NearPositiveZero
Decimal_t2948259380 ___NearPositiveZero_13;
public:
inline static int32_t get_offset_of_Powers10_6() { return static_cast<int32_t>(offsetof(Decimal_t2948259380_StaticFields, ___Powers10_6)); }
inline UInt32U5BU5D_t2770800703* get_Powers10_6() const { return ___Powers10_6; }
inline UInt32U5BU5D_t2770800703** get_address_of_Powers10_6() { return &___Powers10_6; }
inline void set_Powers10_6(UInt32U5BU5D_t2770800703* value)
{
___Powers10_6 = value;
Il2CppCodeGenWriteBarrier((&___Powers10_6), value);
}
inline static int32_t get_offset_of_Zero_7() { return static_cast<int32_t>(offsetof(Decimal_t2948259380_StaticFields, ___Zero_7)); }
inline Decimal_t2948259380 get_Zero_7() const { return ___Zero_7; }
inline Decimal_t2948259380 * get_address_of_Zero_7() { return &___Zero_7; }
inline void set_Zero_7(Decimal_t2948259380 value)
{
___Zero_7 = value;
}
inline static int32_t get_offset_of_One_8() { return static_cast<int32_t>(offsetof(Decimal_t2948259380_StaticFields, ___One_8)); }
inline Decimal_t2948259380 get_One_8() const { return ___One_8; }
inline Decimal_t2948259380 * get_address_of_One_8() { return &___One_8; }
inline void set_One_8(Decimal_t2948259380 value)
{
___One_8 = value;
}
inline static int32_t get_offset_of_MinusOne_9() { return static_cast<int32_t>(offsetof(Decimal_t2948259380_StaticFields, ___MinusOne_9)); }
inline Decimal_t2948259380 get_MinusOne_9() const { return ___MinusOne_9; }
inline Decimal_t2948259380 * get_address_of_MinusOne_9() { return &___MinusOne_9; }
inline void set_MinusOne_9(Decimal_t2948259380 value)
{
___MinusOne_9 = value;
}
inline static int32_t get_offset_of_MaxValue_10() { return static_cast<int32_t>(offsetof(Decimal_t2948259380_StaticFields, ___MaxValue_10)); }
inline Decimal_t2948259380 get_MaxValue_10() const { return ___MaxValue_10; }
inline Decimal_t2948259380 * get_address_of_MaxValue_10() { return &___MaxValue_10; }
inline void set_MaxValue_10(Decimal_t2948259380 value)
{
___MaxValue_10 = value;
}
inline static int32_t get_offset_of_MinValue_11() { return static_cast<int32_t>(offsetof(Decimal_t2948259380_StaticFields, ___MinValue_11)); }
inline Decimal_t2948259380 get_MinValue_11() const { return ___MinValue_11; }
inline Decimal_t2948259380 * get_address_of_MinValue_11() { return &___MinValue_11; }
inline void set_MinValue_11(Decimal_t2948259380 value)
{
___MinValue_11 = value;
}
inline static int32_t get_offset_of_NearNegativeZero_12() { return static_cast<int32_t>(offsetof(Decimal_t2948259380_StaticFields, ___NearNegativeZero_12)); }
inline Decimal_t2948259380 get_NearNegativeZero_12() const { return ___NearNegativeZero_12; }
inline Decimal_t2948259380 * get_address_of_NearNegativeZero_12() { return &___NearNegativeZero_12; }
inline void set_NearNegativeZero_12(Decimal_t2948259380 value)
{
___NearNegativeZero_12 = value;
}
inline static int32_t get_offset_of_NearPositiveZero_13() { return static_cast<int32_t>(offsetof(Decimal_t2948259380_StaticFields, ___NearPositiveZero_13)); }
inline Decimal_t2948259380 get_NearPositiveZero_13() const { return ___NearPositiveZero_13; }
inline Decimal_t2948259380 * get_address_of_NearPositiveZero_13() { return &___NearPositiveZero_13; }
inline void set_NearPositiveZero_13(Decimal_t2948259380 value)
{
___NearPositiveZero_13 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DECIMAL_T2948259380_H
#ifndef DOUBLE_T594665363_H
#define DOUBLE_T594665363_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Double
struct Double_t594665363
{
public:
// System.Double System.Double::m_value
double ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Double_t594665363, ___m_value_0)); }
inline double get_m_value_0() const { return ___m_value_0; }
inline double* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(double value)
{
___m_value_0 = value;
}
};
struct Double_t594665363_StaticFields
{
public:
// System.Double System.Double::NegativeZero
double ___NegativeZero_7;
public:
inline static int32_t get_offset_of_NegativeZero_7() { return static_cast<int32_t>(offsetof(Double_t594665363_StaticFields, ___NegativeZero_7)); }
inline double get_NegativeZero_7() const { return ___NegativeZero_7; }
inline double* get_address_of_NegativeZero_7() { return &___NegativeZero_7; }
inline void set_NegativeZero_7(double value)
{
___NegativeZero_7 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DOUBLE_T594665363_H
#ifndef SINGLE_T1397266774_H
#define SINGLE_T1397266774_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Single
struct Single_t1397266774
{
public:
// System.Single System.Single::m_value
float ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Single_t1397266774, ___m_value_0)); }
inline float get_m_value_0() const { return ___m_value_0; }
inline float* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(float value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SINGLE_T1397266774_H
#ifndef UINT64_T4134040092_H
#define UINT64_T4134040092_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UInt64
struct UInt64_t4134040092
{
public:
// System.UInt64 System.UInt64::m_value
uint64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt64_t4134040092, ___m_value_0)); }
inline uint64_t get_m_value_0() const { return ___m_value_0; }
inline uint64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint64_t value)
{
___m_value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UINT64_T4134040092_H
#ifndef SYSTEMEXCEPTION_T176217640_H
#define SYSTEMEXCEPTION_T176217640_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.SystemException
struct SystemException_t176217640 : public Exception_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SYSTEMEXCEPTION_T176217640_H
#ifndef BOOLEAN_T97287965_H
#define BOOLEAN_T97287965_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Boolean
struct Boolean_t97287965
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_t97287965, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_t97287965_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_t97287965_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((&___TrueString_5), value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_t97287965_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((&___FalseString_6), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BOOLEAN_T97287965_H
#ifndef WEAKREFERENCE_T1334886716_H
#define WEAKREFERENCE_T1334886716_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.WeakReference
struct WeakReference_t1334886716 : public RuntimeObject
{
public:
// System.Boolean System.WeakReference::isLongReference
bool ___isLongReference_0;
// System.Runtime.InteropServices.GCHandle System.WeakReference::gcHandle
GCHandle_t3351438187 ___gcHandle_1;
public:
inline static int32_t get_offset_of_isLongReference_0() { return static_cast<int32_t>(offsetof(WeakReference_t1334886716, ___isLongReference_0)); }
inline bool get_isLongReference_0() const { return ___isLongReference_0; }
inline bool* get_address_of_isLongReference_0() { return &___isLongReference_0; }
inline void set_isLongReference_0(bool value)
{
___isLongReference_0 = value;
}
inline static int32_t get_offset_of_gcHandle_1() { return static_cast<int32_t>(offsetof(WeakReference_t1334886716, ___gcHandle_1)); }
inline GCHandle_t3351438187 get_gcHandle_1() const { return ___gcHandle_1; }
inline GCHandle_t3351438187 * get_address_of_gcHandle_1() { return &___gcHandle_1; }
inline void set_gcHandle_1(GCHandle_t3351438187 value)
{
___gcHandle_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WEAKREFERENCE_T1334886716_H
#ifndef CONSOLESCREENBUFFERINFO_T3095351730_H
#define CONSOLESCREENBUFFERINFO_T3095351730_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleScreenBufferInfo
struct ConsoleScreenBufferInfo_t3095351730
{
public:
// System.Coord System.ConsoleScreenBufferInfo::Size
Coord_t397375283 ___Size_0;
// System.Coord System.ConsoleScreenBufferInfo::CursorPosition
Coord_t397375283 ___CursorPosition_1;
// System.Int16 System.ConsoleScreenBufferInfo::Attribute
int16_t ___Attribute_2;
// System.SmallRect System.ConsoleScreenBufferInfo::Window
SmallRect_t2930836963 ___Window_3;
// System.Coord System.ConsoleScreenBufferInfo::MaxWindowSize
Coord_t397375283 ___MaxWindowSize_4;
public:
inline static int32_t get_offset_of_Size_0() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_t3095351730, ___Size_0)); }
inline Coord_t397375283 get_Size_0() const { return ___Size_0; }
inline Coord_t397375283 * get_address_of_Size_0() { return &___Size_0; }
inline void set_Size_0(Coord_t397375283 value)
{
___Size_0 = value;
}
inline static int32_t get_offset_of_CursorPosition_1() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_t3095351730, ___CursorPosition_1)); }
inline Coord_t397375283 get_CursorPosition_1() const { return ___CursorPosition_1; }
inline Coord_t397375283 * get_address_of_CursorPosition_1() { return &___CursorPosition_1; }
inline void set_CursorPosition_1(Coord_t397375283 value)
{
___CursorPosition_1 = value;
}
inline static int32_t get_offset_of_Attribute_2() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_t3095351730, ___Attribute_2)); }
inline int16_t get_Attribute_2() const { return ___Attribute_2; }
inline int16_t* get_address_of_Attribute_2() { return &___Attribute_2; }
inline void set_Attribute_2(int16_t value)
{
___Attribute_2 = value;
}
inline static int32_t get_offset_of_Window_3() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_t3095351730, ___Window_3)); }
inline SmallRect_t2930836963 get_Window_3() const { return ___Window_3; }
inline SmallRect_t2930836963 * get_address_of_Window_3() { return &___Window_3; }
inline void set_Window_3(SmallRect_t2930836963 value)
{
___Window_3 = value;
}
inline static int32_t get_offset_of_MaxWindowSize_4() { return static_cast<int32_t>(offsetof(ConsoleScreenBufferInfo_t3095351730, ___MaxWindowSize_4)); }
inline Coord_t397375283 get_MaxWindowSize_4() const { return ___MaxWindowSize_4; }
inline Coord_t397375283 * get_address_of_MaxWindowSize_4() { return &___MaxWindowSize_4; }
inline void set_MaxWindowSize_4(Coord_t397375283 value)
{
___MaxWindowSize_4 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONSOLESCREENBUFFERINFO_T3095351730_H
#ifndef BRECORD_T3470580684_H
#define BRECORD_T3470580684_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.BRECORD
struct BRECORD_t3470580684
{
public:
// System.IntPtr System.BRECORD::pvRecord
intptr_t ___pvRecord_0;
// System.IntPtr System.BRECORD::pRecInfo
intptr_t ___pRecInfo_1;
public:
inline static int32_t get_offset_of_pvRecord_0() { return static_cast<int32_t>(offsetof(BRECORD_t3470580684, ___pvRecord_0)); }
inline intptr_t get_pvRecord_0() const { return ___pvRecord_0; }
inline intptr_t* get_address_of_pvRecord_0() { return &___pvRecord_0; }
inline void set_pvRecord_0(intptr_t value)
{
___pvRecord_0 = value;
}
inline static int32_t get_offset_of_pRecInfo_1() { return static_cast<int32_t>(offsetof(BRECORD_t3470580684, ___pRecInfo_1)); }
inline intptr_t get_pRecInfo_1() const { return ___pRecInfo_1; }
inline intptr_t* get_address_of_pRecInfo_1() { return &___pRecInfo_1; }
inline void set_pRecInfo_1(intptr_t value)
{
___pRecInfo_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BRECORD_T3470580684_H
#ifndef WINDOWSCONSOLEDRIVER_T3991887195_H
#define WINDOWSCONSOLEDRIVER_T3991887195_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.WindowsConsoleDriver
struct WindowsConsoleDriver_t3991887195 : public RuntimeObject
{
public:
// System.IntPtr System.WindowsConsoleDriver::inputHandle
intptr_t ___inputHandle_0;
// System.IntPtr System.WindowsConsoleDriver::outputHandle
intptr_t ___outputHandle_1;
// System.Int16 System.WindowsConsoleDriver::defaultAttribute
int16_t ___defaultAttribute_2;
public:
inline static int32_t get_offset_of_inputHandle_0() { return static_cast<int32_t>(offsetof(WindowsConsoleDriver_t3991887195, ___inputHandle_0)); }
inline intptr_t get_inputHandle_0() const { return ___inputHandle_0; }
inline intptr_t* get_address_of_inputHandle_0() { return &___inputHandle_0; }
inline void set_inputHandle_0(intptr_t value)
{
___inputHandle_0 = value;
}
inline static int32_t get_offset_of_outputHandle_1() { return static_cast<int32_t>(offsetof(WindowsConsoleDriver_t3991887195, ___outputHandle_1)); }
inline intptr_t get_outputHandle_1() const { return ___outputHandle_1; }
inline intptr_t* get_address_of_outputHandle_1() { return &___outputHandle_1; }
inline void set_outputHandle_1(intptr_t value)
{
___outputHandle_1 = value;
}
inline static int32_t get_offset_of_defaultAttribute_2() { return static_cast<int32_t>(offsetof(WindowsConsoleDriver_t3991887195, ___defaultAttribute_2)); }
inline int16_t get_defaultAttribute_2() const { return ___defaultAttribute_2; }
inline int16_t* get_address_of_defaultAttribute_2() { return &___defaultAttribute_2; }
inline void set_defaultAttribute_2(int16_t value)
{
___defaultAttribute_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // WINDOWSCONSOLEDRIVER_T3991887195_H
#ifndef STREAMINGCONTEXTSTATES_T3580100459_H
#define STREAMINGCONTEXTSTATES_T3580100459_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.StreamingContextStates
struct StreamingContextStates_t3580100459
{
public:
// System.Int32 System.Runtime.Serialization.StreamingContextStates::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(StreamingContextStates_t3580100459, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STREAMINGCONTEXTSTATES_T3580100459_H
#ifndef BINDINGFLAGS_T2721792723_H
#define BINDINGFLAGS_T2721792723_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.BindingFlags
struct BindingFlags_t2721792723
{
public:
// System.Int32 System.Reflection.BindingFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(BindingFlags_t2721792723, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BINDINGFLAGS_T2721792723_H
#ifndef HANDLES_T3280152003_H
#define HANDLES_T3280152003_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Handles
struct Handles_t3280152003
{
public:
// System.Int32 System.Handles::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Handles_t3280152003, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HANDLES_T3280152003_H
#ifndef CONSOLEKEY_T4097401472_H
#define CONSOLEKEY_T4097401472_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleKey
struct ConsoleKey_t4097401472
{
public:
// System.Int32 System.ConsoleKey::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConsoleKey_t4097401472, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONSOLEKEY_T4097401472_H
#ifndef CFRANGE_T1233619878_H
#define CFRANGE_T1233619878_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// XamMac.CoreFoundation.CFHelpers/CFRange
struct CFRange_t1233619878
{
public:
// System.IntPtr XamMac.CoreFoundation.CFHelpers/CFRange::loc
intptr_t ___loc_0;
// System.IntPtr XamMac.CoreFoundation.CFHelpers/CFRange::len
intptr_t ___len_1;
public:
inline static int32_t get_offset_of_loc_0() { return static_cast<int32_t>(offsetof(CFRange_t1233619878, ___loc_0)); }
inline intptr_t get_loc_0() const { return ___loc_0; }
inline intptr_t* get_address_of_loc_0() { return &___loc_0; }
inline void set_loc_0(intptr_t value)
{
___loc_0 = value;
}
inline static int32_t get_offset_of_len_1() { return static_cast<int32_t>(offsetof(CFRange_t1233619878, ___len_1)); }
inline intptr_t get_len_1() const { return ___len_1; }
inline intptr_t* get_address_of_len_1() { return &___len_1; }
inline void set_len_1(intptr_t value)
{
___len_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CFRANGE_T1233619878_H
#ifndef GCHANDLETYPE_T3432586689_H
#define GCHANDLETYPE_T3432586689_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.InteropServices.GCHandleType
struct GCHandleType_t3432586689
{
public:
// System.Int32 System.Runtime.InteropServices.GCHandleType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(GCHandleType_t3432586689, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // GCHANDLETYPE_T3432586689_H
#ifndef INVALIDOPERATIONEXCEPTION_T56020091_H
#define INVALIDOPERATIONEXCEPTION_T56020091_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.InvalidOperationException
struct InvalidOperationException_t56020091 : public SystemException_t176217640
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INVALIDOPERATIONEXCEPTION_T56020091_H
#ifndef CONSOLEMODIFIERS_T1471011467_H
#define CONSOLEMODIFIERS_T1471011467_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleModifiers
struct ConsoleModifiers_t1471011467
{
public:
// System.Int32 System.ConsoleModifiers::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConsoleModifiers_t1471011467, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CONSOLEMODIFIERS_T1471011467_H
#ifndef UNAUTHORIZEDACCESSEXCEPTION_T490705335_H
#define UNAUTHORIZEDACCESSEXCEPTION_T490705335_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UnauthorizedAccessException
struct UnauthorizedAccessException_t490705335 : public SystemException_t176217640
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNAUTHORIZEDACCESSEXCEPTION_T490705335_H
#ifndef ARGUMENTEXCEPTION_T132251570_H
#define ARGUMENTEXCEPTION_T132251570_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ArgumentException
struct ArgumentException_t132251570 : public SystemException_t176217640
{
public:
// System.String System.ArgumentException::m_paramName
String_t* ___m_paramName_17;
public:
inline static int32_t get_offset_of_m_paramName_17() { return static_cast<int32_t>(offsetof(ArgumentException_t132251570, ___m_paramName_17)); }
inline String_t* get_m_paramName_17() const { return ___m_paramName_17; }
inline String_t** get_address_of_m_paramName_17() { return &___m_paramName_17; }
inline void set_m_paramName_17(String_t* value)
{
___m_paramName_17 = value;
Il2CppCodeGenWriteBarrier((&___m_paramName_17), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ARGUMENTEXCEPTION_T132251570_H
#ifndef NOTSUPPORTEDEXCEPTION_T1314879016_H
#define NOTSUPPORTEDEXCEPTION_T1314879016_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.NotSupportedException
struct NotSupportedException_t1314879016 : public SystemException_t176217640
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // NOTSUPPORTEDEXCEPTION_T1314879016_H
#ifndef SERIALIZATIONEXCEPTION_T3941511869_H
#define SERIALIZATIONEXCEPTION_T3941511869_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.SerializationException
struct SerializationException_t3941511869 : public SystemException_t176217640
{
public:
public:
};
struct SerializationException_t3941511869_StaticFields
{
public:
// System.String System.Runtime.Serialization.SerializationException::_nullMessage
String_t* ____nullMessage_17;
public:
inline static int32_t get_offset_of__nullMessage_17() { return static_cast<int32_t>(offsetof(SerializationException_t3941511869_StaticFields, ____nullMessage_17)); }
inline String_t* get__nullMessage_17() const { return ____nullMessage_17; }
inline String_t** get_address_of__nullMessage_17() { return &____nullMessage_17; }
inline void set__nullMessage_17(String_t* value)
{
____nullMessage_17 = value;
Il2CppCodeGenWriteBarrier((&____nullMessage_17), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SERIALIZATIONEXCEPTION_T3941511869_H
#ifndef ASSEMBLY_T_H
#define ASSEMBLY_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.Assembly
struct Assembly_t : public RuntimeObject
{
public:
// System.IntPtr System.Reflection.Assembly::_mono_assembly
intptr_t ____mono_assembly_0;
// System.Reflection.Assembly/ResolveEventHolder System.Reflection.Assembly::resolve_event_holder
ResolveEventHolder_t2120639521 * ___resolve_event_holder_1;
// System.Security.Policy.Evidence System.Reflection.Assembly::_evidence
Evidence_t2008144148 * ____evidence_2;
// System.Security.PermissionSet System.Reflection.Assembly::_minimum
PermissionSet_t223948603 * ____minimum_3;
// System.Security.PermissionSet System.Reflection.Assembly::_optional
PermissionSet_t223948603 * ____optional_4;
// System.Security.PermissionSet System.Reflection.Assembly::_refuse
PermissionSet_t223948603 * ____refuse_5;
// System.Security.PermissionSet System.Reflection.Assembly::_granted
PermissionSet_t223948603 * ____granted_6;
// System.Security.PermissionSet System.Reflection.Assembly::_denied
PermissionSet_t223948603 * ____denied_7;
// System.Boolean System.Reflection.Assembly::fromByteArray
bool ___fromByteArray_8;
// System.String System.Reflection.Assembly::assemblyName
String_t* ___assemblyName_9;
public:
inline static int32_t get_offset_of__mono_assembly_0() { return static_cast<int32_t>(offsetof(Assembly_t, ____mono_assembly_0)); }
inline intptr_t get__mono_assembly_0() const { return ____mono_assembly_0; }
inline intptr_t* get_address_of__mono_assembly_0() { return &____mono_assembly_0; }
inline void set__mono_assembly_0(intptr_t value)
{
____mono_assembly_0 = value;
}
inline static int32_t get_offset_of_resolve_event_holder_1() { return static_cast<int32_t>(offsetof(Assembly_t, ___resolve_event_holder_1)); }
inline ResolveEventHolder_t2120639521 * get_resolve_event_holder_1() const { return ___resolve_event_holder_1; }
inline ResolveEventHolder_t2120639521 ** get_address_of_resolve_event_holder_1() { return &___resolve_event_holder_1; }
inline void set_resolve_event_holder_1(ResolveEventHolder_t2120639521 * value)
{
___resolve_event_holder_1 = value;
Il2CppCodeGenWriteBarrier((&___resolve_event_holder_1), value);
}
inline static int32_t get_offset_of__evidence_2() { return static_cast<int32_t>(offsetof(Assembly_t, ____evidence_2)); }
inline Evidence_t2008144148 * get__evidence_2() const { return ____evidence_2; }
inline Evidence_t2008144148 ** get_address_of__evidence_2() { return &____evidence_2; }
inline void set__evidence_2(Evidence_t2008144148 * value)
{
____evidence_2 = value;
Il2CppCodeGenWriteBarrier((&____evidence_2), value);
}
inline static int32_t get_offset_of__minimum_3() { return static_cast<int32_t>(offsetof(Assembly_t, ____minimum_3)); }
inline PermissionSet_t223948603 * get__minimum_3() const { return ____minimum_3; }
inline PermissionSet_t223948603 ** get_address_of__minimum_3() { return &____minimum_3; }
inline void set__minimum_3(PermissionSet_t223948603 * value)
{
____minimum_3 = value;
Il2CppCodeGenWriteBarrier((&____minimum_3), value);
}
inline static int32_t get_offset_of__optional_4() { return static_cast<int32_t>(offsetof(Assembly_t, ____optional_4)); }
inline PermissionSet_t223948603 * get__optional_4() const { return ____optional_4; }
inline PermissionSet_t223948603 ** get_address_of__optional_4() { return &____optional_4; }
inline void set__optional_4(PermissionSet_t223948603 * value)
{
____optional_4 = value;
Il2CppCodeGenWriteBarrier((&____optional_4), value);
}
inline static int32_t get_offset_of__refuse_5() { return static_cast<int32_t>(offsetof(Assembly_t, ____refuse_5)); }
inline PermissionSet_t223948603 * get__refuse_5() const { return ____refuse_5; }
inline PermissionSet_t223948603 ** get_address_of__refuse_5() { return &____refuse_5; }
inline void set__refuse_5(PermissionSet_t223948603 * value)
{
____refuse_5 = value;
Il2CppCodeGenWriteBarrier((&____refuse_5), value);
}
inline static int32_t get_offset_of__granted_6() { return static_cast<int32_t>(offsetof(Assembly_t, ____granted_6)); }
inline PermissionSet_t223948603 * get__granted_6() const { return ____granted_6; }
inline PermissionSet_t223948603 ** get_address_of__granted_6() { return &____granted_6; }
inline void set__granted_6(PermissionSet_t223948603 * value)
{
____granted_6 = value;
Il2CppCodeGenWriteBarrier((&____granted_6), value);
}
inline static int32_t get_offset_of__denied_7() { return static_cast<int32_t>(offsetof(Assembly_t, ____denied_7)); }
inline PermissionSet_t223948603 * get__denied_7() const { return ____denied_7; }
inline PermissionSet_t223948603 ** get_address_of__denied_7() { return &____denied_7; }
inline void set__denied_7(PermissionSet_t223948603 * value)
{
____denied_7 = value;
Il2CppCodeGenWriteBarrier((&____denied_7), value);
}
inline static int32_t get_offset_of_fromByteArray_8() { return static_cast<int32_t>(offsetof(Assembly_t, ___fromByteArray_8)); }
inline bool get_fromByteArray_8() const { return ___fromByteArray_8; }
inline bool* get_address_of_fromByteArray_8() { return &___fromByteArray_8; }
inline void set_fromByteArray_8(bool value)
{
___fromByteArray_8 = value;
}
inline static int32_t get_offset_of_assemblyName_9() { return static_cast<int32_t>(offsetof(Assembly_t, ___assemblyName_9)); }
inline String_t* get_assemblyName_9() const { return ___assemblyName_9; }
inline String_t** get_address_of_assemblyName_9() { return &___assemblyName_9; }
inline void set_assemblyName_9(String_t* value)
{
___assemblyName_9 = value;
Il2CppCodeGenWriteBarrier((&___assemblyName_9), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Reflection.Assembly
struct Assembly_t_marshaled_pinvoke
{
intptr_t ____mono_assembly_0;
ResolveEventHolder_t2120639521 * ___resolve_event_holder_1;
Evidence_t2008144148 * ____evidence_2;
PermissionSet_t223948603 * ____minimum_3;
PermissionSet_t223948603 * ____optional_4;
PermissionSet_t223948603 * ____refuse_5;
PermissionSet_t223948603 * ____granted_6;
PermissionSet_t223948603 * ____denied_7;
int32_t ___fromByteArray_8;
char* ___assemblyName_9;
};
// Native definition for COM marshalling of System.Reflection.Assembly
struct Assembly_t_marshaled_com
{
intptr_t ____mono_assembly_0;
ResolveEventHolder_t2120639521 * ___resolve_event_holder_1;
Evidence_t2008144148 * ____evidence_2;
PermissionSet_t223948603 * ____minimum_3;
PermissionSet_t223948603 * ____optional_4;
PermissionSet_t223948603 * ____refuse_5;
PermissionSet_t223948603 * ____granted_6;
PermissionSet_t223948603 * ____denied_7;
int32_t ___fromByteArray_8;
Il2CppChar* ___assemblyName_9;
};
#endif // ASSEMBLY_T_H
#ifndef RUNTIMETYPEHANDLE_T3027515415_H
#define RUNTIMETYPEHANDLE_T3027515415_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.RuntimeTypeHandle
struct RuntimeTypeHandle_t3027515415
{
public:
// System.IntPtr System.RuntimeTypeHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeTypeHandle_t3027515415, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMETYPEHANDLE_T3027515415_H
#ifndef NUMBERSTYLES_T617258130_H
#define NUMBERSTYLES_T617258130_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Globalization.NumberStyles
struct NumberStyles_t617258130
{
public:
// System.Int32 System.Globalization.NumberStyles::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(NumberStyles_t617258130, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // NUMBERSTYLES_T617258130_H
#ifndef DELEGATE_T1188392813_H
#define DELEGATE_T1188392813_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Delegate
struct Delegate_t1188392813 : public RuntimeObject
{
public:
// System.IntPtr System.Delegate::method_ptr
Il2CppMethodPointer ___method_ptr_0;
// System.IntPtr System.Delegate::invoke_impl
intptr_t ___invoke_impl_1;
// System.Object System.Delegate::m_target
RuntimeObject * ___m_target_2;
// System.IntPtr System.Delegate::method
intptr_t ___method_3;
// System.IntPtr System.Delegate::delegate_trampoline
intptr_t ___delegate_trampoline_4;
// System.IntPtr System.Delegate::extra_arg
intptr_t ___extra_arg_5;
// System.IntPtr System.Delegate::method_code
intptr_t ___method_code_6;
// System.Reflection.MethodInfo System.Delegate::method_info
MethodInfo_t * ___method_info_7;
// System.Reflection.MethodInfo System.Delegate::original_method_info
MethodInfo_t * ___original_method_info_8;
// System.DelegateData System.Delegate::data
DelegateData_t1677132599 * ___data_9;
// System.Boolean System.Delegate::method_is_virtual
bool ___method_is_virtual_10;
public:
inline static int32_t get_offset_of_method_ptr_0() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_ptr_0)); }
inline Il2CppMethodPointer get_method_ptr_0() const { return ___method_ptr_0; }
inline Il2CppMethodPointer* get_address_of_method_ptr_0() { return &___method_ptr_0; }
inline void set_method_ptr_0(Il2CppMethodPointer value)
{
___method_ptr_0 = value;
}
inline static int32_t get_offset_of_invoke_impl_1() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___invoke_impl_1)); }
inline intptr_t get_invoke_impl_1() const { return ___invoke_impl_1; }
inline intptr_t* get_address_of_invoke_impl_1() { return &___invoke_impl_1; }
inline void set_invoke_impl_1(intptr_t value)
{
___invoke_impl_1 = value;
}
inline static int32_t get_offset_of_m_target_2() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___m_target_2)); }
inline RuntimeObject * get_m_target_2() const { return ___m_target_2; }
inline RuntimeObject ** get_address_of_m_target_2() { return &___m_target_2; }
inline void set_m_target_2(RuntimeObject * value)
{
___m_target_2 = value;
Il2CppCodeGenWriteBarrier((&___m_target_2), value);
}
inline static int32_t get_offset_of_method_3() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_3)); }
inline intptr_t get_method_3() const { return ___method_3; }
inline intptr_t* get_address_of_method_3() { return &___method_3; }
inline void set_method_3(intptr_t value)
{
___method_3 = value;
}
inline static int32_t get_offset_of_delegate_trampoline_4() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___delegate_trampoline_4)); }
inline intptr_t get_delegate_trampoline_4() const { return ___delegate_trampoline_4; }
inline intptr_t* get_address_of_delegate_trampoline_4() { return &___delegate_trampoline_4; }
inline void set_delegate_trampoline_4(intptr_t value)
{
___delegate_trampoline_4 = value;
}
inline static int32_t get_offset_of_extra_arg_5() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___extra_arg_5)); }
inline intptr_t get_extra_arg_5() const { return ___extra_arg_5; }
inline intptr_t* get_address_of_extra_arg_5() { return &___extra_arg_5; }
inline void set_extra_arg_5(intptr_t value)
{
___extra_arg_5 = value;
}
inline static int32_t get_offset_of_method_code_6() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_code_6)); }
inline intptr_t get_method_code_6() const { return ___method_code_6; }
inline intptr_t* get_address_of_method_code_6() { return &___method_code_6; }
inline void set_method_code_6(intptr_t value)
{
___method_code_6 = value;
}
inline static int32_t get_offset_of_method_info_7() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_info_7)); }
inline MethodInfo_t * get_method_info_7() const { return ___method_info_7; }
inline MethodInfo_t ** get_address_of_method_info_7() { return &___method_info_7; }
inline void set_method_info_7(MethodInfo_t * value)
{
___method_info_7 = value;
Il2CppCodeGenWriteBarrier((&___method_info_7), value);
}
inline static int32_t get_offset_of_original_method_info_8() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___original_method_info_8)); }
inline MethodInfo_t * get_original_method_info_8() const { return ___original_method_info_8; }
inline MethodInfo_t ** get_address_of_original_method_info_8() { return &___original_method_info_8; }
inline void set_original_method_info_8(MethodInfo_t * value)
{
___original_method_info_8 = value;
Il2CppCodeGenWriteBarrier((&___original_method_info_8), value);
}
inline static int32_t get_offset_of_data_9() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___data_9)); }
inline DelegateData_t1677132599 * get_data_9() const { return ___data_9; }
inline DelegateData_t1677132599 ** get_address_of_data_9() { return &___data_9; }
inline void set_data_9(DelegateData_t1677132599 * value)
{
___data_9 = value;
Il2CppCodeGenWriteBarrier((&___data_9), value);
}
inline static int32_t get_offset_of_method_is_virtual_10() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_is_virtual_10)); }
inline bool get_method_is_virtual_10() const { return ___method_is_virtual_10; }
inline bool* get_address_of_method_is_virtual_10() { return &___method_is_virtual_10; }
inline void set_method_is_virtual_10(bool value)
{
___method_is_virtual_10 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Delegate
struct Delegate_t1188392813_marshaled_pinvoke
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1677132599 * ___data_9;
int32_t ___method_is_virtual_10;
};
// Native definition for COM marshalling of System.Delegate
struct Delegate_t1188392813_marshaled_com
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1677132599 * ___data_9;
int32_t ___method_is_virtual_10;
};
#endif // DELEGATE_T1188392813_H
#ifndef TYPECODE_T2987224087_H
#define TYPECODE_T2987224087_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TypeCode
struct TypeCode_t2987224087
{
public:
// System.Int32 System.TypeCode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TypeCode_t2987224087, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPECODE_T2987224087_H
#ifndef INVALIDCASTEXCEPTION_T3927145244_H
#define INVALIDCASTEXCEPTION_T3927145244_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.InvalidCastException
struct InvalidCastException_t3927145244 : public SystemException_t176217640
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INVALIDCASTEXCEPTION_T3927145244_H
#ifndef INDEXOUTOFRANGEEXCEPTION_T1578797820_H
#define INDEXOUTOFRANGEEXCEPTION_T1578797820_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.IndexOutOfRangeException
struct IndexOutOfRangeException_t1578797820 : public SystemException_t176217640
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INDEXOUTOFRANGEEXCEPTION_T1578797820_H
#ifndef NUMBERFORMATINFO_T435877138_H
#define NUMBERFORMATINFO_T435877138_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Globalization.NumberFormatInfo
struct NumberFormatInfo_t435877138 : public RuntimeObject
{
public:
// System.Int32[] System.Globalization.NumberFormatInfo::numberGroupSizes
Int32U5BU5D_t385246372* ___numberGroupSizes_1;
// System.Int32[] System.Globalization.NumberFormatInfo::currencyGroupSizes
Int32U5BU5D_t385246372* ___currencyGroupSizes_2;
// System.Int32[] System.Globalization.NumberFormatInfo::percentGroupSizes
Int32U5BU5D_t385246372* ___percentGroupSizes_3;
// System.String System.Globalization.NumberFormatInfo::positiveSign
String_t* ___positiveSign_4;
// System.String System.Globalization.NumberFormatInfo::negativeSign
String_t* ___negativeSign_5;
// System.String System.Globalization.NumberFormatInfo::numberDecimalSeparator
String_t* ___numberDecimalSeparator_6;
// System.String System.Globalization.NumberFormatInfo::numberGroupSeparator
String_t* ___numberGroupSeparator_7;
// System.String System.Globalization.NumberFormatInfo::currencyGroupSeparator
String_t* ___currencyGroupSeparator_8;
// System.String System.Globalization.NumberFormatInfo::currencyDecimalSeparator
String_t* ___currencyDecimalSeparator_9;
// System.String System.Globalization.NumberFormatInfo::currencySymbol
String_t* ___currencySymbol_10;
// System.String System.Globalization.NumberFormatInfo::ansiCurrencySymbol
String_t* ___ansiCurrencySymbol_11;
// System.String System.Globalization.NumberFormatInfo::nanSymbol
String_t* ___nanSymbol_12;
// System.String System.Globalization.NumberFormatInfo::positiveInfinitySymbol
String_t* ___positiveInfinitySymbol_13;
// System.String System.Globalization.NumberFormatInfo::negativeInfinitySymbol
String_t* ___negativeInfinitySymbol_14;
// System.String System.Globalization.NumberFormatInfo::percentDecimalSeparator
String_t* ___percentDecimalSeparator_15;
// System.String System.Globalization.NumberFormatInfo::percentGroupSeparator
String_t* ___percentGroupSeparator_16;
// System.String System.Globalization.NumberFormatInfo::percentSymbol
String_t* ___percentSymbol_17;
// System.String System.Globalization.NumberFormatInfo::perMilleSymbol
String_t* ___perMilleSymbol_18;
// System.String[] System.Globalization.NumberFormatInfo::nativeDigits
StringU5BU5D_t1281789340* ___nativeDigits_19;
// System.Int32 System.Globalization.NumberFormatInfo::m_dataItem
int32_t ___m_dataItem_20;
// System.Int32 System.Globalization.NumberFormatInfo::numberDecimalDigits
int32_t ___numberDecimalDigits_21;
// System.Int32 System.Globalization.NumberFormatInfo::currencyDecimalDigits
int32_t ___currencyDecimalDigits_22;
// System.Int32 System.Globalization.NumberFormatInfo::currencyPositivePattern
int32_t ___currencyPositivePattern_23;
// System.Int32 System.Globalization.NumberFormatInfo::currencyNegativePattern
int32_t ___currencyNegativePattern_24;
// System.Int32 System.Globalization.NumberFormatInfo::numberNegativePattern
int32_t ___numberNegativePattern_25;
// System.Int32 System.Globalization.NumberFormatInfo::percentPositivePattern
int32_t ___percentPositivePattern_26;
// System.Int32 System.Globalization.NumberFormatInfo::percentNegativePattern
int32_t ___percentNegativePattern_27;
// System.Int32 System.Globalization.NumberFormatInfo::percentDecimalDigits
int32_t ___percentDecimalDigits_28;
// System.Int32 System.Globalization.NumberFormatInfo::digitSubstitution
int32_t ___digitSubstitution_29;
// System.Boolean System.Globalization.NumberFormatInfo::isReadOnly
bool ___isReadOnly_30;
// System.Boolean System.Globalization.NumberFormatInfo::m_useUserOverride
bool ___m_useUserOverride_31;
// System.Boolean System.Globalization.NumberFormatInfo::m_isInvariant
bool ___m_isInvariant_32;
// System.Boolean System.Globalization.NumberFormatInfo::validForParseAsNumber
bool ___validForParseAsNumber_33;
// System.Boolean System.Globalization.NumberFormatInfo::validForParseAsCurrency
bool ___validForParseAsCurrency_34;
public:
inline static int32_t get_offset_of_numberGroupSizes_1() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___numberGroupSizes_1)); }
inline Int32U5BU5D_t385246372* get_numberGroupSizes_1() const { return ___numberGroupSizes_1; }
inline Int32U5BU5D_t385246372** get_address_of_numberGroupSizes_1() { return &___numberGroupSizes_1; }
inline void set_numberGroupSizes_1(Int32U5BU5D_t385246372* value)
{
___numberGroupSizes_1 = value;
Il2CppCodeGenWriteBarrier((&___numberGroupSizes_1), value);
}
inline static int32_t get_offset_of_currencyGroupSizes_2() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___currencyGroupSizes_2)); }
inline Int32U5BU5D_t385246372* get_currencyGroupSizes_2() const { return ___currencyGroupSizes_2; }
inline Int32U5BU5D_t385246372** get_address_of_currencyGroupSizes_2() { return &___currencyGroupSizes_2; }
inline void set_currencyGroupSizes_2(Int32U5BU5D_t385246372* value)
{
___currencyGroupSizes_2 = value;
Il2CppCodeGenWriteBarrier((&___currencyGroupSizes_2), value);
}
inline static int32_t get_offset_of_percentGroupSizes_3() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___percentGroupSizes_3)); }
inline Int32U5BU5D_t385246372* get_percentGroupSizes_3() const { return ___percentGroupSizes_3; }
inline Int32U5BU5D_t385246372** get_address_of_percentGroupSizes_3() { return &___percentGroupSizes_3; }
inline void set_percentGroupSizes_3(Int32U5BU5D_t385246372* value)
{
___percentGroupSizes_3 = value;
Il2CppCodeGenWriteBarrier((&___percentGroupSizes_3), value);
}
inline static int32_t get_offset_of_positiveSign_4() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___positiveSign_4)); }
inline String_t* get_positiveSign_4() const { return ___positiveSign_4; }
inline String_t** get_address_of_positiveSign_4() { return &___positiveSign_4; }
inline void set_positiveSign_4(String_t* value)
{
___positiveSign_4 = value;
Il2CppCodeGenWriteBarrier((&___positiveSign_4), value);
}
inline static int32_t get_offset_of_negativeSign_5() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___negativeSign_5)); }
inline String_t* get_negativeSign_5() const { return ___negativeSign_5; }
inline String_t** get_address_of_negativeSign_5() { return &___negativeSign_5; }
inline void set_negativeSign_5(String_t* value)
{
___negativeSign_5 = value;
Il2CppCodeGenWriteBarrier((&___negativeSign_5), value);
}
inline static int32_t get_offset_of_numberDecimalSeparator_6() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___numberDecimalSeparator_6)); }
inline String_t* get_numberDecimalSeparator_6() const { return ___numberDecimalSeparator_6; }
inline String_t** get_address_of_numberDecimalSeparator_6() { return &___numberDecimalSeparator_6; }
inline void set_numberDecimalSeparator_6(String_t* value)
{
___numberDecimalSeparator_6 = value;
Il2CppCodeGenWriteBarrier((&___numberDecimalSeparator_6), value);
}
inline static int32_t get_offset_of_numberGroupSeparator_7() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___numberGroupSeparator_7)); }
inline String_t* get_numberGroupSeparator_7() const { return ___numberGroupSeparator_7; }
inline String_t** get_address_of_numberGroupSeparator_7() { return &___numberGroupSeparator_7; }
inline void set_numberGroupSeparator_7(String_t* value)
{
___numberGroupSeparator_7 = value;
Il2CppCodeGenWriteBarrier((&___numberGroupSeparator_7), value);
}
inline static int32_t get_offset_of_currencyGroupSeparator_8() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___currencyGroupSeparator_8)); }
inline String_t* get_currencyGroupSeparator_8() const { return ___currencyGroupSeparator_8; }
inline String_t** get_address_of_currencyGroupSeparator_8() { return &___currencyGroupSeparator_8; }
inline void set_currencyGroupSeparator_8(String_t* value)
{
___currencyGroupSeparator_8 = value;
Il2CppCodeGenWriteBarrier((&___currencyGroupSeparator_8), value);
}
inline static int32_t get_offset_of_currencyDecimalSeparator_9() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___currencyDecimalSeparator_9)); }
inline String_t* get_currencyDecimalSeparator_9() const { return ___currencyDecimalSeparator_9; }
inline String_t** get_address_of_currencyDecimalSeparator_9() { return &___currencyDecimalSeparator_9; }
inline void set_currencyDecimalSeparator_9(String_t* value)
{
___currencyDecimalSeparator_9 = value;
Il2CppCodeGenWriteBarrier((&___currencyDecimalSeparator_9), value);
}
inline static int32_t get_offset_of_currencySymbol_10() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___currencySymbol_10)); }
inline String_t* get_currencySymbol_10() const { return ___currencySymbol_10; }
inline String_t** get_address_of_currencySymbol_10() { return &___currencySymbol_10; }
inline void set_currencySymbol_10(String_t* value)
{
___currencySymbol_10 = value;
Il2CppCodeGenWriteBarrier((&___currencySymbol_10), value);
}
inline static int32_t get_offset_of_ansiCurrencySymbol_11() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___ansiCurrencySymbol_11)); }
inline String_t* get_ansiCurrencySymbol_11() const { return ___ansiCurrencySymbol_11; }
inline String_t** get_address_of_ansiCurrencySymbol_11() { return &___ansiCurrencySymbol_11; }
inline void set_ansiCurrencySymbol_11(String_t* value)
{
___ansiCurrencySymbol_11 = value;
Il2CppCodeGenWriteBarrier((&___ansiCurrencySymbol_11), value);
}
inline static int32_t get_offset_of_nanSymbol_12() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___nanSymbol_12)); }
inline String_t* get_nanSymbol_12() const { return ___nanSymbol_12; }
inline String_t** get_address_of_nanSymbol_12() { return &___nanSymbol_12; }
inline void set_nanSymbol_12(String_t* value)
{
___nanSymbol_12 = value;
Il2CppCodeGenWriteBarrier((&___nanSymbol_12), value);
}
inline static int32_t get_offset_of_positiveInfinitySymbol_13() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___positiveInfinitySymbol_13)); }
inline String_t* get_positiveInfinitySymbol_13() const { return ___positiveInfinitySymbol_13; }
inline String_t** get_address_of_positiveInfinitySymbol_13() { return &___positiveInfinitySymbol_13; }
inline void set_positiveInfinitySymbol_13(String_t* value)
{
___positiveInfinitySymbol_13 = value;
Il2CppCodeGenWriteBarrier((&___positiveInfinitySymbol_13), value);
}
inline static int32_t get_offset_of_negativeInfinitySymbol_14() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___negativeInfinitySymbol_14)); }
inline String_t* get_negativeInfinitySymbol_14() const { return ___negativeInfinitySymbol_14; }
inline String_t** get_address_of_negativeInfinitySymbol_14() { return &___negativeInfinitySymbol_14; }
inline void set_negativeInfinitySymbol_14(String_t* value)
{
___negativeInfinitySymbol_14 = value;
Il2CppCodeGenWriteBarrier((&___negativeInfinitySymbol_14), value);
}
inline static int32_t get_offset_of_percentDecimalSeparator_15() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___percentDecimalSeparator_15)); }
inline String_t* get_percentDecimalSeparator_15() const { return ___percentDecimalSeparator_15; }
inline String_t** get_address_of_percentDecimalSeparator_15() { return &___percentDecimalSeparator_15; }
inline void set_percentDecimalSeparator_15(String_t* value)
{
___percentDecimalSeparator_15 = value;
Il2CppCodeGenWriteBarrier((&___percentDecimalSeparator_15), value);
}
inline static int32_t get_offset_of_percentGroupSeparator_16() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___percentGroupSeparator_16)); }
inline String_t* get_percentGroupSeparator_16() const { return ___percentGroupSeparator_16; }
inline String_t** get_address_of_percentGroupSeparator_16() { return &___percentGroupSeparator_16; }
inline void set_percentGroupSeparator_16(String_t* value)
{
___percentGroupSeparator_16 = value;
Il2CppCodeGenWriteBarrier((&___percentGroupSeparator_16), value);
}
inline static int32_t get_offset_of_percentSymbol_17() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___percentSymbol_17)); }
inline String_t* get_percentSymbol_17() const { return ___percentSymbol_17; }
inline String_t** get_address_of_percentSymbol_17() { return &___percentSymbol_17; }
inline void set_percentSymbol_17(String_t* value)
{
___percentSymbol_17 = value;
Il2CppCodeGenWriteBarrier((&___percentSymbol_17), value);
}
inline static int32_t get_offset_of_perMilleSymbol_18() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___perMilleSymbol_18)); }
inline String_t* get_perMilleSymbol_18() const { return ___perMilleSymbol_18; }
inline String_t** get_address_of_perMilleSymbol_18() { return &___perMilleSymbol_18; }
inline void set_perMilleSymbol_18(String_t* value)
{
___perMilleSymbol_18 = value;
Il2CppCodeGenWriteBarrier((&___perMilleSymbol_18), value);
}
inline static int32_t get_offset_of_nativeDigits_19() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___nativeDigits_19)); }
inline StringU5BU5D_t1281789340* get_nativeDigits_19() const { return ___nativeDigits_19; }
inline StringU5BU5D_t1281789340** get_address_of_nativeDigits_19() { return &___nativeDigits_19; }
inline void set_nativeDigits_19(StringU5BU5D_t1281789340* value)
{
___nativeDigits_19 = value;
Il2CppCodeGenWriteBarrier((&___nativeDigits_19), value);
}
inline static int32_t get_offset_of_m_dataItem_20() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___m_dataItem_20)); }
inline int32_t get_m_dataItem_20() const { return ___m_dataItem_20; }
inline int32_t* get_address_of_m_dataItem_20() { return &___m_dataItem_20; }
inline void set_m_dataItem_20(int32_t value)
{
___m_dataItem_20 = value;
}
inline static int32_t get_offset_of_numberDecimalDigits_21() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___numberDecimalDigits_21)); }
inline int32_t get_numberDecimalDigits_21() const { return ___numberDecimalDigits_21; }
inline int32_t* get_address_of_numberDecimalDigits_21() { return &___numberDecimalDigits_21; }
inline void set_numberDecimalDigits_21(int32_t value)
{
___numberDecimalDigits_21 = value;
}
inline static int32_t get_offset_of_currencyDecimalDigits_22() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___currencyDecimalDigits_22)); }
inline int32_t get_currencyDecimalDigits_22() const { return ___currencyDecimalDigits_22; }
inline int32_t* get_address_of_currencyDecimalDigits_22() { return &___currencyDecimalDigits_22; }
inline void set_currencyDecimalDigits_22(int32_t value)
{
___currencyDecimalDigits_22 = value;
}
inline static int32_t get_offset_of_currencyPositivePattern_23() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___currencyPositivePattern_23)); }
inline int32_t get_currencyPositivePattern_23() const { return ___currencyPositivePattern_23; }
inline int32_t* get_address_of_currencyPositivePattern_23() { return &___currencyPositivePattern_23; }
inline void set_currencyPositivePattern_23(int32_t value)
{
___currencyPositivePattern_23 = value;
}
inline static int32_t get_offset_of_currencyNegativePattern_24() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___currencyNegativePattern_24)); }
inline int32_t get_currencyNegativePattern_24() const { return ___currencyNegativePattern_24; }
inline int32_t* get_address_of_currencyNegativePattern_24() { return &___currencyNegativePattern_24; }
inline void set_currencyNegativePattern_24(int32_t value)
{
___currencyNegativePattern_24 = value;
}
inline static int32_t get_offset_of_numberNegativePattern_25() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___numberNegativePattern_25)); }
inline int32_t get_numberNegativePattern_25() const { return ___numberNegativePattern_25; }
inline int32_t* get_address_of_numberNegativePattern_25() { return &___numberNegativePattern_25; }
inline void set_numberNegativePattern_25(int32_t value)
{
___numberNegativePattern_25 = value;
}
inline static int32_t get_offset_of_percentPositivePattern_26() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___percentPositivePattern_26)); }
inline int32_t get_percentPositivePattern_26() const { return ___percentPositivePattern_26; }
inline int32_t* get_address_of_percentPositivePattern_26() { return &___percentPositivePattern_26; }
inline void set_percentPositivePattern_26(int32_t value)
{
___percentPositivePattern_26 = value;
}
inline static int32_t get_offset_of_percentNegativePattern_27() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___percentNegativePattern_27)); }
inline int32_t get_percentNegativePattern_27() const { return ___percentNegativePattern_27; }
inline int32_t* get_address_of_percentNegativePattern_27() { return &___percentNegativePattern_27; }
inline void set_percentNegativePattern_27(int32_t value)
{
___percentNegativePattern_27 = value;
}
inline static int32_t get_offset_of_percentDecimalDigits_28() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___percentDecimalDigits_28)); }
inline int32_t get_percentDecimalDigits_28() const { return ___percentDecimalDigits_28; }
inline int32_t* get_address_of_percentDecimalDigits_28() { return &___percentDecimalDigits_28; }
inline void set_percentDecimalDigits_28(int32_t value)
{
___percentDecimalDigits_28 = value;
}
inline static int32_t get_offset_of_digitSubstitution_29() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___digitSubstitution_29)); }
inline int32_t get_digitSubstitution_29() const { return ___digitSubstitution_29; }
inline int32_t* get_address_of_digitSubstitution_29() { return &___digitSubstitution_29; }
inline void set_digitSubstitution_29(int32_t value)
{
___digitSubstitution_29 = value;
}
inline static int32_t get_offset_of_isReadOnly_30() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___isReadOnly_30)); }
inline bool get_isReadOnly_30() const { return ___isReadOnly_30; }
inline bool* get_address_of_isReadOnly_30() { return &___isReadOnly_30; }
inline void set_isReadOnly_30(bool value)
{
___isReadOnly_30 = value;
}
inline static int32_t get_offset_of_m_useUserOverride_31() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___m_useUserOverride_31)); }
inline bool get_m_useUserOverride_31() const { return ___m_useUserOverride_31; }
inline bool* get_address_of_m_useUserOverride_31() { return &___m_useUserOverride_31; }
inline void set_m_useUserOverride_31(bool value)
{
___m_useUserOverride_31 = value;
}
inline static int32_t get_offset_of_m_isInvariant_32() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___m_isInvariant_32)); }
inline bool get_m_isInvariant_32() const { return ___m_isInvariant_32; }
inline bool* get_address_of_m_isInvariant_32() { return &___m_isInvariant_32; }
inline void set_m_isInvariant_32(bool value)
{
___m_isInvariant_32 = value;
}
inline static int32_t get_offset_of_validForParseAsNumber_33() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___validForParseAsNumber_33)); }
inline bool get_validForParseAsNumber_33() const { return ___validForParseAsNumber_33; }
inline bool* get_address_of_validForParseAsNumber_33() { return &___validForParseAsNumber_33; }
inline void set_validForParseAsNumber_33(bool value)
{
___validForParseAsNumber_33 = value;
}
inline static int32_t get_offset_of_validForParseAsCurrency_34() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138, ___validForParseAsCurrency_34)); }
inline bool get_validForParseAsCurrency_34() const { return ___validForParseAsCurrency_34; }
inline bool* get_address_of_validForParseAsCurrency_34() { return &___validForParseAsCurrency_34; }
inline void set_validForParseAsCurrency_34(bool value)
{
___validForParseAsCurrency_34 = value;
}
};
struct NumberFormatInfo_t435877138_StaticFields
{
public:
// System.Globalization.NumberFormatInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.NumberFormatInfo::invariantInfo
NumberFormatInfo_t435877138 * ___invariantInfo_0;
public:
inline static int32_t get_offset_of_invariantInfo_0() { return static_cast<int32_t>(offsetof(NumberFormatInfo_t435877138_StaticFields, ___invariantInfo_0)); }
inline NumberFormatInfo_t435877138 * get_invariantInfo_0() const { return ___invariantInfo_0; }
inline NumberFormatInfo_t435877138 ** get_address_of_invariantInfo_0() { return &___invariantInfo_0; }
inline void set_invariantInfo_0(NumberFormatInfo_t435877138 * value)
{
___invariantInfo_0 = value;
Il2CppCodeGenWriteBarrier((&___invariantInfo_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // NUMBERFORMATINFO_T435877138_H
#ifndef MULTICASTDELEGATE_T_H
#define MULTICASTDELEGATE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MulticastDelegate
struct MulticastDelegate_t : public Delegate_t1188392813
{
public:
// System.Delegate[] System.MulticastDelegate::delegates
DelegateU5BU5D_t1703627840* ___delegates_11;
public:
inline static int32_t get_offset_of_delegates_11() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___delegates_11)); }
inline DelegateU5BU5D_t1703627840* get_delegates_11() const { return ___delegates_11; }
inline DelegateU5BU5D_t1703627840** get_address_of_delegates_11() { return &___delegates_11; }
inline void set_delegates_11(DelegateU5BU5D_t1703627840* value)
{
___delegates_11 = value;
Il2CppCodeGenWriteBarrier((&___delegates_11), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_pinvoke : public Delegate_t1188392813_marshaled_pinvoke
{
DelegateU5BU5D_t1703627840* ___delegates_11;
};
// Native definition for COM marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_com : public Delegate_t1188392813_marshaled_com
{
DelegateU5BU5D_t1703627840* ___delegates_11;
};
#endif // MULTICASTDELEGATE_T_H
#ifndef TYPE_T_H
#define TYPE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Type
struct Type_t : public MemberInfo_t
{
public:
// System.RuntimeTypeHandle System.Type::_impl
RuntimeTypeHandle_t3027515415 ____impl_9;
public:
inline static int32_t get_offset_of__impl_9() { return static_cast<int32_t>(offsetof(Type_t, ____impl_9)); }
inline RuntimeTypeHandle_t3027515415 get__impl_9() const { return ____impl_9; }
inline RuntimeTypeHandle_t3027515415 * get_address_of__impl_9() { return &____impl_9; }
inline void set__impl_9(RuntimeTypeHandle_t3027515415 value)
{
____impl_9 = value;
}
};
struct Type_t_StaticFields
{
public:
// System.Reflection.MemberFilter System.Type::FilterAttribute
MemberFilter_t426314064 * ___FilterAttribute_0;
// System.Reflection.MemberFilter System.Type::FilterName
MemberFilter_t426314064 * ___FilterName_1;
// System.Reflection.MemberFilter System.Type::FilterNameIgnoreCase
MemberFilter_t426314064 * ___FilterNameIgnoreCase_2;
// System.Object System.Type::Missing
RuntimeObject * ___Missing_3;
// System.Char System.Type::Delimiter
Il2CppChar ___Delimiter_4;
// System.Type[] System.Type::EmptyTypes
TypeU5BU5D_t3940880105* ___EmptyTypes_5;
// System.Reflection.Binder System.Type::defaultBinder
Binder_t2999457153 * ___defaultBinder_6;
public:
inline static int32_t get_offset_of_FilterAttribute_0() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterAttribute_0)); }
inline MemberFilter_t426314064 * get_FilterAttribute_0() const { return ___FilterAttribute_0; }
inline MemberFilter_t426314064 ** get_address_of_FilterAttribute_0() { return &___FilterAttribute_0; }
inline void set_FilterAttribute_0(MemberFilter_t426314064 * value)
{
___FilterAttribute_0 = value;
Il2CppCodeGenWriteBarrier((&___FilterAttribute_0), value);
}
inline static int32_t get_offset_of_FilterName_1() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterName_1)); }
inline MemberFilter_t426314064 * get_FilterName_1() const { return ___FilterName_1; }
inline MemberFilter_t426314064 ** get_address_of_FilterName_1() { return &___FilterName_1; }
inline void set_FilterName_1(MemberFilter_t426314064 * value)
{
___FilterName_1 = value;
Il2CppCodeGenWriteBarrier((&___FilterName_1), value);
}
inline static int32_t get_offset_of_FilterNameIgnoreCase_2() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___FilterNameIgnoreCase_2)); }
inline MemberFilter_t426314064 * get_FilterNameIgnoreCase_2() const { return ___FilterNameIgnoreCase_2; }
inline MemberFilter_t426314064 ** get_address_of_FilterNameIgnoreCase_2() { return &___FilterNameIgnoreCase_2; }
inline void set_FilterNameIgnoreCase_2(MemberFilter_t426314064 * value)
{
___FilterNameIgnoreCase_2 = value;
Il2CppCodeGenWriteBarrier((&___FilterNameIgnoreCase_2), value);
}
inline static int32_t get_offset_of_Missing_3() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___Missing_3)); }
inline RuntimeObject * get_Missing_3() const { return ___Missing_3; }
inline RuntimeObject ** get_address_of_Missing_3() { return &___Missing_3; }
inline void set_Missing_3(RuntimeObject * value)
{
___Missing_3 = value;
Il2CppCodeGenWriteBarrier((&___Missing_3), value);
}
inline static int32_t get_offset_of_Delimiter_4() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___Delimiter_4)); }
inline Il2CppChar get_Delimiter_4() const { return ___Delimiter_4; }
inline Il2CppChar* get_address_of_Delimiter_4() { return &___Delimiter_4; }
inline void set_Delimiter_4(Il2CppChar value)
{
___Delimiter_4 = value;
}
inline static int32_t get_offset_of_EmptyTypes_5() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___EmptyTypes_5)); }
inline TypeU5BU5D_t3940880105* get_EmptyTypes_5() const { return ___EmptyTypes_5; }
inline TypeU5BU5D_t3940880105** get_address_of_EmptyTypes_5() { return &___EmptyTypes_5; }
inline void set_EmptyTypes_5(TypeU5BU5D_t3940880105* value)
{
___EmptyTypes_5 = value;
Il2CppCodeGenWriteBarrier((&___EmptyTypes_5), value);
}
inline static int32_t get_offset_of_defaultBinder_6() { return static_cast<int32_t>(offsetof(Type_t_StaticFields, ___defaultBinder_6)); }
inline Binder_t2999457153 * get_defaultBinder_6() const { return ___defaultBinder_6; }
inline Binder_t2999457153 ** get_address_of_defaultBinder_6() { return &___defaultBinder_6; }
inline void set_defaultBinder_6(Binder_t2999457153 * value)
{
___defaultBinder_6 = value;
Il2CppCodeGenWriteBarrier((&___defaultBinder_6), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPE_T_H
#ifndef VARIANT_T2753289927_H
#define VARIANT_T2753289927_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Variant
struct Variant_t2753289927
{
public:
union
{
#pragma pack(push, tp, 1)
struct
{
// System.Int16 System.Variant::vt
int16_t ___vt_0;
};
#pragma pack(pop, tp)
struct
{
int16_t ___vt_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___wReserved1_1_OffsetPadding[2];
// System.UInt16 System.Variant::wReserved1
uint16_t ___wReserved1_1;
};
#pragma pack(pop, tp)
struct
{
char ___wReserved1_1_OffsetPadding_forAlignmentOnly[2];
uint16_t ___wReserved1_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___wReserved2_2_OffsetPadding[4];
// System.UInt16 System.Variant::wReserved2
uint16_t ___wReserved2_2;
};
#pragma pack(pop, tp)
struct
{
char ___wReserved2_2_OffsetPadding_forAlignmentOnly[4];
uint16_t ___wReserved2_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___wReserved3_3_OffsetPadding[6];
// System.UInt16 System.Variant::wReserved3
uint16_t ___wReserved3_3;
};
#pragma pack(pop, tp)
struct
{
char ___wReserved3_3_OffsetPadding_forAlignmentOnly[6];
uint16_t ___wReserved3_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___llVal_4_OffsetPadding[8];
// System.Int64 System.Variant::llVal
int64_t ___llVal_4;
};
#pragma pack(pop, tp)
struct
{
char ___llVal_4_OffsetPadding_forAlignmentOnly[8];
int64_t ___llVal_4_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___lVal_5_OffsetPadding[8];
// System.Int32 System.Variant::lVal
int32_t ___lVal_5;
};
#pragma pack(pop, tp)
struct
{
char ___lVal_5_OffsetPadding_forAlignmentOnly[8];
int32_t ___lVal_5_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___bVal_6_OffsetPadding[8];
// System.Byte System.Variant::bVal
uint8_t ___bVal_6;
};
#pragma pack(pop, tp)
struct
{
char ___bVal_6_OffsetPadding_forAlignmentOnly[8];
uint8_t ___bVal_6_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___iVal_7_OffsetPadding[8];
// System.Int16 System.Variant::iVal
int16_t ___iVal_7;
};
#pragma pack(pop, tp)
struct
{
char ___iVal_7_OffsetPadding_forAlignmentOnly[8];
int16_t ___iVal_7_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___fltVal_8_OffsetPadding[8];
// System.Single System.Variant::fltVal
float ___fltVal_8;
};
#pragma pack(pop, tp)
struct
{
char ___fltVal_8_OffsetPadding_forAlignmentOnly[8];
float ___fltVal_8_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___dblVal_9_OffsetPadding[8];
// System.Double System.Variant::dblVal
double ___dblVal_9;
};
#pragma pack(pop, tp)
struct
{
char ___dblVal_9_OffsetPadding_forAlignmentOnly[8];
double ___dblVal_9_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___boolVal_10_OffsetPadding[8];
// System.Int16 System.Variant::boolVal
int16_t ___boolVal_10;
};
#pragma pack(pop, tp)
struct
{
char ___boolVal_10_OffsetPadding_forAlignmentOnly[8];
int16_t ___boolVal_10_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___bstrVal_11_OffsetPadding[8];
// System.IntPtr System.Variant::bstrVal
intptr_t ___bstrVal_11;
};
#pragma pack(pop, tp)
struct
{
char ___bstrVal_11_OffsetPadding_forAlignmentOnly[8];
intptr_t ___bstrVal_11_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___cVal_12_OffsetPadding[8];
// System.SByte System.Variant::cVal
int8_t ___cVal_12;
};
#pragma pack(pop, tp)
struct
{
char ___cVal_12_OffsetPadding_forAlignmentOnly[8];
int8_t ___cVal_12_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uiVal_13_OffsetPadding[8];
// System.UInt16 System.Variant::uiVal
uint16_t ___uiVal_13;
};
#pragma pack(pop, tp)
struct
{
char ___uiVal_13_OffsetPadding_forAlignmentOnly[8];
uint16_t ___uiVal_13_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___ulVal_14_OffsetPadding[8];
// System.UInt32 System.Variant::ulVal
uint32_t ___ulVal_14;
};
#pragma pack(pop, tp)
struct
{
char ___ulVal_14_OffsetPadding_forAlignmentOnly[8];
uint32_t ___ulVal_14_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___ullVal_15_OffsetPadding[8];
// System.UInt64 System.Variant::ullVal
uint64_t ___ullVal_15;
};
#pragma pack(pop, tp)
struct
{
char ___ullVal_15_OffsetPadding_forAlignmentOnly[8];
uint64_t ___ullVal_15_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___intVal_16_OffsetPadding[8];
// System.Int32 System.Variant::intVal
int32_t ___intVal_16;
};
#pragma pack(pop, tp)
struct
{
char ___intVal_16_OffsetPadding_forAlignmentOnly[8];
int32_t ___intVal_16_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uintVal_17_OffsetPadding[8];
// System.UInt32 System.Variant::uintVal
uint32_t ___uintVal_17;
};
#pragma pack(pop, tp)
struct
{
char ___uintVal_17_OffsetPadding_forAlignmentOnly[8];
uint32_t ___uintVal_17_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___pdispVal_18_OffsetPadding[8];
// System.IntPtr System.Variant::pdispVal
intptr_t ___pdispVal_18;
};
#pragma pack(pop, tp)
struct
{
char ___pdispVal_18_OffsetPadding_forAlignmentOnly[8];
intptr_t ___pdispVal_18_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___bRecord_19_OffsetPadding[8];
// System.BRECORD System.Variant::bRecord
BRECORD_t3470580684 ___bRecord_19;
};
#pragma pack(pop, tp)
struct
{
char ___bRecord_19_OffsetPadding_forAlignmentOnly[8];
BRECORD_t3470580684 ___bRecord_19_forAlignmentOnly;
};
};
public:
inline static int32_t get_offset_of_vt_0() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___vt_0)); }
inline int16_t get_vt_0() const { return ___vt_0; }
inline int16_t* get_address_of_vt_0() { return &___vt_0; }
inline void set_vt_0(int16_t value)
{
___vt_0 = value;
}
inline static int32_t get_offset_of_wReserved1_1() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___wReserved1_1)); }
inline uint16_t get_wReserved1_1() const { return ___wReserved1_1; }
inline uint16_t* get_address_of_wReserved1_1() { return &___wReserved1_1; }
inline void set_wReserved1_1(uint16_t value)
{
___wReserved1_1 = value;
}
inline static int32_t get_offset_of_wReserved2_2() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___wReserved2_2)); }
inline uint16_t get_wReserved2_2() const { return ___wReserved2_2; }
inline uint16_t* get_address_of_wReserved2_2() { return &___wReserved2_2; }
inline void set_wReserved2_2(uint16_t value)
{
___wReserved2_2 = value;
}
inline static int32_t get_offset_of_wReserved3_3() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___wReserved3_3)); }
inline uint16_t get_wReserved3_3() const { return ___wReserved3_3; }
inline uint16_t* get_address_of_wReserved3_3() { return &___wReserved3_3; }
inline void set_wReserved3_3(uint16_t value)
{
___wReserved3_3 = value;
}
inline static int32_t get_offset_of_llVal_4() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___llVal_4)); }
inline int64_t get_llVal_4() const { return ___llVal_4; }
inline int64_t* get_address_of_llVal_4() { return &___llVal_4; }
inline void set_llVal_4(int64_t value)
{
___llVal_4 = value;
}
inline static int32_t get_offset_of_lVal_5() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___lVal_5)); }
inline int32_t get_lVal_5() const { return ___lVal_5; }
inline int32_t* get_address_of_lVal_5() { return &___lVal_5; }
inline void set_lVal_5(int32_t value)
{
___lVal_5 = value;
}
inline static int32_t get_offset_of_bVal_6() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___bVal_6)); }
inline uint8_t get_bVal_6() const { return ___bVal_6; }
inline uint8_t* get_address_of_bVal_6() { return &___bVal_6; }
inline void set_bVal_6(uint8_t value)
{
___bVal_6 = value;
}
inline static int32_t get_offset_of_iVal_7() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___iVal_7)); }
inline int16_t get_iVal_7() const { return ___iVal_7; }
inline int16_t* get_address_of_iVal_7() { return &___iVal_7; }
inline void set_iVal_7(int16_t value)
{
___iVal_7 = value;
}
inline static int32_t get_offset_of_fltVal_8() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___fltVal_8)); }
inline float get_fltVal_8() const { return ___fltVal_8; }
inline float* get_address_of_fltVal_8() { return &___fltVal_8; }
inline void set_fltVal_8(float value)
{
___fltVal_8 = value;
}
inline static int32_t get_offset_of_dblVal_9() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___dblVal_9)); }
inline double get_dblVal_9() const { return ___dblVal_9; }
inline double* get_address_of_dblVal_9() { return &___dblVal_9; }
inline void set_dblVal_9(double value)
{
___dblVal_9 = value;
}
inline static int32_t get_offset_of_boolVal_10() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___boolVal_10)); }
inline int16_t get_boolVal_10() const { return ___boolVal_10; }
inline int16_t* get_address_of_boolVal_10() { return &___boolVal_10; }
inline void set_boolVal_10(int16_t value)
{
___boolVal_10 = value;
}
inline static int32_t get_offset_of_bstrVal_11() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___bstrVal_11)); }
inline intptr_t get_bstrVal_11() const { return ___bstrVal_11; }
inline intptr_t* get_address_of_bstrVal_11() { return &___bstrVal_11; }
inline void set_bstrVal_11(intptr_t value)
{
___bstrVal_11 = value;
}
inline static int32_t get_offset_of_cVal_12() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___cVal_12)); }
inline int8_t get_cVal_12() const { return ___cVal_12; }
inline int8_t* get_address_of_cVal_12() { return &___cVal_12; }
inline void set_cVal_12(int8_t value)
{
___cVal_12 = value;
}
inline static int32_t get_offset_of_uiVal_13() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___uiVal_13)); }
inline uint16_t get_uiVal_13() const { return ___uiVal_13; }
inline uint16_t* get_address_of_uiVal_13() { return &___uiVal_13; }
inline void set_uiVal_13(uint16_t value)
{
___uiVal_13 = value;
}
inline static int32_t get_offset_of_ulVal_14() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___ulVal_14)); }
inline uint32_t get_ulVal_14() const { return ___ulVal_14; }
inline uint32_t* get_address_of_ulVal_14() { return &___ulVal_14; }
inline void set_ulVal_14(uint32_t value)
{
___ulVal_14 = value;
}
inline static int32_t get_offset_of_ullVal_15() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___ullVal_15)); }
inline uint64_t get_ullVal_15() const { return ___ullVal_15; }
inline uint64_t* get_address_of_ullVal_15() { return &___ullVal_15; }
inline void set_ullVal_15(uint64_t value)
{
___ullVal_15 = value;
}
inline static int32_t get_offset_of_intVal_16() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___intVal_16)); }
inline int32_t get_intVal_16() const { return ___intVal_16; }
inline int32_t* get_address_of_intVal_16() { return &___intVal_16; }
inline void set_intVal_16(int32_t value)
{
___intVal_16 = value;
}
inline static int32_t get_offset_of_uintVal_17() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___uintVal_17)); }
inline uint32_t get_uintVal_17() const { return ___uintVal_17; }
inline uint32_t* get_address_of_uintVal_17() { return &___uintVal_17; }
inline void set_uintVal_17(uint32_t value)
{
___uintVal_17 = value;
}
inline static int32_t get_offset_of_pdispVal_18() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___pdispVal_18)); }
inline intptr_t get_pdispVal_18() const { return ___pdispVal_18; }
inline intptr_t* get_address_of_pdispVal_18() { return &___pdispVal_18; }
inline void set_pdispVal_18(intptr_t value)
{
___pdispVal_18 = value;
}
inline static int32_t get_offset_of_bRecord_19() { return static_cast<int32_t>(offsetof(Variant_t2753289927, ___bRecord_19)); }
inline BRECORD_t3470580684 get_bRecord_19() const { return ___bRecord_19; }
inline BRECORD_t3470580684 * get_address_of_bRecord_19() { return &___bRecord_19; }
inline void set_bRecord_19(BRECORD_t3470580684 value)
{
___bRecord_19 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VARIANT_T2753289927_H
#ifndef ARGUMENTNULLEXCEPTION_T1615371798_H
#define ARGUMENTNULLEXCEPTION_T1615371798_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ArgumentNullException
struct ArgumentNullException_t1615371798 : public ArgumentException_t132251570
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ARGUMENTNULLEXCEPTION_T1615371798_H
#ifndef CONSOLEKEYINFO_T1802691652_H
#define CONSOLEKEYINFO_T1802691652_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ConsoleKeyInfo
struct ConsoleKeyInfo_t1802691652
{
public:
// System.Char System.ConsoleKeyInfo::_keyChar
Il2CppChar ____keyChar_0;
// System.ConsoleKey System.ConsoleKeyInfo::_key
int32_t ____key_1;
// System.ConsoleModifiers System.ConsoleKeyInfo::_mods
int32_t ____mods_2;
public:
inline static int32_t get_offset_of__keyChar_0() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_t1802691652, ____keyChar_0)); }
inline Il2CppChar get__keyChar_0() const { return ____keyChar_0; }
inline Il2CppChar* get_address_of__keyChar_0() { return &____keyChar_0; }
inline void set__keyChar_0(Il2CppChar value)
{
____keyChar_0 = value;
}
inline static int32_t get_offset_of__key_1() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_t1802691652, ____key_1)); }
inline int32_t get__key_1() const { return ____key_1; }
inline int32_t* get_address_of__key_1() { return &____key_1; }
inline void set__key_1(int32_t value)
{
____key_1 = value;
}
inline static int32_t get_offset_of__mods_2() { return static_cast<int32_t>(offsetof(ConsoleKeyInfo_t1802691652, ____mods_2)); }
inline int32_t get__mods_2() const { return ____mods_2; }
inline int32_t* get_address_of__mods_2() { return &____mods_2; }
inline void set__mods_2(int32_t value)
{
____mods_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.ConsoleKeyInfo
struct ConsoleKeyInfo_t1802691652_marshaled_pinvoke
{
uint8_t ____keyChar_0;
int32_t ____key_1;
int32_t ____mods_2;
};
// Native definition for COM marshalling of System.ConsoleKeyInfo
struct ConsoleKeyInfo_t1802691652_marshaled_com
{
uint8_t ____keyChar_0;
int32_t ____key_1;
int32_t ____mods_2;
};
#endif // CONSOLEKEYINFO_T1802691652_H
#ifndef RUNTIMEASSEMBLY_T1451753063_H
#define RUNTIMEASSEMBLY_T1451753063_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.RuntimeAssembly
struct RuntimeAssembly_t1451753063 : public Assembly_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEASSEMBLY_T1451753063_H
#ifndef ARGUMENTOUTOFRANGEEXCEPTION_T777629997_H
#define ARGUMENTOUTOFRANGEEXCEPTION_T777629997_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ArgumentOutOfRangeException
struct ArgumentOutOfRangeException_t777629997 : public ArgumentException_t132251570
{
public:
// System.Object System.ArgumentOutOfRangeException::m_actualValue
RuntimeObject * ___m_actualValue_19;
public:
inline static int32_t get_offset_of_m_actualValue_19() { return static_cast<int32_t>(offsetof(ArgumentOutOfRangeException_t777629997, ___m_actualValue_19)); }
inline RuntimeObject * get_m_actualValue_19() const { return ___m_actualValue_19; }
inline RuntimeObject ** get_address_of_m_actualValue_19() { return &___m_actualValue_19; }
inline void set_m_actualValue_19(RuntimeObject * value)
{
___m_actualValue_19 = value;
Il2CppCodeGenWriteBarrier((&___m_actualValue_19), value);
}
};
struct ArgumentOutOfRangeException_t777629997_StaticFields
{
public:
// System.String modreq(System.Runtime.CompilerServices.IsVolatile) System.ArgumentOutOfRangeException::_rangeMessage
String_t* ____rangeMessage_18;
public:
inline static int32_t get_offset_of__rangeMessage_18() { return static_cast<int32_t>(offsetof(ArgumentOutOfRangeException_t777629997_StaticFields, ____rangeMessage_18)); }
inline String_t* get__rangeMessage_18() const { return ____rangeMessage_18; }
inline String_t** get_address_of__rangeMessage_18() { return &____rangeMessage_18; }
inline void set__rangeMessage_18(String_t* value)
{
____rangeMessage_18 = value;
Il2CppCodeGenWriteBarrier((&____rangeMessage_18), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ARGUMENTOUTOFRANGEEXCEPTION_T777629997_H
#ifndef MODULE_T2987026101_H
#define MODULE_T2987026101_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.Module
struct Module_t2987026101 : public RuntimeObject
{
public:
// System.IntPtr System.Reflection.Module::_impl
intptr_t ____impl_2;
// System.Reflection.Assembly System.Reflection.Module::assembly
Assembly_t * ___assembly_3;
// System.String System.Reflection.Module::fqname
String_t* ___fqname_4;
// System.String System.Reflection.Module::name
String_t* ___name_5;
// System.String System.Reflection.Module::scopename
String_t* ___scopename_6;
// System.Boolean System.Reflection.Module::is_resource
bool ___is_resource_7;
// System.Int32 System.Reflection.Module::token
int32_t ___token_8;
public:
inline static int32_t get_offset_of__impl_2() { return static_cast<int32_t>(offsetof(Module_t2987026101, ____impl_2)); }
inline intptr_t get__impl_2() const { return ____impl_2; }
inline intptr_t* get_address_of__impl_2() { return &____impl_2; }
inline void set__impl_2(intptr_t value)
{
____impl_2 = value;
}
inline static int32_t get_offset_of_assembly_3() { return static_cast<int32_t>(offsetof(Module_t2987026101, ___assembly_3)); }
inline Assembly_t * get_assembly_3() const { return ___assembly_3; }
inline Assembly_t ** get_address_of_assembly_3() { return &___assembly_3; }
inline void set_assembly_3(Assembly_t * value)
{
___assembly_3 = value;
Il2CppCodeGenWriteBarrier((&___assembly_3), value);
}
inline static int32_t get_offset_of_fqname_4() { return static_cast<int32_t>(offsetof(Module_t2987026101, ___fqname_4)); }
inline String_t* get_fqname_4() const { return ___fqname_4; }
inline String_t** get_address_of_fqname_4() { return &___fqname_4; }
inline void set_fqname_4(String_t* value)
{
___fqname_4 = value;
Il2CppCodeGenWriteBarrier((&___fqname_4), value);
}
inline static int32_t get_offset_of_name_5() { return static_cast<int32_t>(offsetof(Module_t2987026101, ___name_5)); }
inline String_t* get_name_5() const { return ___name_5; }
inline String_t** get_address_of_name_5() { return &___name_5; }
inline void set_name_5(String_t* value)
{
___name_5 = value;
Il2CppCodeGenWriteBarrier((&___name_5), value);
}
inline static int32_t get_offset_of_scopename_6() { return static_cast<int32_t>(offsetof(Module_t2987026101, ___scopename_6)); }
inline String_t* get_scopename_6() const { return ___scopename_6; }
inline String_t** get_address_of_scopename_6() { return &___scopename_6; }
inline void set_scopename_6(String_t* value)
{
___scopename_6 = value;
Il2CppCodeGenWriteBarrier((&___scopename_6), value);
}
inline static int32_t get_offset_of_is_resource_7() { return static_cast<int32_t>(offsetof(Module_t2987026101, ___is_resource_7)); }
inline bool get_is_resource_7() const { return ___is_resource_7; }
inline bool* get_address_of_is_resource_7() { return &___is_resource_7; }
inline void set_is_resource_7(bool value)
{
___is_resource_7 = value;
}
inline static int32_t get_offset_of_token_8() { return static_cast<int32_t>(offsetof(Module_t2987026101, ___token_8)); }
inline int32_t get_token_8() const { return ___token_8; }
inline int32_t* get_address_of_token_8() { return &___token_8; }
inline void set_token_8(int32_t value)
{
___token_8 = value;
}
};
struct Module_t2987026101_StaticFields
{
public:
// System.Reflection.TypeFilter System.Reflection.Module::FilterTypeName
TypeFilter_t2356120900 * ___FilterTypeName_0;
// System.Reflection.TypeFilter System.Reflection.Module::FilterTypeNameIgnoreCase
TypeFilter_t2356120900 * ___FilterTypeNameIgnoreCase_1;
public:
inline static int32_t get_offset_of_FilterTypeName_0() { return static_cast<int32_t>(offsetof(Module_t2987026101_StaticFields, ___FilterTypeName_0)); }
inline TypeFilter_t2356120900 * get_FilterTypeName_0() const { return ___FilterTypeName_0; }
inline TypeFilter_t2356120900 ** get_address_of_FilterTypeName_0() { return &___FilterTypeName_0; }
inline void set_FilterTypeName_0(TypeFilter_t2356120900 * value)
{
___FilterTypeName_0 = value;
Il2CppCodeGenWriteBarrier((&___FilterTypeName_0), value);
}
inline static int32_t get_offset_of_FilterTypeNameIgnoreCase_1() { return static_cast<int32_t>(offsetof(Module_t2987026101_StaticFields, ___FilterTypeNameIgnoreCase_1)); }
inline TypeFilter_t2356120900 * get_FilterTypeNameIgnoreCase_1() const { return ___FilterTypeNameIgnoreCase_1; }
inline TypeFilter_t2356120900 ** get_address_of_FilterTypeNameIgnoreCase_1() { return &___FilterTypeNameIgnoreCase_1; }
inline void set_FilterTypeNameIgnoreCase_1(TypeFilter_t2356120900 * value)
{
___FilterTypeNameIgnoreCase_1 = value;
Il2CppCodeGenWriteBarrier((&___FilterTypeNameIgnoreCase_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Reflection.Module
struct Module_t2987026101_marshaled_pinvoke
{
intptr_t ____impl_2;
Assembly_t_marshaled_pinvoke* ___assembly_3;
char* ___fqname_4;
char* ___name_5;
char* ___scopename_6;
int32_t ___is_resource_7;
int32_t ___token_8;
};
// Native definition for COM marshalling of System.Reflection.Module
struct Module_t2987026101_marshaled_com
{
intptr_t ____impl_2;
Assembly_t_marshaled_com* ___assembly_3;
Il2CppChar* ___fqname_4;
Il2CppChar* ___name_5;
Il2CppChar* ___scopename_6;
int32_t ___is_resource_7;
int32_t ___token_8;
};
#endif // MODULE_T2987026101_H
#ifndef STREAMINGCONTEXT_T3711869237_H
#define STREAMINGCONTEXT_T3711869237_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.StreamingContext
struct StreamingContext_t3711869237
{
public:
// System.Object System.Runtime.Serialization.StreamingContext::m_additionalContext
RuntimeObject * ___m_additionalContext_0;
// System.Runtime.Serialization.StreamingContextStates System.Runtime.Serialization.StreamingContext::m_state
int32_t ___m_state_1;
public:
inline static int32_t get_offset_of_m_additionalContext_0() { return static_cast<int32_t>(offsetof(StreamingContext_t3711869237, ___m_additionalContext_0)); }
inline RuntimeObject * get_m_additionalContext_0() const { return ___m_additionalContext_0; }
inline RuntimeObject ** get_address_of_m_additionalContext_0() { return &___m_additionalContext_0; }
inline void set_m_additionalContext_0(RuntimeObject * value)
{
___m_additionalContext_0 = value;
Il2CppCodeGenWriteBarrier((&___m_additionalContext_0), value);
}
inline static int32_t get_offset_of_m_state_1() { return static_cast<int32_t>(offsetof(StreamingContext_t3711869237, ___m_state_1)); }
inline int32_t get_m_state_1() const { return ___m_state_1; }
inline int32_t* get_address_of_m_state_1() { return &___m_state_1; }
inline void set_m_state_1(int32_t value)
{
___m_state_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Runtime.Serialization.StreamingContext
struct StreamingContext_t3711869237_marshaled_pinvoke
{
Il2CppIUnknown* ___m_additionalContext_0;
int32_t ___m_state_1;
};
// Native definition for COM marshalling of System.Runtime.Serialization.StreamingContext
struct StreamingContext_t3711869237_marshaled_com
{
Il2CppIUnknown* ___m_additionalContext_0;
int32_t ___m_state_1;
};
#endif // STREAMINGCONTEXT_T3711869237_H
#ifndef UNHANDLEDEXCEPTIONEVENTHANDLER_T3101989324_H
#define UNHANDLEDEXCEPTIONEVENTHANDLER_T3101989324_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.UnhandledExceptionEventHandler
struct UnhandledExceptionEventHandler_t3101989324 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNHANDLEDEXCEPTIONEVENTHANDLER_T3101989324_H
#ifndef ASYNCCALLBACK_T3962456242_H
#define ASYNCCALLBACK_T3962456242_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.AsyncCallback
struct AsyncCallback_t3962456242 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASYNCCALLBACK_T3962456242_H
#ifndef TYPEINFO_T1690786683_H
#define TYPEINFO_T1690786683_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Reflection.TypeInfo
struct TypeInfo_t1690786683 : public Type_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPEINFO_T1690786683_H
#ifndef RUNTIMETYPE_T3636489352_H
#define RUNTIMETYPE_T3636489352_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.RuntimeType
struct RuntimeType_t3636489352 : public TypeInfo_t1690786683
{
public:
// System.MonoTypeInfo System.RuntimeType::type_info
MonoTypeInfo_t3366989025 * ___type_info_26;
// System.Object System.RuntimeType::GenericCache
RuntimeObject * ___GenericCache_27;
// System.Reflection.RuntimeConstructorInfo System.RuntimeType::m_serializationCtor
RuntimeConstructorInfo_t1806616898 * ___m_serializationCtor_28;
public:
inline static int32_t get_offset_of_type_info_26() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352, ___type_info_26)); }
inline MonoTypeInfo_t3366989025 * get_type_info_26() const { return ___type_info_26; }
inline MonoTypeInfo_t3366989025 ** get_address_of_type_info_26() { return &___type_info_26; }
inline void set_type_info_26(MonoTypeInfo_t3366989025 * value)
{
___type_info_26 = value;
Il2CppCodeGenWriteBarrier((&___type_info_26), value);
}
inline static int32_t get_offset_of_GenericCache_27() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352, ___GenericCache_27)); }
inline RuntimeObject * get_GenericCache_27() const { return ___GenericCache_27; }
inline RuntimeObject ** get_address_of_GenericCache_27() { return &___GenericCache_27; }
inline void set_GenericCache_27(RuntimeObject * value)
{
___GenericCache_27 = value;
Il2CppCodeGenWriteBarrier((&___GenericCache_27), value);
}
inline static int32_t get_offset_of_m_serializationCtor_28() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352, ___m_serializationCtor_28)); }
inline RuntimeConstructorInfo_t1806616898 * get_m_serializationCtor_28() const { return ___m_serializationCtor_28; }
inline RuntimeConstructorInfo_t1806616898 ** get_address_of_m_serializationCtor_28() { return &___m_serializationCtor_28; }
inline void set_m_serializationCtor_28(RuntimeConstructorInfo_t1806616898 * value)
{
___m_serializationCtor_28 = value;
Il2CppCodeGenWriteBarrier((&___m_serializationCtor_28), value);
}
};
struct RuntimeType_t3636489352_StaticFields
{
public:
// System.RuntimeType System.RuntimeType::ValueType
RuntimeType_t3636489352 * ___ValueType_10;
// System.RuntimeType System.RuntimeType::EnumType
RuntimeType_t3636489352 * ___EnumType_11;
// System.RuntimeType System.RuntimeType::ObjectType
RuntimeType_t3636489352 * ___ObjectType_12;
// System.RuntimeType System.RuntimeType::StringType
RuntimeType_t3636489352 * ___StringType_13;
// System.RuntimeType System.RuntimeType::DelegateType
RuntimeType_t3636489352 * ___DelegateType_14;
// System.Type[] System.RuntimeType::s_SICtorParamTypes
TypeU5BU5D_t3940880105* ___s_SICtorParamTypes_15;
// System.RuntimeType System.RuntimeType::s_typedRef
RuntimeType_t3636489352 * ___s_typedRef_25;
// System.Collections.Generic.Dictionary`2<System.Guid,System.Type> System.RuntimeType::clsid_types
Dictionary_2_t1532962293 * ___clsid_types_29;
// System.Reflection.Emit.AssemblyBuilder System.RuntimeType::clsid_assemblybuilder
AssemblyBuilder_t359885250 * ___clsid_assemblybuilder_30;
public:
inline static int32_t get_offset_of_ValueType_10() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352_StaticFields, ___ValueType_10)); }
inline RuntimeType_t3636489352 * get_ValueType_10() const { return ___ValueType_10; }
inline RuntimeType_t3636489352 ** get_address_of_ValueType_10() { return &___ValueType_10; }
inline void set_ValueType_10(RuntimeType_t3636489352 * value)
{
___ValueType_10 = value;
Il2CppCodeGenWriteBarrier((&___ValueType_10), value);
}
inline static int32_t get_offset_of_EnumType_11() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352_StaticFields, ___EnumType_11)); }
inline RuntimeType_t3636489352 * get_EnumType_11() const { return ___EnumType_11; }
inline RuntimeType_t3636489352 ** get_address_of_EnumType_11() { return &___EnumType_11; }
inline void set_EnumType_11(RuntimeType_t3636489352 * value)
{
___EnumType_11 = value;
Il2CppCodeGenWriteBarrier((&___EnumType_11), value);
}
inline static int32_t get_offset_of_ObjectType_12() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352_StaticFields, ___ObjectType_12)); }
inline RuntimeType_t3636489352 * get_ObjectType_12() const { return ___ObjectType_12; }
inline RuntimeType_t3636489352 ** get_address_of_ObjectType_12() { return &___ObjectType_12; }
inline void set_ObjectType_12(RuntimeType_t3636489352 * value)
{
___ObjectType_12 = value;
Il2CppCodeGenWriteBarrier((&___ObjectType_12), value);
}
inline static int32_t get_offset_of_StringType_13() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352_StaticFields, ___StringType_13)); }
inline RuntimeType_t3636489352 * get_StringType_13() const { return ___StringType_13; }
inline RuntimeType_t3636489352 ** get_address_of_StringType_13() { return &___StringType_13; }
inline void set_StringType_13(RuntimeType_t3636489352 * value)
{
___StringType_13 = value;
Il2CppCodeGenWriteBarrier((&___StringType_13), value);
}
inline static int32_t get_offset_of_DelegateType_14() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352_StaticFields, ___DelegateType_14)); }
inline RuntimeType_t3636489352 * get_DelegateType_14() const { return ___DelegateType_14; }
inline RuntimeType_t3636489352 ** get_address_of_DelegateType_14() { return &___DelegateType_14; }
inline void set_DelegateType_14(RuntimeType_t3636489352 * value)
{
___DelegateType_14 = value;
Il2CppCodeGenWriteBarrier((&___DelegateType_14), value);
}
inline static int32_t get_offset_of_s_SICtorParamTypes_15() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352_StaticFields, ___s_SICtorParamTypes_15)); }
inline TypeU5BU5D_t3940880105* get_s_SICtorParamTypes_15() const { return ___s_SICtorParamTypes_15; }
inline TypeU5BU5D_t3940880105** get_address_of_s_SICtorParamTypes_15() { return &___s_SICtorParamTypes_15; }
inline void set_s_SICtorParamTypes_15(TypeU5BU5D_t3940880105* value)
{
___s_SICtorParamTypes_15 = value;
Il2CppCodeGenWriteBarrier((&___s_SICtorParamTypes_15), value);
}
inline static int32_t get_offset_of_s_typedRef_25() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352_StaticFields, ___s_typedRef_25)); }
inline RuntimeType_t3636489352 * get_s_typedRef_25() const { return ___s_typedRef_25; }
inline RuntimeType_t3636489352 ** get_address_of_s_typedRef_25() { return &___s_typedRef_25; }
inline void set_s_typedRef_25(RuntimeType_t3636489352 * value)
{
___s_typedRef_25 = value;
Il2CppCodeGenWriteBarrier((&___s_typedRef_25), value);
}
inline static int32_t get_offset_of_clsid_types_29() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352_StaticFields, ___clsid_types_29)); }
inline Dictionary_2_t1532962293 * get_clsid_types_29() const { return ___clsid_types_29; }
inline Dictionary_2_t1532962293 ** get_address_of_clsid_types_29() { return &___clsid_types_29; }
inline void set_clsid_types_29(Dictionary_2_t1532962293 * value)
{
___clsid_types_29 = value;
Il2CppCodeGenWriteBarrier((&___clsid_types_29), value);
}
inline static int32_t get_offset_of_clsid_assemblybuilder_30() { return static_cast<int32_t>(offsetof(RuntimeType_t3636489352_StaticFields, ___clsid_assemblybuilder_30)); }
inline AssemblyBuilder_t359885250 * get_clsid_assemblybuilder_30() const { return ___clsid_assemblybuilder_30; }
inline AssemblyBuilder_t359885250 ** get_address_of_clsid_assemblybuilder_30() { return &___clsid_assemblybuilder_30; }
inline void set_clsid_assemblybuilder_30(AssemblyBuilder_t359885250 * value)
{
___clsid_assemblybuilder_30 = value;
Il2CppCodeGenWriteBarrier((&___clsid_assemblybuilder_30), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMETYPE_T3636489352_H
// System.Object[]
struct ObjectU5BU5D_t2843939325 : public RuntimeArray
{
public:
ALIGN_FIELD (8) RuntimeObject * m_Items[1];
public:
inline RuntimeObject * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline RuntimeObject ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, RuntimeObject * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline RuntimeObject * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline RuntimeObject ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, RuntimeObject * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// System.Delegate[]
struct DelegateU5BU5D_t1703627840 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Delegate_t1188392813 * m_Items[1];
public:
inline Delegate_t1188392813 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Delegate_t1188392813 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Delegate_t1188392813 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline Delegate_t1188392813 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Delegate_t1188392813 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Delegate_t1188392813 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// System.Int32[]
struct Int32U5BU5D_t385246372 : public RuntimeArray
{
public:
ALIGN_FIELD (8) int32_t m_Items[1];
public:
inline int32_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline int32_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, int32_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline int32_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline int32_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, int32_t value)
{
m_Items[index] = value;
}
};
// System.Type[]
struct TypeU5BU5D_t3940880105 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Type_t * m_Items[1];
public:
inline Type_t * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Type_t ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Type_t * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
inline Type_t * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Type_t ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Type_t * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier(m_Items + index, value);
}
};
// System.Char[]
struct CharU5BU5D_t3528271667 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Il2CppChar m_Items[1];
public:
inline Il2CppChar GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Il2CppChar* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Il2CppChar value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline Il2CppChar GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Il2CppChar* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Il2CppChar value)
{
m_Items[index] = value;
}
};
// System.Byte[]
struct ByteU5BU5D_t4116647657 : public RuntimeArray
{
public:
ALIGN_FIELD (8) uint8_t m_Items[1];
public:
inline uint8_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint8_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint8_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint8_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint8_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint8_t value)
{
m_Items[index] = value;
}
};
extern "C" void InputRecord_t2660212290_marshal_pinvoke(const InputRecord_t2660212290& unmarshaled, InputRecord_t2660212290_marshaled_pinvoke& marshaled);
extern "C" void InputRecord_t2660212290_marshal_pinvoke_back(const InputRecord_t2660212290_marshaled_pinvoke& marshaled, InputRecord_t2660212290& unmarshaled);
extern "C" void InputRecord_t2660212290_marshal_pinvoke_cleanup(InputRecord_t2660212290_marshaled_pinvoke& marshaled);
// System.Void System.Collections.Generic.List`1<System.Int32>::.ctor()
extern "C" void List_1__ctor_m1204004817_gshared (List_1_t128053199 * __this, const RuntimeMethod* method);
// System.Void System.Collections.Generic.List`1<System.Int32>::Add(T)
extern "C" void List_1_Add_m2080863212_gshared (List_1_t128053199 * __this, int32_t p0, const RuntimeMethod* method);
// T[] System.Collections.Generic.List`1<System.Int32>::ToArray()
extern "C" Int32U5BU5D_t385246372* List_1_ToArray_m1469074435_gshared (List_1_t128053199 * __this, const RuntimeMethod* method);
// System.String System.Environment::GetResourceString(System.String)
extern "C" String_t* Environment_GetResourceString_m2063689938 (RuntimeObject * __this /* static, unused */, String_t* ___key0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.ArgumentException::.ctor(System.String)
extern "C" void ArgumentException__ctor_m1312628991 (ArgumentException_t132251570 * __this, String_t* ___message0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UInt32::CompareTo(System.Object)
extern "C" int32_t UInt32_CompareTo_m362578384 (uint32_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UInt32::CompareTo(System.UInt32)
extern "C" int32_t UInt32_CompareTo_m2218823230 (uint32_t* __this, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.UInt32::Equals(System.Object)
extern "C" bool UInt32_Equals_m351935437 (uint32_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.UInt32::Equals(System.UInt32)
extern "C" bool UInt32_Equals_m4250336581 (uint32_t* __this, uint32_t ___obj0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UInt32::GetHashCode()
extern "C" int32_t UInt32_GetHashCode_m3722548385 (uint32_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Globalization.NumberFormatInfo System.Globalization.NumberFormatInfo::get_CurrentInfo()
extern "C" NumberFormatInfo_t435877138 * NumberFormatInfo_get_CurrentInfo_m2605582008 (RuntimeObject * __this /* static, unused */, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.Number::FormatUInt32(System.UInt32,System.String,System.Globalization.NumberFormatInfo)
extern "C" String_t* Number_FormatUInt32_m2486347252 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, String_t* ___format1, NumberFormatInfo_t435877138 * ___info2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.UInt32::ToString()
extern "C" String_t* UInt32_ToString_m2574561716 (uint32_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Globalization.NumberFormatInfo System.Globalization.NumberFormatInfo::GetInstance(System.IFormatProvider)
extern "C" NumberFormatInfo_t435877138 * NumberFormatInfo_GetInstance_m2833078205 (RuntimeObject * __this /* static, unused */, RuntimeObject* ___formatProvider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.UInt32::ToString(System.IFormatProvider)
extern "C" String_t* UInt32_ToString_m4293943134 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.UInt32::ToString(System.String,System.IFormatProvider)
extern "C" String_t* UInt32_ToString_m2420423038 (uint32_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt32 System.Number::ParseUInt32(System.String,System.Globalization.NumberStyles,System.Globalization.NumberFormatInfo)
extern "C" uint32_t Number_ParseUInt32_m4237573864 (RuntimeObject * __this /* static, unused */, String_t* ___value0, int32_t ___options1, NumberFormatInfo_t435877138 * ___numfmt2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Globalization.NumberFormatInfo::ValidateParseStyleInteger(System.Globalization.NumberStyles)
extern "C" void NumberFormatInfo_ValidateParseStyleInteger_m957858295 (RuntimeObject * __this /* static, unused */, int32_t ___style0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Number::TryParseUInt32(System.String,System.Globalization.NumberStyles,System.Globalization.NumberFormatInfo,System.UInt32&)
extern "C" bool Number_TryParseUInt32_m2802499845 (RuntimeObject * __this /* static, unused */, String_t* ___s0, int32_t ___style1, NumberFormatInfo_t435877138 * ___info2, uint32_t* ___result3, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.TypeCode System.UInt32::GetTypeCode()
extern "C" int32_t UInt32_GetTypeCode_m88917904 (uint32_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Convert::ToBoolean(System.UInt32)
extern "C" bool Convert_ToBoolean_m2807110707 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.UInt32::System.IConvertible.ToBoolean(System.IFormatProvider)
extern "C" bool UInt32_System_IConvertible_ToBoolean_m1763673183 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Char System.Convert::ToChar(System.UInt32)
extern "C" Il2CppChar Convert_ToChar_m2796006345 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Char System.UInt32::System.IConvertible.ToChar(System.IFormatProvider)
extern "C" Il2CppChar UInt32_System_IConvertible_ToChar_m1873050533 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.SByte System.Convert::ToSByte(System.UInt32)
extern "C" int8_t Convert_ToSByte_m2486156346 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.SByte System.UInt32::System.IConvertible.ToSByte(System.IFormatProvider)
extern "C" int8_t UInt32_System_IConvertible_ToSByte_m1061556466 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Byte System.Convert::ToByte(System.UInt32)
extern "C" uint8_t Convert_ToByte_m1993550870 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Byte System.UInt32::System.IConvertible.ToByte(System.IFormatProvider)
extern "C" uint8_t UInt32_System_IConvertible_ToByte_m4072781199 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int16 System.Convert::ToInt16(System.UInt32)
extern "C" int16_t Convert_ToInt16_m571189957 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int16 System.UInt32::System.IConvertible.ToInt16(System.IFormatProvider)
extern "C" int16_t UInt32_System_IConvertible_ToInt16_m1659441601 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt16 System.Convert::ToUInt16(System.UInt32)
extern "C" uint16_t Convert_ToUInt16_m1480956416 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt16 System.UInt32::System.IConvertible.ToUInt16(System.IFormatProvider)
extern "C" uint16_t UInt32_System_IConvertible_ToUInt16_m3125657960 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Convert::ToInt32(System.UInt32)
extern "C" int32_t Convert_ToInt32_m3956995719 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UInt32::System.IConvertible.ToInt32(System.IFormatProvider)
extern "C" int32_t UInt32_System_IConvertible_ToInt32_m220754611 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt32 System.UInt32::System.IConvertible.ToUInt32(System.IFormatProvider)
extern "C" uint32_t UInt32_System_IConvertible_ToUInt32_m1744564280 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int64 System.Convert::ToInt64(System.UInt32)
extern "C" int64_t Convert_ToInt64_m3392013556 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int64 System.UInt32::System.IConvertible.ToInt64(System.IFormatProvider)
extern "C" int64_t UInt32_System_IConvertible_ToInt64_m2261037378 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt64 System.Convert::ToUInt64(System.UInt32)
extern "C" uint64_t Convert_ToUInt64_m1745056470 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt64 System.UInt32::System.IConvertible.ToUInt64(System.IFormatProvider)
extern "C" uint64_t UInt32_System_IConvertible_ToUInt64_m1094958903 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Single System.Convert::ToSingle(System.UInt32)
extern "C" float Convert_ToSingle_m3983149863 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Single System.UInt32::System.IConvertible.ToSingle(System.IFormatProvider)
extern "C" float UInt32_System_IConvertible_ToSingle_m1272823424 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Double System.Convert::ToDouble(System.UInt32)
extern "C" double Convert_ToDouble_m2222536920 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Double System.UInt32::System.IConvertible.ToDouble(System.IFormatProvider)
extern "C" double UInt32_System_IConvertible_ToDouble_m940039456 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Decimal System.Convert::ToDecimal(System.UInt32)
extern "C" Decimal_t2948259380 Convert_ToDecimal_m889385228 (RuntimeObject * __this /* static, unused */, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Decimal System.UInt32::System.IConvertible.ToDecimal(System.IFormatProvider)
extern "C" Decimal_t2948259380 UInt32_System_IConvertible_ToDecimal_m675004071 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.Environment::GetResourceString(System.String,System.Object[])
extern "C" String_t* Environment_GetResourceString_m479507158 (RuntimeObject * __this /* static, unused */, String_t* ___key0, ObjectU5BU5D_t2843939325* ___values1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.InvalidCastException::.ctor(System.String)
extern "C" void InvalidCastException__ctor_m318645277 (InvalidCastException_t3927145244 * __this, String_t* ___message0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.DateTime System.UInt32::System.IConvertible.ToDateTime(System.IFormatProvider)
extern "C" DateTime_t3738529785 UInt32_System_IConvertible_ToDateTime_m2767723441 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Object System.Convert::DefaultToType(System.IConvertible,System.Type,System.IFormatProvider)
extern "C" RuntimeObject * Convert_DefaultToType_m1860037989 (RuntimeObject * __this /* static, unused */, RuntimeObject* ___value0, Type_t * ___targetType1, RuntimeObject* ___provider2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Object System.UInt32::System.IConvertible.ToType(System.Type,System.IFormatProvider)
extern "C" RuntimeObject * UInt32_System_IConvertible_ToType_m922356584 (uint32_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UInt64::CompareTo(System.Object)
extern "C" int32_t UInt64_CompareTo_m3619843473 (uint64_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UInt64::CompareTo(System.UInt64)
extern "C" int32_t UInt64_CompareTo_m1614517204 (uint64_t* __this, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.UInt64::Equals(System.Object)
extern "C" bool UInt64_Equals_m1879425698 (uint64_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.UInt64::Equals(System.UInt64)
extern "C" bool UInt64_Equals_m367573732 (uint64_t* __this, uint64_t ___obj0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UInt64::GetHashCode()
extern "C" int32_t UInt64_GetHashCode_m4209760355 (uint64_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.Number::FormatUInt64(System.UInt64,System.String,System.Globalization.NumberFormatInfo)
extern "C" String_t* Number_FormatUInt64_m792080283 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, String_t* ___format1, NumberFormatInfo_t435877138 * ___info2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.UInt64::ToString()
extern "C" String_t* UInt64_ToString_m1529093114 (uint64_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.UInt64::ToString(System.IFormatProvider)
extern "C" String_t* UInt64_ToString_m2623377370 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.UInt64::ToString(System.String)
extern "C" String_t* UInt64_ToString_m2177233542 (uint64_t* __this, String_t* ___format0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.UInt64::ToString(System.String,System.IFormatProvider)
extern "C" String_t* UInt64_ToString_m1695188334 (uint64_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt64 System.Number::ParseUInt64(System.String,System.Globalization.NumberStyles,System.Globalization.NumberFormatInfo)
extern "C" uint64_t Number_ParseUInt64_m2694014565 (RuntimeObject * __this /* static, unused */, String_t* ___value0, int32_t ___options1, NumberFormatInfo_t435877138 * ___numfmt2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Number::TryParseUInt64(System.String,System.Globalization.NumberStyles,System.Globalization.NumberFormatInfo,System.UInt64&)
extern "C" bool Number_TryParseUInt64_m782753458 (RuntimeObject * __this /* static, unused */, String_t* ___s0, int32_t ___style1, NumberFormatInfo_t435877138 * ___info2, uint64_t* ___result3, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.TypeCode System.UInt64::GetTypeCode()
extern "C" int32_t UInt64_GetTypeCode_m844217172 (uint64_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Convert::ToBoolean(System.UInt64)
extern "C" bool Convert_ToBoolean_m3613483153 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.UInt64::System.IConvertible.ToBoolean(System.IFormatProvider)
extern "C" bool UInt64_System_IConvertible_ToBoolean_m3071416000 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Char System.Convert::ToChar(System.UInt64)
extern "C" Il2CppChar Convert_ToChar_m1604365259 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Char System.UInt64::System.IConvertible.ToChar(System.IFormatProvider)
extern "C" Il2CppChar UInt64_System_IConvertible_ToChar_m2074245892 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.SByte System.Convert::ToSByte(System.UInt64)
extern "C" int8_t Convert_ToSByte_m1679390684 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.SByte System.UInt64::System.IConvertible.ToSByte(System.IFormatProvider)
extern "C" int8_t UInt64_System_IConvertible_ToSByte_m30962591 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Byte System.Convert::ToByte(System.UInt64)
extern "C" uint8_t Convert_ToByte_m3567528984 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Byte System.UInt64::System.IConvertible.ToByte(System.IFormatProvider)
extern "C" uint8_t UInt64_System_IConvertible_ToByte_m1501504925 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int16 System.Convert::ToInt16(System.UInt64)
extern "C" int16_t Convert_ToInt16_m1733792763 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int16 System.UInt64::System.IConvertible.ToInt16(System.IFormatProvider)
extern "C" int16_t UInt64_System_IConvertible_ToInt16_m3895479143 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt16 System.Convert::ToUInt16(System.UInt64)
extern "C" uint16_t Convert_ToUInt16_m2672597498 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt16 System.UInt64::System.IConvertible.ToUInt16(System.IFormatProvider)
extern "C" uint16_t UInt64_System_IConvertible_ToUInt16_m4165747038 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Convert::ToInt32(System.UInt64)
extern "C" int32_t Convert_ToInt32_m825155517 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UInt64::System.IConvertible.ToInt32(System.IFormatProvider)
extern "C" int32_t UInt64_System_IConvertible_ToInt32_m949522652 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt32 System.Convert::ToUInt32(System.UInt64)
extern "C" uint32_t Convert_ToUInt32_m1767593911 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt32 System.UInt64::System.IConvertible.ToUInt32(System.IFormatProvider)
extern "C" uint32_t UInt64_System_IConvertible_ToUInt32_m2784653358 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int64 System.Convert::ToInt64(System.UInt64)
extern "C" int64_t Convert_ToInt64_m260173354 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int64 System.UInt64::System.IConvertible.ToInt64(System.IFormatProvider)
extern "C" int64_t UInt64_System_IConvertible_ToInt64_m4241475606 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.UInt64 System.UInt64::System.IConvertible.ToUInt64(System.IFormatProvider)
extern "C" uint64_t UInt64_System_IConvertible_ToUInt64_m2135047981 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Single System.Convert::ToSingle(System.UInt64)
extern "C" float Convert_ToSingle_m2791508777 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Single System.UInt64::System.IConvertible.ToSingle(System.IFormatProvider)
extern "C" float UInt64_System_IConvertible_ToSingle_m925613075 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Double System.Convert::ToDouble(System.UInt64)
extern "C" double Convert_ToDouble_m1030895834 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Double System.UInt64::System.IConvertible.ToDouble(System.IFormatProvider)
extern "C" double UInt64_System_IConvertible_ToDouble_m602078108 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Decimal System.Convert::ToDecimal(System.UInt64)
extern "C" Decimal_t2948259380 Convert_ToDecimal_m1695757674 (RuntimeObject * __this /* static, unused */, uint64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Decimal System.UInt64::System.IConvertible.ToDecimal(System.IFormatProvider)
extern "C" Decimal_t2948259380 UInt64_System_IConvertible_ToDecimal_m806594027 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.DateTime System.UInt64::System.IConvertible.ToDateTime(System.IFormatProvider)
extern "C" DateTime_t3738529785 UInt64_System_IConvertible_ToDateTime_m3434604642 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Object System.UInt64::System.IConvertible.ToType(System.Type,System.IFormatProvider)
extern "C" RuntimeObject * UInt64_System_IConvertible_ToType_m4049257834 (uint64_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.UIntPtr::.ctor(System.UInt32)
extern "C" void UIntPtr__ctor_m4250165422 (uintptr_t* __this, uint32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.UIntPtr::Equals(System.Object)
extern "C" bool UIntPtr_Equals_m1316671746 (uintptr_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UIntPtr::GetHashCode()
extern "C" int32_t UIntPtr_GetHashCode_m3482152298 (uintptr_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.UIntPtr::get_Size()
extern "C" int32_t UIntPtr_get_Size_m703595701 (RuntimeObject * __this /* static, unused */, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.UIntPtr::ToString()
extern "C" String_t* UIntPtr_ToString_m984583492 (uintptr_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.ArgumentNullException::.ctor(System.String)
extern "C" void ArgumentNullException__ctor_m1170824041 (ArgumentNullException_t1615371798 * __this, String_t* ___paramName0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.UInt64)
extern "C" void SerializationInfo_AddValue_m2020653395 (SerializationInfo_t950877179 * __this, String_t* ___name0, uint64_t ___value1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.UIntPtr::System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_m1767630151 (uintptr_t* __this, SerializationInfo_t950877179 * ___info0, StreamingContext_t3711869237 ___context1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.SystemException::.ctor(System.String)
extern "C" void SystemException__ctor_m3298527747 (SystemException_t176217640 * __this, String_t* ___message0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Exception::SetErrorCode(System.Int32)
extern "C" void Exception_SetErrorCode_m4269507377 (Exception_t * __this, int32_t ___hr0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.SystemException::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void SystemException__ctor_m1515048899 (SystemException_t176217640 * __this, SerializationInfo_t950877179 * ___info0, StreamingContext_t3711869237 ___context1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.EventArgs::.ctor()
extern "C" void EventArgs__ctor_m32674013 (EventArgs_t3591816995 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)
extern "C" Type_t * Type_GetTypeFromHandle_m1620074514 (RuntimeObject * __this /* static, unused */, RuntimeTypeHandle_t3027515415 ___handle0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.Serialization.SerializationInfo::SetType(System.Type)
extern "C" void SerializationInfo_SetType_m3923964808 (SerializationInfo_t950877179 * __this, Type_t * ___type0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.Int32)
extern "C" void SerializationInfo_AddValue_m412754688 (SerializationInfo_t950877179 * __this, String_t* ___name0, int32_t ___value1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Collections.Generic.List`1<System.Int32>::.ctor()
#define List_1__ctor_m1204004817(__this, method) (( void (*) (List_1_t128053199 *, const RuntimeMethod*))List_1__ctor_m1204004817_gshared)(__this, method)
// System.Void System.Collections.Generic.List`1<System.Int32>::Add(T)
#define List_1_Add_m2080863212(__this, p0, method) (( void (*) (List_1_t128053199 *, int32_t, const RuntimeMethod*))List_1_Add_m2080863212_gshared)(__this, p0, method)
// System.Boolean System.Type::get_IsArray()
extern "C" bool Type_get_IsArray_m2591212821 (Type_t * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Type::get_IsPointer()
extern "C" bool Type_get_IsPointer_m4067542339 (Type_t * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Type::get_IsByRef()
extern "C" bool Type_get_IsByRef_m1262524108 (Type_t * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Type::get_HasElementType()
extern "C" bool Type_get_HasElementType_m710151977 (Type_t * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// T[] System.Collections.Generic.List`1<System.Int32>::ToArray()
#define List_1_ToArray_m1469074435(__this, method) (( Int32U5BU5D_t385246372* (*) (List_1_t128053199 *, const RuntimeMethod*))List_1_ToArray_m1469074435_gshared)(__this, method)
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.Object,System.Type)
extern "C" void SerializationInfo_AddValue_m3906743584 (SerializationInfo_t950877179 * __this, String_t* ___name0, RuntimeObject * ___value1, Type_t * ___type2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Type System.Type::GetRootElementType()
extern "C" Type_t * Type_GetRootElementType_m2028550026 (Type_t * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.RuntimeType System.UnitySerializationHolder::AddElementTypes(System.Runtime.Serialization.SerializationInfo,System.RuntimeType)
extern "C" RuntimeType_t3636489352 * UnitySerializationHolder_AddElementTypes_m2711578409 (RuntimeObject * __this /* static, unused */, SerializationInfo_t950877179 * ___info0, RuntimeType_t3636489352 * ___type1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Reflection.RuntimeAssembly System.RuntimeType::GetRuntimeAssembly()
extern "C" RuntimeAssembly_t1451753063 * RuntimeType_GetRuntimeAssembly_m2955606119 (RuntimeType_t3636489352 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.UnitySerializationHolder::GetUnitySerializationInfo(System.Runtime.Serialization.SerializationInfo,System.Int32,System.String,System.Reflection.RuntimeAssembly)
extern "C" void UnitySerializationHolder_GetUnitySerializationInfo_m3966690610 (RuntimeObject * __this /* static, unused */, SerializationInfo_t950877179 * ___info0, int32_t ___unityType1, String_t* ___data2, RuntimeAssembly_t1451753063 * ___assembly3, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Reflection.Assembly::op_Equality(System.Reflection.Assembly,System.Reflection.Assembly)
extern "C" bool Assembly_op_Equality_m3828289814 (RuntimeObject * __this /* static, unused */, Assembly_t * ___left0, Assembly_t * ___right1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.Object)
extern "C" void SerializationInfo_AddValue_m2872281893 (SerializationInfo_t950877179 * __this, String_t* ___name0, RuntimeObject * ___value1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Object::.ctor()
extern "C" void Object__ctor_m297566312 (RuntimeObject * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Runtime.Serialization.SerializationInfo::GetInt32(System.String)
extern "C" int32_t SerializationInfo_GetInt32_m2640574809 (SerializationInfo_t950877179 * __this, String_t* ___name0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Object System.Runtime.Serialization.SerializationInfo::GetValue(System.String,System.Type)
extern "C" RuntimeObject * SerializationInfo_GetValue_m42271953 (SerializationInfo_t950877179 * __this, String_t* ___name0, Type_t * ___type1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.Runtime.Serialization.SerializationInfo::GetString(System.String)
extern "C" String_t* SerializationInfo_GetString_m3155282843 (SerializationInfo_t950877179 * __this, String_t* ___name0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.Serialization.SerializationException::.ctor(System.String)
extern "C" void SerializationException__ctor_m3862484944 (SerializationException_t3941511869 * __this, String_t* ___message0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.NotSupportedException::.ctor(System.String)
extern "C" void NotSupportedException__ctor_m2494070935 (NotSupportedException_t1314879016 * __this, String_t* ___message0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Type::op_Equality(System.Type,System.Type)
extern "C" bool Type_op_Equality_m2683486427 (RuntimeObject * __this /* static, unused */, Type_t * ___left0, Type_t * ___right1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Type System.UnitySerializationHolder::MakeElementTypes(System.Type)
extern "C" Type_t * UnitySerializationHolder_MakeElementTypes_m672301684 (UnitySerializationHolder_t431912834 * __this, Type_t * ___type0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Reflection.MethodBase::op_Equality(System.Reflection.MethodBase,System.Reflection.MethodBase)
extern "C" bool MethodBase_op_Equality_m2405991987 (RuntimeObject * __this /* static, unused */, MethodBase_t * ___left0, MethodBase_t * ___right1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.UnitySerializationHolder::ThrowInsufficientInformation(System.String)
extern "C" void UnitySerializationHolder_ThrowInsufficientInformation_m1747464776 (UnitySerializationHolder_t431912834 * __this, String_t* ___field0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Reflection.MethodBase::op_Inequality(System.Reflection.MethodBase,System.Reflection.MethodBase)
extern "C" bool MethodBase_op_Inequality_m736913402 (RuntimeObject * __this /* static, unused */, MethodBase_t * ___left0, MethodBase_t * ___right1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.String::get_Length()
extern "C" int32_t String_get_Length_m3847582255 (String_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Type System.Type::GetType(System.String,System.Boolean,System.Boolean)
extern "C" Type_t * Type_GetType_m3971160356 (RuntimeObject * __this /* static, unused */, String_t* ___typeName0, bool ___throwOnError1, bool ___ignoreCase2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Reflection.Assembly System.Reflection.Assembly::Load(System.String)
extern "C" Assembly_t * Assembly_Load_m3487507613 (RuntimeObject * __this /* static, unused */, String_t* ___assemblyString0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Reflection.Module::op_Equality(System.Reflection.Module,System.Reflection.Module)
extern "C" bool Module_op_Equality_m1102431980 (RuntimeObject * __this /* static, unused */, Module_t2987026101 * ___left0, Module_t2987026101 * ___right1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.UnSafeCharBuffer::.ctor(System.Char*,System.Int32)
extern "C" void UnSafeCharBuffer__ctor_m1145239641 (UnSafeCharBuffer_t2176740272 * __this, Il2CppChar* ___buffer0, int32_t ___bufferSize1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.String::IsNullOrEmpty(System.String)
extern "C" bool String_IsNullOrEmpty_m2969720369 (RuntimeObject * __this /* static, unused */, String_t* ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.IndexOutOfRangeException::.ctor()
extern "C" void IndexOutOfRangeException__ctor_m2441337274 (IndexOutOfRangeException_t1578797820 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Runtime.CompilerServices.RuntimeHelpers::get_OffsetToStringData()
extern "C" int32_t RuntimeHelpers_get_OffsetToStringData_m2192601476 (RuntimeObject * __this /* static, unused */, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Buffer::Memcpy(System.Byte*,System.Byte*,System.Int32)
extern "C" void Buffer_Memcpy_m2035854300 (RuntimeObject * __this /* static, unused */, uint8_t* ___dest0, uint8_t* ___src1, int32_t ___size2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.UnSafeCharBuffer::AppendString(System.String)
extern "C" void UnSafeCharBuffer_AppendString_m2223303597 (UnSafeCharBuffer_t2176740272 * __this, String_t* ___stringToAppend0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.ValueTuple::Equals(System.Object)
extern "C" bool ValueTuple_Equals_m3777586424 (ValueTuple_t3168505507 * __this, RuntimeObject * ___obj0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.ValueTuple::Equals(System.ValueTuple)
extern "C" bool ValueTuple_Equals_m3868013840 (ValueTuple_t3168505507 * __this, ValueTuple_t3168505507 ___other0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.ValueTuple::System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)
extern "C" bool ValueTuple_System_Collections_IStructuralEquatable_Equals_m1158377527 (ValueTuple_t3168505507 * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Type System.Object::GetType()
extern "C" Type_t * Object_GetType_m88164663 (RuntimeObject * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String SR::Format(System.String,System.Object)
extern "C" String_t* SR_Format_m1749913990 (RuntimeObject * __this /* static, unused */, String_t* ___resourceFormat0, RuntimeObject * ___p11, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.ArgumentException::.ctor(System.String,System.String)
extern "C" void ArgumentException__ctor_m1216717135 (ArgumentException_t132251570 * __this, String_t* ___message0, String_t* ___paramName1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.ValueTuple::System.IComparable.CompareTo(System.Object)
extern "C" int32_t ValueTuple_System_IComparable_CompareTo_m3152321575 (ValueTuple_t3168505507 * __this, RuntimeObject * ___other0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.ValueTuple::CompareTo(System.ValueTuple)
extern "C" int32_t ValueTuple_CompareTo_m2936302085 (ValueTuple_t3168505507 * __this, ValueTuple_t3168505507 ___other0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.ValueTuple::System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)
extern "C" int32_t ValueTuple_System_Collections_IStructuralComparable_CompareTo_m1147772089 (ValueTuple_t3168505507 * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.ValueTuple::GetHashCode()
extern "C" int32_t ValueTuple_GetHashCode_m2158739460 (ValueTuple_t3168505507 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.ValueTuple::System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)
extern "C" int32_t ValueTuple_System_Collections_IStructuralEquatable_GetHashCode_m3160204034 (ValueTuple_t3168505507 * __this, RuntimeObject* ___comparer0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.ValueTuple::ToString()
extern "C" String_t* ValueTuple_ToString_m2213345710 (ValueTuple_t3168505507 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Numerics.Hashing.HashHelpers::Combine(System.Int32,System.Int32)
extern "C" int32_t HashHelpers_Combine_m3459330122 (RuntimeObject * __this /* static, unused */, int32_t ___h10, int32_t ___h21, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.RuntimeType::op_Inequality(System.RuntimeType,System.RuntimeType)
extern "C" bool RuntimeType_op_Inequality_m287584116 (RuntimeObject * __this /* static, unused */, RuntimeType_t3636489352 * ___left0, RuntimeType_t3636489352 * ___right1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.ValueType::InternalEquals(System.Object,System.Object,System.Object[]&)
extern "C" bool ValueType_InternalEquals_m1384040357 (RuntimeObject * __this /* static, unused */, RuntimeObject * ___o10, RuntimeObject * ___o21, ObjectU5BU5D_t2843939325** ___fields2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.ValueType::DefaultEquals(System.Object,System.Object)
extern "C" bool ValueType_DefaultEquals_m2927252100 (RuntimeObject * __this /* static, unused */, RuntimeObject * ___o10, RuntimeObject * ___o21, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.ValueType::InternalGetHashCode(System.Object,System.Object[]&)
extern "C" int32_t ValueType_InternalGetHashCode_m58786863 (RuntimeObject * __this /* static, unused */, RuntimeObject * ___o0, ObjectU5BU5D_t2843939325** ___fields1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.InteropServices.Marshal::FreeBSTR(System.IntPtr)
extern "C" void Marshal_FreeBSTR_m2788901813 (RuntimeObject * __this /* static, unused */, intptr_t ___ptr0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.IntPtr::op_Inequality(System.IntPtr,System.IntPtr)
extern "C" bool IntPtr_op_Inequality_m3063970704 (RuntimeObject * __this /* static, unused */, intptr_t ___value10, intptr_t ___value21, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Runtime.InteropServices.Marshal::Release(System.IntPtr)
extern "C" int32_t Marshal_Release_m3880542832 (RuntimeObject * __this /* static, unused */, intptr_t ___pUnk0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Variant::Clear()
extern "C" void Variant_Clear_m3388694274 (Variant_t2753289927 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.ArgumentOutOfRangeException::.ctor(System.String,System.String)
extern "C" void ArgumentOutOfRangeException__ctor_m282481429 (ArgumentOutOfRangeException_t777629997 * __this, String_t* ___paramName0, String_t* ___message1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Version::.ctor()
extern "C" void Version__ctor_m872301635 (Version_t3456873960 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Version::op_Equality(System.Version,System.Version)
extern "C" bool Version_op_Equality_m3804852517 (RuntimeObject * __this /* static, unused */, Version_t3456873960 * ___v10, Version_t3456873960 * ___v21, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.Version::ToString(System.Int32)
extern "C" String_t* Version_ToString_m3654989516 (Version_t3456873960 * __this, int32_t ___fieldCount0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.Int32::ToString()
extern "C" String_t* Int32_ToString_m141394615 (int32_t* __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Text.StringBuilder System.Text.StringBuilderCache::Acquire(System.Int32)
extern "C" StringBuilder_t * StringBuilderCache_Acquire_m4169564332 (RuntimeObject * __this /* static, unused */, int32_t ___capacity0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Version::AppendPositiveNumber(System.Int32,System.Text.StringBuilder)
extern "C" void Version_AppendPositiveNumber_m308762805 (RuntimeObject * __this /* static, unused */, int32_t ___num0, StringBuilder_t * ___sb1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Text.StringBuilder System.Text.StringBuilder::Append(System.Char)
extern "C" StringBuilder_t * StringBuilder_Append_m2383614642 (StringBuilder_t * __this, Il2CppChar ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.Text.StringBuilderCache::GetStringAndRelease(System.Text.StringBuilder)
extern "C" String_t* StringBuilderCache_GetStringAndRelease_m1110745745 (RuntimeObject * __this /* static, unused */, StringBuilder_t * ___sb0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Text.StringBuilder::get_Length()
extern "C" int32_t StringBuilder_get_Length_m3238060835 (StringBuilder_t * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Text.StringBuilder System.Text.StringBuilder::Insert(System.Int32,System.Char)
extern "C" StringBuilder_t * StringBuilder_Insert_m1076119876 (StringBuilder_t * __this, int32_t ___index0, Il2CppChar ___value1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Version::Equals(System.Version)
extern "C" bool Version_Equals_m1564427710 (Version_t3456873960 * __this, Version_t3456873960 * ___obj0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Version::CompareTo(System.Version)
extern "C" int32_t Version_CompareTo_m3146217210 (Version_t3456873960 * __this, Version_t3456873960 * ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Version::op_LessThanOrEqual(System.Version,System.Version)
extern "C" bool Version_op_LessThanOrEqual_m666140174 (RuntimeObject * __this /* static, unused */, Version_t3456873960 * ___v10, Version_t3456873960 * ___v21, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Runtime.InteropServices.GCHandle System.Runtime.InteropServices.GCHandle::Alloc(System.Object,System.Runtime.InteropServices.GCHandleType)
extern "C" GCHandle_t3351438187 GCHandle_Alloc_m3823409740 (RuntimeObject * __this /* static, unused */, RuntimeObject * ___value0, int32_t ___type1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.WeakReference::.ctor(System.Object,System.Boolean)
extern "C" void WeakReference__ctor_m1054065938 (WeakReference_t1334886716 * __this, RuntimeObject * ___target0, bool ___trackResurrection1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.WeakReference::AllocateHandle(System.Object)
extern "C" void WeakReference_AllocateHandle_m1478975559 (WeakReference_t1334886716 * __this, RuntimeObject * ___target0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Runtime.Serialization.SerializationInfo::GetBoolean(System.String)
extern "C" bool SerializationInfo_GetBoolean_m1756153320 (SerializationInfo_t950877179 * __this, String_t* ___name0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.Runtime.InteropServices.GCHandle::get_IsAllocated()
extern "C" bool GCHandle_get_IsAllocated_m1058226959 (GCHandle_t3351438187 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Object System.Runtime.InteropServices.GCHandle::get_Target()
extern "C" RuntimeObject * GCHandle_get_Target_m1824973883 (GCHandle_t3351438187 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.InteropServices.GCHandle::Free()
extern "C" void GCHandle_Free_m1457699368 (GCHandle_t3351438187 * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Object::Finalize()
extern "C" void Object_Finalize_m3076187857 (RuntimeObject * __this, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.Serialization.SerializationInfo::AddValue(System.String,System.Boolean)
extern "C" void SerializationInfo_AddValue_m3427199315 (SerializationInfo_t950877179 * __this, String_t* ___name0, bool ___value1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr System.WindowsConsoleDriver::GetStdHandle(System.Handles)
extern "C" intptr_t WindowsConsoleDriver_GetStdHandle_m23119533 (RuntimeObject * __this /* static, unused */, int32_t ___handle0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.WindowsConsoleDriver::GetConsoleScreenBufferInfo(System.IntPtr,System.ConsoleScreenBufferInfo&)
extern "C" bool WindowsConsoleDriver_GetConsoleScreenBufferInfo_m3609341087 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, ConsoleScreenBufferInfo_t3095351730 * ___info1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.WindowsConsoleDriver::ReadConsoleInput(System.IntPtr,System.InputRecord&,System.Int32,System.Int32&)
extern "C" bool WindowsConsoleDriver_ReadConsoleInput_m1790694890 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, InputRecord_t2660212290 * ___record1, int32_t ___length2, int32_t* ___nread3, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.Runtime.InteropServices.Marshal::GetLastWin32Error()
extern "C" int32_t Marshal_GetLastWin32Error_m1272610344 (RuntimeObject * __this /* static, unused */, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.String::Concat(System.Object,System.Object)
extern "C" String_t* String_Concat_m904156431 (RuntimeObject * __this /* static, unused */, RuntimeObject * ___arg00, RuntimeObject * ___arg11, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.InvalidOperationException::.ctor(System.String)
extern "C" void InvalidOperationException__ctor_m237278729 (InvalidOperationException_t56020091 * __this, String_t* ___message0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.WindowsConsoleDriver::IsModifierKey(System.Int16)
extern "C" bool WindowsConsoleDriver_IsModifierKey_m1974886538 (RuntimeObject * __this /* static, unused */, int16_t ___virtualKeyCode0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.ConsoleKeyInfo::.ctor(System.Char,System.ConsoleKey,System.Boolean,System.Boolean,System.Boolean)
extern "C" void ConsoleKeyInfo__ctor_m535940175 (ConsoleKeyInfo_t1802691652 * __this, Il2CppChar ___keyChar0, int32_t ___key1, bool ___shift2, bool ___alt3, bool ___control4, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Boolean System.IntPtr::op_Equality(System.IntPtr,System.IntPtr)
extern "C" bool IntPtr_op_Equality_m408849716 (RuntimeObject * __this /* static, unused */, intptr_t ___value10, intptr_t ___value21, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFStringGetLength(System.IntPtr)
extern "C" intptr_t CFHelpers_CFStringGetLength_m1003035781 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Int32 System.IntPtr::op_Explicit(System.IntPtr)
extern "C" int32_t IntPtr_op_Explicit_m4220076518 (RuntimeObject * __this /* static, unused */, intptr_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFStringGetCharactersPtr(System.IntPtr)
extern "C" intptr_t CFHelpers_CFStringGetCharactersPtr_m1790634856 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void XamMac.CoreFoundation.CFHelpers/CFRange::.ctor(System.Int32,System.Int32)
extern "C" void CFRange__ctor_m1242434219 (CFRange_t1233619878 * __this, int32_t ___loc0, int32_t ___len1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr System.Runtime.InteropServices.Marshal::AllocCoTaskMem(System.Int32)
extern "C" intptr_t Marshal_AllocCoTaskMem_m1327939722 (RuntimeObject * __this /* static, unused */, int32_t ___cb0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFStringGetCharacters(System.IntPtr,XamMac.CoreFoundation.CFHelpers/CFRange,System.IntPtr)
extern "C" intptr_t CFHelpers_CFStringGetCharacters_m1195295518 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, CFRange_t1233619878 ___range1, intptr_t ___buffer2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void* System.IntPtr::op_Explicit(System.IntPtr)
extern "C" void* IntPtr_op_Explicit_m2520637223 (RuntimeObject * __this /* static, unused */, intptr_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.String System.String::CreateString(System.Char*,System.Int32,System.Int32)
extern "C" String_t* String_CreateString_m3400201881 (String_t* __this, Il2CppChar* ___value0, int32_t ___startIndex1, int32_t ___length2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.InteropServices.Marshal::FreeCoTaskMem(System.IntPtr)
extern "C" void Marshal_FreeCoTaskMem_m3753155979 (RuntimeObject * __this /* static, unused */, intptr_t ___ptr0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFDataGetLength(System.IntPtr)
extern "C" intptr_t CFHelpers_CFDataGetLength_m3730685275 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFDataGetBytePtr(System.IntPtr)
extern "C" intptr_t CFHelpers_CFDataGetBytePtr_m1648767664 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.InteropServices.Marshal::Copy(System.IntPtr,System.Byte[],System.Int32,System.Int32)
extern "C" void Marshal_Copy_m1222846562 (RuntimeObject * __this /* static, unused */, intptr_t ___source0, ByteU5BU5D_t4116647657* ___destination1, int32_t ___startIndex2, int32_t ___length3, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr System.IntPtr::op_Explicit(System.Void*)
extern "C" intptr_t IntPtr_op_Explicit_m536245531 (RuntimeObject * __this /* static, unused */, void* ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void System.IntPtr::.ctor(System.Int32)
extern "C" void IntPtr__ctor_m987082960 (intptr_t* __this, int32_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFDataCreate(System.IntPtr,System.IntPtr,System.IntPtr)
extern "C" intptr_t CFHelpers_CFDataCreate_m3875740957 (RuntimeObject * __this /* static, unused */, intptr_t ___allocator0, intptr_t ___bytes1, intptr_t ___length2, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr XamMac.CoreFoundation.CFHelpers::SecCertificateCreateWithData(System.IntPtr,System.IntPtr)
extern "C" intptr_t CFHelpers_SecCertificateCreateWithData_m1682200427 (RuntimeObject * __this /* static, unused */, intptr_t ___allocator0, intptr_t ___cfData1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void XamMac.CoreFoundation.CFHelpers::CFRelease(System.IntPtr)
extern "C" void CFHelpers_CFRelease_m3206817372 (RuntimeObject * __this /* static, unused */, intptr_t ___obj0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.Void XamMac.CoreFoundation.CFHelpers/CFRange::.ctor(System.Int64,System.Int64)
extern "C" void CFRange__ctor_m3401693388 (CFRange_t1233619878 * __this, int64_t ___l0, int64_t ___len1, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
// System.IntPtr System.IntPtr::op_Explicit(System.Int64)
extern "C" intptr_t IntPtr_op_Explicit_m1593085246 (RuntimeObject * __this /* static, unused */, int64_t ___value0, const RuntimeMethod* method) IL2CPP_METHOD_ATTR;
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int32 System.UInt32::CompareTo(System.Object)
extern "C" int32_t UInt32_CompareTo_m362578384 (uint32_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_CompareTo_m362578384_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint32_t V_0 = 0;
{
RuntimeObject * L_0 = ___value0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___value0;
if (!((RuntimeObject *)IsInstSealed((RuntimeObject*)L_1, UInt32_t2560061978_il2cpp_TypeInfo_var)))
{
goto IL_0024;
}
}
{
RuntimeObject * L_2 = ___value0;
V_0 = ((*(uint32_t*)((uint32_t*)UnBox(L_2, UInt32_t2560061978_il2cpp_TypeInfo_var))));
uint32_t L_3 = V_0;
if ((!(((uint32_t)(*((uint32_t*)__this))) < ((uint32_t)L_3))))
{
goto IL_001b;
}
}
{
return (-1);
}
IL_001b:
{
uint32_t L_4 = V_0;
if ((!(((uint32_t)(*((uint32_t*)__this))) > ((uint32_t)L_4))))
{
goto IL_0022;
}
}
{
return 1;
}
IL_0022:
{
return 0;
}
IL_0024:
{
String_t* L_5 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral1622425596, /*hidden argument*/NULL);
ArgumentException_t132251570 * L_6 = (ArgumentException_t132251570 *)il2cpp_codegen_object_new(ArgumentException_t132251570_il2cpp_TypeInfo_var);
ArgumentException__ctor_m1312628991(L_6, L_5, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6, NULL, UInt32_CompareTo_m362578384_RuntimeMethod_var);
}
}
extern "C" int32_t UInt32_CompareTo_m362578384_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_CompareTo_m362578384(_thisAdjusted, ___value0, method);
}
// System.Int32 System.UInt32::CompareTo(System.UInt32)
extern "C" int32_t UInt32_CompareTo_m2218823230 (uint32_t* __this, uint32_t ___value0, const RuntimeMethod* method)
{
{
uint32_t L_0 = ___value0;
if ((!(((uint32_t)(*((uint32_t*)__this))) < ((uint32_t)L_0))))
{
goto IL_0007;
}
}
{
return (-1);
}
IL_0007:
{
uint32_t L_1 = ___value0;
if ((!(((uint32_t)(*((uint32_t*)__this))) > ((uint32_t)L_1))))
{
goto IL_000e;
}
}
{
return 1;
}
IL_000e:
{
return 0;
}
}
extern "C" int32_t UInt32_CompareTo_m2218823230_AdjustorThunk (RuntimeObject * __this, uint32_t ___value0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_CompareTo_m2218823230(_thisAdjusted, ___value0, method);
}
// System.Boolean System.UInt32::Equals(System.Object)
extern "C" bool UInt32_Equals_m351935437 (uint32_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_Equals_m351935437_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___obj0;
if (((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, UInt32_t2560061978_il2cpp_TypeInfo_var)))
{
goto IL_000a;
}
}
{
return (bool)0;
}
IL_000a:
{
RuntimeObject * L_1 = ___obj0;
return (bool)((((int32_t)(*((uint32_t*)__this))) == ((int32_t)((*(uint32_t*)((uint32_t*)UnBox(L_1, UInt32_t2560061978_il2cpp_TypeInfo_var))))))? 1 : 0);
}
}
extern "C" bool UInt32_Equals_m351935437_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_Equals_m351935437(_thisAdjusted, ___obj0, method);
}
// System.Boolean System.UInt32::Equals(System.UInt32)
extern "C" bool UInt32_Equals_m4250336581 (uint32_t* __this, uint32_t ___obj0, const RuntimeMethod* method)
{
{
uint32_t L_0 = ___obj0;
return (bool)((((int32_t)(*((uint32_t*)__this))) == ((int32_t)L_0))? 1 : 0);
}
}
extern "C" bool UInt32_Equals_m4250336581_AdjustorThunk (RuntimeObject * __this, uint32_t ___obj0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_Equals_m4250336581(_thisAdjusted, ___obj0, method);
}
// System.Int32 System.UInt32::GetHashCode()
extern "C" int32_t UInt32_GetHashCode_m3722548385 (uint32_t* __this, const RuntimeMethod* method)
{
{
return (*((uint32_t*)__this));
}
}
extern "C" int32_t UInt32_GetHashCode_m3722548385_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_GetHashCode_m3722548385(_thisAdjusted, method);
}
// System.String System.UInt32::ToString()
extern "C" String_t* UInt32_ToString_m2574561716 (uint32_t* __this, const RuntimeMethod* method)
{
{
NumberFormatInfo_t435877138 * L_0 = NumberFormatInfo_get_CurrentInfo_m2605582008(NULL /*static, unused*/, /*hidden argument*/NULL);
String_t* L_1 = Number_FormatUInt32_m2486347252(NULL /*static, unused*/, (*((uint32_t*)__this)), (String_t*)NULL, L_0, /*hidden argument*/NULL);
return L_1;
}
}
extern "C" String_t* UInt32_ToString_m2574561716_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_ToString_m2574561716(_thisAdjusted, method);
}
// System.String System.UInt32::ToString(System.IFormatProvider)
extern "C" String_t* UInt32_ToString_m4293943134 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
RuntimeObject* L_0 = ___provider0;
NumberFormatInfo_t435877138 * L_1 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
String_t* L_2 = Number_FormatUInt32_m2486347252(NULL /*static, unused*/, (*((uint32_t*)__this)), (String_t*)NULL, L_1, /*hidden argument*/NULL);
return L_2;
}
}
extern "C" String_t* UInt32_ToString_m4293943134_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_ToString_m4293943134(_thisAdjusted, ___provider0, method);
}
// System.String System.UInt32::ToString(System.String,System.IFormatProvider)
extern "C" String_t* UInt32_ToString_m2420423038 (uint32_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
String_t* L_0 = ___format0;
RuntimeObject* L_1 = ___provider1;
NumberFormatInfo_t435877138 * L_2 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
String_t* L_3 = Number_FormatUInt32_m2486347252(NULL /*static, unused*/, (*((uint32_t*)__this)), L_0, L_2, /*hidden argument*/NULL);
return L_3;
}
}
extern "C" String_t* UInt32_ToString_m2420423038_AdjustorThunk (RuntimeObject * __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_ToString_m2420423038(_thisAdjusted, ___format0, ___provider1, method);
}
// System.UInt32 System.UInt32::Parse(System.String)
extern "C" uint32_t UInt32_Parse_m3270868885 (RuntimeObject * __this /* static, unused */, String_t* ___s0, const RuntimeMethod* method)
{
{
String_t* L_0 = ___s0;
NumberFormatInfo_t435877138 * L_1 = NumberFormatInfo_get_CurrentInfo_m2605582008(NULL /*static, unused*/, /*hidden argument*/NULL);
uint32_t L_2 = Number_ParseUInt32_m4237573864(NULL /*static, unused*/, L_0, 7, L_1, /*hidden argument*/NULL);
return L_2;
}
}
// System.UInt32 System.UInt32::Parse(System.String,System.IFormatProvider)
extern "C" uint32_t UInt32_Parse_m1373460382 (RuntimeObject * __this /* static, unused */, String_t* ___s0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
String_t* L_0 = ___s0;
RuntimeObject* L_1 = ___provider1;
NumberFormatInfo_t435877138 * L_2 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
uint32_t L_3 = Number_ParseUInt32_m4237573864(NULL /*static, unused*/, L_0, 7, L_2, /*hidden argument*/NULL);
return L_3;
}
}
// System.UInt32 System.UInt32::Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)
extern "C" uint32_t UInt32_Parse_m3755665066 (RuntimeObject * __this /* static, unused */, String_t* ___s0, int32_t ___style1, RuntimeObject* ___provider2, const RuntimeMethod* method)
{
{
int32_t L_0 = ___style1;
NumberFormatInfo_ValidateParseStyleInteger_m957858295(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
String_t* L_1 = ___s0;
int32_t L_2 = ___style1;
RuntimeObject* L_3 = ___provider2;
NumberFormatInfo_t435877138 * L_4 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
uint32_t L_5 = Number_ParseUInt32_m4237573864(NULL /*static, unused*/, L_1, L_2, L_4, /*hidden argument*/NULL);
return L_5;
}
}
// System.Boolean System.UInt32::TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt32&)
extern "C" bool UInt32_TryParse_m535404612 (RuntimeObject * __this /* static, unused */, String_t* ___s0, int32_t ___style1, RuntimeObject* ___provider2, uint32_t* ___result3, const RuntimeMethod* method)
{
{
int32_t L_0 = ___style1;
NumberFormatInfo_ValidateParseStyleInteger_m957858295(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
String_t* L_1 = ___s0;
int32_t L_2 = ___style1;
RuntimeObject* L_3 = ___provider2;
NumberFormatInfo_t435877138 * L_4 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
uint32_t* L_5 = ___result3;
bool L_6 = Number_TryParseUInt32_m2802499845(NULL /*static, unused*/, L_1, L_2, L_4, (uint32_t*)L_5, /*hidden argument*/NULL);
return L_6;
}
}
// System.TypeCode System.UInt32::GetTypeCode()
extern "C" int32_t UInt32_GetTypeCode_m88917904 (uint32_t* __this, const RuntimeMethod* method)
{
{
return (int32_t)(((int32_t)10));
}
}
extern "C" int32_t UInt32_GetTypeCode_m88917904_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_GetTypeCode_m88917904(_thisAdjusted, method);
}
// System.Boolean System.UInt32::System.IConvertible.ToBoolean(System.IFormatProvider)
extern "C" bool UInt32_System_IConvertible_ToBoolean_m1763673183 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToBoolean_m1763673183_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
bool L_0 = Convert_ToBoolean_m2807110707(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" bool UInt32_System_IConvertible_ToBoolean_m1763673183_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToBoolean_m1763673183(_thisAdjusted, ___provider0, method);
}
// System.Char System.UInt32::System.IConvertible.ToChar(System.IFormatProvider)
extern "C" Il2CppChar UInt32_System_IConvertible_ToChar_m1873050533 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToChar_m1873050533_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
Il2CppChar L_0 = Convert_ToChar_m2796006345(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" Il2CppChar UInt32_System_IConvertible_ToChar_m1873050533_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToChar_m1873050533(_thisAdjusted, ___provider0, method);
}
// System.SByte System.UInt32::System.IConvertible.ToSByte(System.IFormatProvider)
extern "C" int8_t UInt32_System_IConvertible_ToSByte_m1061556466 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToSByte_m1061556466_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
int8_t L_0 = Convert_ToSByte_m2486156346(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" int8_t UInt32_System_IConvertible_ToSByte_m1061556466_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToSByte_m1061556466(_thisAdjusted, ___provider0, method);
}
// System.Byte System.UInt32::System.IConvertible.ToByte(System.IFormatProvider)
extern "C" uint8_t UInt32_System_IConvertible_ToByte_m4072781199 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToByte_m4072781199_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
uint8_t L_0 = Convert_ToByte_m1993550870(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" uint8_t UInt32_System_IConvertible_ToByte_m4072781199_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToByte_m4072781199(_thisAdjusted, ___provider0, method);
}
// System.Int16 System.UInt32::System.IConvertible.ToInt16(System.IFormatProvider)
extern "C" int16_t UInt32_System_IConvertible_ToInt16_m1659441601 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToInt16_m1659441601_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
int16_t L_0 = Convert_ToInt16_m571189957(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" int16_t UInt32_System_IConvertible_ToInt16_m1659441601_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToInt16_m1659441601(_thisAdjusted, ___provider0, method);
}
// System.UInt16 System.UInt32::System.IConvertible.ToUInt16(System.IFormatProvider)
extern "C" uint16_t UInt32_System_IConvertible_ToUInt16_m3125657960 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToUInt16_m3125657960_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
uint16_t L_0 = Convert_ToUInt16_m1480956416(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" uint16_t UInt32_System_IConvertible_ToUInt16_m3125657960_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToUInt16_m3125657960(_thisAdjusted, ___provider0, method);
}
// System.Int32 System.UInt32::System.IConvertible.ToInt32(System.IFormatProvider)
extern "C" int32_t UInt32_System_IConvertible_ToInt32_m220754611 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToInt32_m220754611_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
int32_t L_0 = Convert_ToInt32_m3956995719(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" int32_t UInt32_System_IConvertible_ToInt32_m220754611_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToInt32_m220754611(_thisAdjusted, ___provider0, method);
}
// System.UInt32 System.UInt32::System.IConvertible.ToUInt32(System.IFormatProvider)
extern "C" uint32_t UInt32_System_IConvertible_ToUInt32_m1744564280 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
return (*((uint32_t*)__this));
}
}
extern "C" uint32_t UInt32_System_IConvertible_ToUInt32_m1744564280_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToUInt32_m1744564280(_thisAdjusted, ___provider0, method);
}
// System.Int64 System.UInt32::System.IConvertible.ToInt64(System.IFormatProvider)
extern "C" int64_t UInt32_System_IConvertible_ToInt64_m2261037378 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToInt64_m2261037378_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
int64_t L_0 = Convert_ToInt64_m3392013556(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" int64_t UInt32_System_IConvertible_ToInt64_m2261037378_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToInt64_m2261037378(_thisAdjusted, ___provider0, method);
}
// System.UInt64 System.UInt32::System.IConvertible.ToUInt64(System.IFormatProvider)
extern "C" uint64_t UInt32_System_IConvertible_ToUInt64_m1094958903 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToUInt64_m1094958903_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
uint64_t L_0 = Convert_ToUInt64_m1745056470(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" uint64_t UInt32_System_IConvertible_ToUInt64_m1094958903_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToUInt64_m1094958903(_thisAdjusted, ___provider0, method);
}
// System.Single System.UInt32::System.IConvertible.ToSingle(System.IFormatProvider)
extern "C" float UInt32_System_IConvertible_ToSingle_m1272823424 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToSingle_m1272823424_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
float L_0 = Convert_ToSingle_m3983149863(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" float UInt32_System_IConvertible_ToSingle_m1272823424_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToSingle_m1272823424(_thisAdjusted, ___provider0, method);
}
// System.Double System.UInt32::System.IConvertible.ToDouble(System.IFormatProvider)
extern "C" double UInt32_System_IConvertible_ToDouble_m940039456 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToDouble_m940039456_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
double L_0 = Convert_ToDouble_m2222536920(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" double UInt32_System_IConvertible_ToDouble_m940039456_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToDouble_m940039456(_thisAdjusted, ___provider0, method);
}
// System.Decimal System.UInt32::System.IConvertible.ToDecimal(System.IFormatProvider)
extern "C" Decimal_t2948259380 UInt32_System_IConvertible_ToDecimal_m675004071 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToDecimal_m675004071_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
Decimal_t2948259380 L_0 = Convert_ToDecimal_m889385228(NULL /*static, unused*/, (*((uint32_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" Decimal_t2948259380 UInt32_System_IConvertible_ToDecimal_m675004071_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToDecimal_m675004071(_thisAdjusted, ___provider0, method);
}
// System.DateTime System.UInt32::System.IConvertible.ToDateTime(System.IFormatProvider)
extern "C" DateTime_t3738529785 UInt32_System_IConvertible_ToDateTime_m2767723441 (uint32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToDateTime_m2767723441_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ObjectU5BU5D_t2843939325* L_0 = (ObjectU5BU5D_t2843939325*)SZArrayNew(ObjectU5BU5D_t2843939325_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t2843939325* L_1 = L_0;
NullCheck(L_1);
ArrayElementTypeCheck (L_1, _stringLiteral2789887848);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteral2789887848);
ObjectU5BU5D_t2843939325* L_2 = L_1;
NullCheck(L_2);
ArrayElementTypeCheck (L_2, _stringLiteral3798051137);
(L_2)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteral3798051137);
String_t* L_3 = Environment_GetResourceString_m479507158(NULL /*static, unused*/, _stringLiteral4287968739, L_2, /*hidden argument*/NULL);
InvalidCastException_t3927145244 * L_4 = (InvalidCastException_t3927145244 *)il2cpp_codegen_object_new(InvalidCastException_t3927145244_il2cpp_TypeInfo_var);
InvalidCastException__ctor_m318645277(L_4, L_3, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_4, NULL, UInt32_System_IConvertible_ToDateTime_m2767723441_RuntimeMethod_var);
}
}
extern "C" DateTime_t3738529785 UInt32_System_IConvertible_ToDateTime_m2767723441_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToDateTime_m2767723441(_thisAdjusted, ___provider0, method);
}
// System.Object System.UInt32::System.IConvertible.ToType(System.Type,System.IFormatProvider)
extern "C" RuntimeObject * UInt32_System_IConvertible_ToType_m922356584 (uint32_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt32_System_IConvertible_ToType_m922356584_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
uint32_t L_0 = ((uint32_t)(*((uint32_t*)__this)));
RuntimeObject * L_1 = Box(UInt32_t2560061978_il2cpp_TypeInfo_var, &L_0);
Type_t * L_2 = ___type0;
RuntimeObject* L_3 = ___provider1;
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
RuntimeObject * L_4 = Convert_DefaultToType_m1860037989(NULL /*static, unused*/, (RuntimeObject*)L_1, L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
extern "C" RuntimeObject * UInt32_System_IConvertible_ToType_m922356584_AdjustorThunk (RuntimeObject * __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint32_t* _thisAdjusted = reinterpret_cast<uint32_t*>(__this + 1);
return UInt32_System_IConvertible_ToType_m922356584(_thisAdjusted, ___type0, ___provider1, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Int32 System.UInt64::CompareTo(System.Object)
extern "C" int32_t UInt64_CompareTo_m3619843473 (uint64_t* __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_CompareTo_m3619843473_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint64_t V_0 = 0;
{
RuntimeObject * L_0 = ___value0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___value0;
if (!((RuntimeObject *)IsInstSealed((RuntimeObject*)L_1, UInt64_t4134040092_il2cpp_TypeInfo_var)))
{
goto IL_0024;
}
}
{
RuntimeObject * L_2 = ___value0;
V_0 = ((*(uint64_t*)((uint64_t*)UnBox(L_2, UInt64_t4134040092_il2cpp_TypeInfo_var))));
uint64_t L_3 = V_0;
if ((!(((uint64_t)(*((int64_t*)__this))) < ((uint64_t)L_3))))
{
goto IL_001b;
}
}
{
return (-1);
}
IL_001b:
{
uint64_t L_4 = V_0;
if ((!(((uint64_t)(*((int64_t*)__this))) > ((uint64_t)L_4))))
{
goto IL_0022;
}
}
{
return 1;
}
IL_0022:
{
return 0;
}
IL_0024:
{
String_t* L_5 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral2814066682, /*hidden argument*/NULL);
ArgumentException_t132251570 * L_6 = (ArgumentException_t132251570 *)il2cpp_codegen_object_new(ArgumentException_t132251570_il2cpp_TypeInfo_var);
ArgumentException__ctor_m1312628991(L_6, L_5, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6, NULL, UInt64_CompareTo_m3619843473_RuntimeMethod_var);
}
}
extern "C" int32_t UInt64_CompareTo_m3619843473_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_CompareTo_m3619843473(_thisAdjusted, ___value0, method);
}
// System.Int32 System.UInt64::CompareTo(System.UInt64)
extern "C" int32_t UInt64_CompareTo_m1614517204 (uint64_t* __this, uint64_t ___value0, const RuntimeMethod* method)
{
{
uint64_t L_0 = ___value0;
if ((!(((uint64_t)(*((int64_t*)__this))) < ((uint64_t)L_0))))
{
goto IL_0007;
}
}
{
return (-1);
}
IL_0007:
{
uint64_t L_1 = ___value0;
if ((!(((uint64_t)(*((int64_t*)__this))) > ((uint64_t)L_1))))
{
goto IL_000e;
}
}
{
return 1;
}
IL_000e:
{
return 0;
}
}
extern "C" int32_t UInt64_CompareTo_m1614517204_AdjustorThunk (RuntimeObject * __this, uint64_t ___value0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_CompareTo_m1614517204(_thisAdjusted, ___value0, method);
}
// System.Boolean System.UInt64::Equals(System.Object)
extern "C" bool UInt64_Equals_m1879425698 (uint64_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_Equals_m1879425698_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___obj0;
if (((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, UInt64_t4134040092_il2cpp_TypeInfo_var)))
{
goto IL_000a;
}
}
{
return (bool)0;
}
IL_000a:
{
RuntimeObject * L_1 = ___obj0;
return (bool)((((int64_t)(*((int64_t*)__this))) == ((int64_t)((*(uint64_t*)((uint64_t*)UnBox(L_1, UInt64_t4134040092_il2cpp_TypeInfo_var))))))? 1 : 0);
}
}
extern "C" bool UInt64_Equals_m1879425698_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_Equals_m1879425698(_thisAdjusted, ___obj0, method);
}
// System.Boolean System.UInt64::Equals(System.UInt64)
extern "C" bool UInt64_Equals_m367573732 (uint64_t* __this, uint64_t ___obj0, const RuntimeMethod* method)
{
{
uint64_t L_0 = ___obj0;
return (bool)((((int64_t)(*((int64_t*)__this))) == ((int64_t)L_0))? 1 : 0);
}
}
extern "C" bool UInt64_Equals_m367573732_AdjustorThunk (RuntimeObject * __this, uint64_t ___obj0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_Equals_m367573732(_thisAdjusted, ___obj0, method);
}
// System.Int32 System.UInt64::GetHashCode()
extern "C" int32_t UInt64_GetHashCode_m4209760355 (uint64_t* __this, const RuntimeMethod* method)
{
{
return ((int32_t)((int32_t)(((int32_t)((int32_t)(*((int64_t*)__this)))))^(int32_t)(((int32_t)((int32_t)((int64_t)((uint64_t)(*((int64_t*)__this))>>((int32_t)32))))))));
}
}
extern "C" int32_t UInt64_GetHashCode_m4209760355_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_GetHashCode_m4209760355(_thisAdjusted, method);
}
// System.String System.UInt64::ToString()
extern "C" String_t* UInt64_ToString_m1529093114 (uint64_t* __this, const RuntimeMethod* method)
{
{
NumberFormatInfo_t435877138 * L_0 = NumberFormatInfo_get_CurrentInfo_m2605582008(NULL /*static, unused*/, /*hidden argument*/NULL);
String_t* L_1 = Number_FormatUInt64_m792080283(NULL /*static, unused*/, (*((int64_t*)__this)), (String_t*)NULL, L_0, /*hidden argument*/NULL);
return L_1;
}
}
extern "C" String_t* UInt64_ToString_m1529093114_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_ToString_m1529093114(_thisAdjusted, method);
}
// System.String System.UInt64::ToString(System.IFormatProvider)
extern "C" String_t* UInt64_ToString_m2623377370 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
RuntimeObject* L_0 = ___provider0;
NumberFormatInfo_t435877138 * L_1 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
String_t* L_2 = Number_FormatUInt64_m792080283(NULL /*static, unused*/, (*((int64_t*)__this)), (String_t*)NULL, L_1, /*hidden argument*/NULL);
return L_2;
}
}
extern "C" String_t* UInt64_ToString_m2623377370_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_ToString_m2623377370(_thisAdjusted, ___provider0, method);
}
// System.String System.UInt64::ToString(System.String)
extern "C" String_t* UInt64_ToString_m2177233542 (uint64_t* __this, String_t* ___format0, const RuntimeMethod* method)
{
{
String_t* L_0 = ___format0;
NumberFormatInfo_t435877138 * L_1 = NumberFormatInfo_get_CurrentInfo_m2605582008(NULL /*static, unused*/, /*hidden argument*/NULL);
String_t* L_2 = Number_FormatUInt64_m792080283(NULL /*static, unused*/, (*((int64_t*)__this)), L_0, L_1, /*hidden argument*/NULL);
return L_2;
}
}
extern "C" String_t* UInt64_ToString_m2177233542_AdjustorThunk (RuntimeObject * __this, String_t* ___format0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_ToString_m2177233542(_thisAdjusted, ___format0, method);
}
// System.String System.UInt64::ToString(System.String,System.IFormatProvider)
extern "C" String_t* UInt64_ToString_m1695188334 (uint64_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
String_t* L_0 = ___format0;
RuntimeObject* L_1 = ___provider1;
NumberFormatInfo_t435877138 * L_2 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
String_t* L_3 = Number_FormatUInt64_m792080283(NULL /*static, unused*/, (*((int64_t*)__this)), L_0, L_2, /*hidden argument*/NULL);
return L_3;
}
}
extern "C" String_t* UInt64_ToString_m1695188334_AdjustorThunk (RuntimeObject * __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_ToString_m1695188334(_thisAdjusted, ___format0, ___provider1, method);
}
// System.UInt64 System.UInt64::Parse(System.String,System.IFormatProvider)
extern "C" uint64_t UInt64_Parse_m819899889 (RuntimeObject * __this /* static, unused */, String_t* ___s0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
{
String_t* L_0 = ___s0;
RuntimeObject* L_1 = ___provider1;
NumberFormatInfo_t435877138 * L_2 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
uint64_t L_3 = Number_ParseUInt64_m2694014565(NULL /*static, unused*/, L_0, 7, L_2, /*hidden argument*/NULL);
return L_3;
}
}
// System.UInt64 System.UInt64::Parse(System.String,System.Globalization.NumberStyles,System.IFormatProvider)
extern "C" uint64_t UInt64_Parse_m1485858293 (RuntimeObject * __this /* static, unused */, String_t* ___s0, int32_t ___style1, RuntimeObject* ___provider2, const RuntimeMethod* method)
{
{
int32_t L_0 = ___style1;
NumberFormatInfo_ValidateParseStyleInteger_m957858295(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
String_t* L_1 = ___s0;
int32_t L_2 = ___style1;
RuntimeObject* L_3 = ___provider2;
NumberFormatInfo_t435877138 * L_4 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
uint64_t L_5 = Number_ParseUInt64_m2694014565(NULL /*static, unused*/, L_1, L_2, L_4, /*hidden argument*/NULL);
return L_5;
}
}
// System.Boolean System.UInt64::TryParse(System.String,System.Globalization.NumberStyles,System.IFormatProvider,System.UInt64&)
extern "C" bool UInt64_TryParse_m3060369906 (RuntimeObject * __this /* static, unused */, String_t* ___s0, int32_t ___style1, RuntimeObject* ___provider2, uint64_t* ___result3, const RuntimeMethod* method)
{
{
int32_t L_0 = ___style1;
NumberFormatInfo_ValidateParseStyleInteger_m957858295(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
String_t* L_1 = ___s0;
int32_t L_2 = ___style1;
RuntimeObject* L_3 = ___provider2;
NumberFormatInfo_t435877138 * L_4 = NumberFormatInfo_GetInstance_m2833078205(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
uint64_t* L_5 = ___result3;
bool L_6 = Number_TryParseUInt64_m782753458(NULL /*static, unused*/, L_1, L_2, L_4, (uint64_t*)L_5, /*hidden argument*/NULL);
return L_6;
}
}
// System.TypeCode System.UInt64::GetTypeCode()
extern "C" int32_t UInt64_GetTypeCode_m844217172 (uint64_t* __this, const RuntimeMethod* method)
{
{
return (int32_t)(((int32_t)12));
}
}
extern "C" int32_t UInt64_GetTypeCode_m844217172_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_GetTypeCode_m844217172(_thisAdjusted, method);
}
// System.Boolean System.UInt64::System.IConvertible.ToBoolean(System.IFormatProvider)
extern "C" bool UInt64_System_IConvertible_ToBoolean_m3071416000 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToBoolean_m3071416000_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
bool L_0 = Convert_ToBoolean_m3613483153(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" bool UInt64_System_IConvertible_ToBoolean_m3071416000_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToBoolean_m3071416000(_thisAdjusted, ___provider0, method);
}
// System.Char System.UInt64::System.IConvertible.ToChar(System.IFormatProvider)
extern "C" Il2CppChar UInt64_System_IConvertible_ToChar_m2074245892 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToChar_m2074245892_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
Il2CppChar L_0 = Convert_ToChar_m1604365259(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" Il2CppChar UInt64_System_IConvertible_ToChar_m2074245892_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToChar_m2074245892(_thisAdjusted, ___provider0, method);
}
// System.SByte System.UInt64::System.IConvertible.ToSByte(System.IFormatProvider)
extern "C" int8_t UInt64_System_IConvertible_ToSByte_m30962591 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToSByte_m30962591_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
int8_t L_0 = Convert_ToSByte_m1679390684(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" int8_t UInt64_System_IConvertible_ToSByte_m30962591_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToSByte_m30962591(_thisAdjusted, ___provider0, method);
}
// System.Byte System.UInt64::System.IConvertible.ToByte(System.IFormatProvider)
extern "C" uint8_t UInt64_System_IConvertible_ToByte_m1501504925 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToByte_m1501504925_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
uint8_t L_0 = Convert_ToByte_m3567528984(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" uint8_t UInt64_System_IConvertible_ToByte_m1501504925_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToByte_m1501504925(_thisAdjusted, ___provider0, method);
}
// System.Int16 System.UInt64::System.IConvertible.ToInt16(System.IFormatProvider)
extern "C" int16_t UInt64_System_IConvertible_ToInt16_m3895479143 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToInt16_m3895479143_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
int16_t L_0 = Convert_ToInt16_m1733792763(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" int16_t UInt64_System_IConvertible_ToInt16_m3895479143_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToInt16_m3895479143(_thisAdjusted, ___provider0, method);
}
// System.UInt16 System.UInt64::System.IConvertible.ToUInt16(System.IFormatProvider)
extern "C" uint16_t UInt64_System_IConvertible_ToUInt16_m4165747038 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToUInt16_m4165747038_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
uint16_t L_0 = Convert_ToUInt16_m2672597498(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" uint16_t UInt64_System_IConvertible_ToUInt16_m4165747038_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToUInt16_m4165747038(_thisAdjusted, ___provider0, method);
}
// System.Int32 System.UInt64::System.IConvertible.ToInt32(System.IFormatProvider)
extern "C" int32_t UInt64_System_IConvertible_ToInt32_m949522652 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToInt32_m949522652_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
int32_t L_0 = Convert_ToInt32_m825155517(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" int32_t UInt64_System_IConvertible_ToInt32_m949522652_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToInt32_m949522652(_thisAdjusted, ___provider0, method);
}
// System.UInt32 System.UInt64::System.IConvertible.ToUInt32(System.IFormatProvider)
extern "C" uint32_t UInt64_System_IConvertible_ToUInt32_m2784653358 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToUInt32_m2784653358_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
uint32_t L_0 = Convert_ToUInt32_m1767593911(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" uint32_t UInt64_System_IConvertible_ToUInt32_m2784653358_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToUInt32_m2784653358(_thisAdjusted, ___provider0, method);
}
// System.Int64 System.UInt64::System.IConvertible.ToInt64(System.IFormatProvider)
extern "C" int64_t UInt64_System_IConvertible_ToInt64_m4241475606 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToInt64_m4241475606_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
int64_t L_0 = Convert_ToInt64_m260173354(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" int64_t UInt64_System_IConvertible_ToInt64_m4241475606_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToInt64_m4241475606(_thisAdjusted, ___provider0, method);
}
// System.UInt64 System.UInt64::System.IConvertible.ToUInt64(System.IFormatProvider)
extern "C" uint64_t UInt64_System_IConvertible_ToUInt64_m2135047981 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
{
return (*((int64_t*)__this));
}
}
extern "C" uint64_t UInt64_System_IConvertible_ToUInt64_m2135047981_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToUInt64_m2135047981(_thisAdjusted, ___provider0, method);
}
// System.Single System.UInt64::System.IConvertible.ToSingle(System.IFormatProvider)
extern "C" float UInt64_System_IConvertible_ToSingle_m925613075 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToSingle_m925613075_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
float L_0 = Convert_ToSingle_m2791508777(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" float UInt64_System_IConvertible_ToSingle_m925613075_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToSingle_m925613075(_thisAdjusted, ___provider0, method);
}
// System.Double System.UInt64::System.IConvertible.ToDouble(System.IFormatProvider)
extern "C" double UInt64_System_IConvertible_ToDouble_m602078108 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToDouble_m602078108_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
double L_0 = Convert_ToDouble_m1030895834(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" double UInt64_System_IConvertible_ToDouble_m602078108_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToDouble_m602078108(_thisAdjusted, ___provider0, method);
}
// System.Decimal System.UInt64::System.IConvertible.ToDecimal(System.IFormatProvider)
extern "C" Decimal_t2948259380 UInt64_System_IConvertible_ToDecimal_m806594027 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToDecimal_m806594027_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
Decimal_t2948259380 L_0 = Convert_ToDecimal_m1695757674(NULL /*static, unused*/, (*((int64_t*)__this)), /*hidden argument*/NULL);
return L_0;
}
}
extern "C" Decimal_t2948259380 UInt64_System_IConvertible_ToDecimal_m806594027_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToDecimal_m806594027(_thisAdjusted, ___provider0, method);
}
// System.DateTime System.UInt64::System.IConvertible.ToDateTime(System.IFormatProvider)
extern "C" DateTime_t3738529785 UInt64_System_IConvertible_ToDateTime_m3434604642 (uint64_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToDateTime_m3434604642_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ObjectU5BU5D_t2843939325* L_0 = (ObjectU5BU5D_t2843939325*)SZArrayNew(ObjectU5BU5D_t2843939325_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t2843939325* L_1 = L_0;
NullCheck(L_1);
ArrayElementTypeCheck (L_1, _stringLiteral2789494635);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteral2789494635);
ObjectU5BU5D_t2843939325* L_2 = L_1;
NullCheck(L_2);
ArrayElementTypeCheck (L_2, _stringLiteral3798051137);
(L_2)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteral3798051137);
String_t* L_3 = Environment_GetResourceString_m479507158(NULL /*static, unused*/, _stringLiteral4287968739, L_2, /*hidden argument*/NULL);
InvalidCastException_t3927145244 * L_4 = (InvalidCastException_t3927145244 *)il2cpp_codegen_object_new(InvalidCastException_t3927145244_il2cpp_TypeInfo_var);
InvalidCastException__ctor_m318645277(L_4, L_3, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_4, NULL, UInt64_System_IConvertible_ToDateTime_m3434604642_RuntimeMethod_var);
}
}
extern "C" DateTime_t3738529785 UInt64_System_IConvertible_ToDateTime_m3434604642_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___provider0, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToDateTime_m3434604642(_thisAdjusted, ___provider0, method);
}
// System.Object System.UInt64::System.IConvertible.ToType(System.Type,System.IFormatProvider)
extern "C" RuntimeObject * UInt64_System_IConvertible_ToType_m4049257834 (uint64_t* __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UInt64_System_IConvertible_ToType_m4049257834_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
uint64_t L_0 = ((uint64_t)(*((int64_t*)__this)));
RuntimeObject * L_1 = Box(UInt64_t4134040092_il2cpp_TypeInfo_var, &L_0);
Type_t * L_2 = ___type0;
RuntimeObject* L_3 = ___provider1;
IL2CPP_RUNTIME_CLASS_INIT(Convert_t2465617642_il2cpp_TypeInfo_var);
RuntimeObject * L_4 = Convert_DefaultToType_m1860037989(NULL /*static, unused*/, (RuntimeObject*)L_1, L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
extern "C" RuntimeObject * UInt64_System_IConvertible_ToType_m4049257834_AdjustorThunk (RuntimeObject * __this, Type_t * ___type0, RuntimeObject* ___provider1, const RuntimeMethod* method)
{
uint64_t* _thisAdjusted = reinterpret_cast<uint64_t*>(__this + 1);
return UInt64_System_IConvertible_ToType_m4049257834(_thisAdjusted, ___type0, ___provider1, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UIntPtr::.ctor(System.UInt32)
extern "C" void UIntPtr__ctor_m4250165422 (uintptr_t* __this, uint32_t ___value0, const RuntimeMethod* method)
{
{
uint32_t L_0 = ___value0;
*__this = ((((uintptr_t)L_0)));
return;
}
}
extern "C" void UIntPtr__ctor_m4250165422_AdjustorThunk (RuntimeObject * __this, uint32_t ___value0, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
UIntPtr__ctor_m4250165422(_thisAdjusted, ___value0, method);
}
// System.Boolean System.UIntPtr::Equals(System.Object)
extern "C" bool UIntPtr_Equals_m1316671746 (uintptr_t* __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UIntPtr_Equals_m1316671746_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uintptr_t V_0;
memset(&V_0, 0, sizeof(V_0));
{
RuntimeObject * L_0 = ___obj0;
if (!((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, UIntPtr_t_il2cpp_TypeInfo_var)))
{
goto IL_001f;
}
}
{
RuntimeObject * L_1 = ___obj0;
V_0 = ((*(uintptr_t*)((uintptr_t*)UnBox(L_1, UIntPtr_t_il2cpp_TypeInfo_var))));
uintptr_t L_2 = *__this;
uintptr_t L_3 = V_0;
return (bool)((((intptr_t)L_2) == ((intptr_t)L_3))? 1 : 0);
}
IL_001f:
{
return (bool)0;
}
}
extern "C" bool UIntPtr_Equals_m1316671746_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
return UIntPtr_Equals_m1316671746(_thisAdjusted, ___obj0, method);
}
// System.Int32 System.UIntPtr::GetHashCode()
extern "C" int32_t UIntPtr_GetHashCode_m3482152298 (uintptr_t* __this, const RuntimeMethod* method)
{
{
uintptr_t L_0 = *__this;
return (((int32_t)((int32_t)L_0)));
}
}
extern "C" int32_t UIntPtr_GetHashCode_m3482152298_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
return UIntPtr_GetHashCode_m3482152298(_thisAdjusted, method);
}
// System.String System.UIntPtr::ToString()
extern "C" String_t* UIntPtr_ToString_m984583492 (uintptr_t* __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UIntPtr_ToString_m984583492_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint64_t V_0 = 0;
uint32_t V_1 = 0;
{
IL2CPP_RUNTIME_CLASS_INIT(UIntPtr_t_il2cpp_TypeInfo_var);
int32_t L_0 = UIntPtr_get_Size_m703595701(NULL /*static, unused*/, /*hidden argument*/NULL);
if ((((int32_t)L_0) < ((int32_t)8)))
{
goto IL_0018;
}
}
{
uintptr_t L_1 = *__this;
V_0 = (((int64_t)((uint64_t)L_1)));
String_t* L_2 = UInt64_ToString_m1529093114((uint64_t*)(&V_0), /*hidden argument*/NULL);
return L_2;
}
IL_0018:
{
uintptr_t L_3 = *__this;
V_1 = (((int32_t)((uint32_t)L_3)));
String_t* L_4 = UInt32_ToString_m2574561716((uint32_t*)(&V_1), /*hidden argument*/NULL);
return L_4;
}
}
extern "C" String_t* UIntPtr_ToString_m984583492_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
return UIntPtr_ToString_m984583492(_thisAdjusted, method);
}
// System.Void System.UIntPtr::System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_m1767630151 (uintptr_t* __this, SerializationInfo_t950877179 * ___info0, StreamingContext_t3711869237 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_m1767630151_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
SerializationInfo_t950877179 * L_0 = ___info0;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t1615371798 * L_1 = (ArgumentNullException_t1615371798 *)il2cpp_codegen_object_new(ArgumentNullException_t1615371798_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m1170824041(L_1, _stringLiteral79347, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_m1767630151_RuntimeMethod_var);
}
IL_000e:
{
SerializationInfo_t950877179 * L_2 = ___info0;
uintptr_t L_3 = *__this;
NullCheck(L_2);
SerializationInfo_AddValue_m2020653395(L_2, _stringLiteral1363226343, (((int64_t)((uint64_t)L_3))), /*hidden argument*/NULL);
return;
}
}
extern "C" void UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_m1767630151_AdjustorThunk (RuntimeObject * __this, SerializationInfo_t950877179 * ___info0, StreamingContext_t3711869237 ___context1, const RuntimeMethod* method)
{
uintptr_t* _thisAdjusted = reinterpret_cast<uintptr_t*>(__this + 1);
UIntPtr_System_Runtime_Serialization_ISerializable_GetObjectData_m1767630151(_thisAdjusted, ___info0, ___context1, method);
}
// System.Boolean System.UIntPtr::op_Equality(System.UIntPtr,System.UIntPtr)
extern "C" bool UIntPtr_op_Equality_m2241921281 (RuntimeObject * __this /* static, unused */, uintptr_t ___value10, uintptr_t ___value21, const RuntimeMethod* method)
{
{
uintptr_t L_0 = ___value10;
uintptr_t L_1 = ___value21;
return (bool)((((intptr_t)L_0) == ((intptr_t)L_1))? 1 : 0);
}
}
// System.Int32 System.UIntPtr::get_Size()
extern "C" int32_t UIntPtr_get_Size_m703595701 (RuntimeObject * __this /* static, unused */, const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(void*);
return L_0;
}
}
// System.Void System.UIntPtr::.cctor()
extern "C" void UIntPtr__cctor_m3513964473 (RuntimeObject * __this /* static, unused */, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UIntPtr__cctor_m3513964473_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
uintptr_t L_0;
memset(&L_0, 0, sizeof(L_0));
UIntPtr__ctor_m4250165422((&L_0), 0, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UnauthorizedAccessException::.ctor()
extern "C" void UnauthorizedAccessException__ctor_m246605039 (UnauthorizedAccessException_t490705335 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnauthorizedAccessException__ctor_m246605039_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral2994918982, /*hidden argument*/NULL);
SystemException__ctor_m3298527747(__this, L_0, /*hidden argument*/NULL);
Exception_SetErrorCode_m4269507377(__this, ((int32_t)-2147024891), /*hidden argument*/NULL);
return;
}
}
// System.Void System.UnauthorizedAccessException::.ctor(System.String)
extern "C" void UnauthorizedAccessException__ctor_m40101894 (UnauthorizedAccessException_t490705335 * __this, String_t* ___message0, const RuntimeMethod* method)
{
{
String_t* L_0 = ___message0;
SystemException__ctor_m3298527747(__this, L_0, /*hidden argument*/NULL);
Exception_SetErrorCode_m4269507377(__this, ((int32_t)-2147024891), /*hidden argument*/NULL);
return;
}
}
// System.Void System.UnauthorizedAccessException::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void UnauthorizedAccessException__ctor_m1652256089 (UnauthorizedAccessException_t490705335 * __this, SerializationInfo_t950877179 * ___info0, StreamingContext_t3711869237 ___context1, const RuntimeMethod* method)
{
{
SerializationInfo_t950877179 * L_0 = ___info0;
StreamingContext_t3711869237 L_1 = ___context1;
SystemException__ctor_m1515048899(__this, L_0, L_1, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UnhandledExceptionEventArgs::.ctor(System.Object,System.Boolean)
extern "C" void UnhandledExceptionEventArgs__ctor_m224348470 (UnhandledExceptionEventArgs_t2886101344 * __this, RuntimeObject * ___exception0, bool ___isTerminating1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnhandledExceptionEventArgs__ctor_m224348470_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(EventArgs_t3591816995_il2cpp_TypeInfo_var);
EventArgs__ctor_m32674013(__this, /*hidden argument*/NULL);
RuntimeObject * L_0 = ___exception0;
__this->set__Exception_1(L_0);
bool L_1 = ___isTerminating1;
__this->set__IsTerminating_2(L_1);
return;
}
}
// System.Object System.UnhandledExceptionEventArgs::get_ExceptionObject()
extern "C" RuntimeObject * UnhandledExceptionEventArgs_get_ExceptionObject_m862578480 (UnhandledExceptionEventArgs_t2886101344 * __this, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = __this->get__Exception_1();
return L_0;
}
}
// System.Boolean System.UnhandledExceptionEventArgs::get_IsTerminating()
extern "C" bool UnhandledExceptionEventArgs_get_IsTerminating_m4073714616 (UnhandledExceptionEventArgs_t2886101344 * __this, const RuntimeMethod* method)
{
{
bool L_0 = __this->get__IsTerminating_2();
return L_0;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UnhandledExceptionEventHandler::.ctor(System.Object,System.IntPtr)
extern "C" void UnhandledExceptionEventHandler__ctor_m626016213 (UnhandledExceptionEventHandler_t3101989324 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.UnhandledExceptionEventHandler::Invoke(System.Object,System.UnhandledExceptionEventArgs)
extern "C" void UnhandledExceptionEventHandler_Invoke_m1545705626 (UnhandledExceptionEventHandler_t3101989324 * __this, RuntimeObject * ___sender0, UnhandledExceptionEventArgs_t2886101344 * ___e1, const RuntimeMethod* method)
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((RuntimeMethod*)(__this->get_method_3()));
DelegateU5BU5D_t1703627840* delegatesToInvoke = __this->get_delegates_11();
if (delegatesToInvoke != NULL)
{
il2cpp_array_size_t length = delegatesToInvoke->max_length;
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t1188392813* currentDelegate = (delegatesToInvoke)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
bool ___methodIsStatic = MethodIsStatic(targetMethod);
if (___methodIsStatic)
{
if (il2cpp_codegen_method_parameter_count(targetMethod) == 2)
{
// open
{
typedef void (*FunctionPointerType) (RuntimeObject *, RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(NULL, ___sender0, ___e1, targetMethod);
}
}
else
{
// closed
{
typedef void (*FunctionPointerType) (RuntimeObject *, void*, RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(NULL, targetThis, ___sender0, ___e1, targetMethod);
}
}
}
else
{
if (il2cpp_codegen_method_parameter_count(targetMethod) == 2)
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 * >::Invoke(targetMethod, targetThis, ___sender0, ___e1);
else
GenericVirtActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 * >::Invoke(targetMethod, targetThis, ___sender0, ___e1);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___sender0, ___e1);
else
VirtActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___sender0, ___e1);
}
}
else
{
typedef void (*FunctionPointerType) (void*, RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___sender0, ___e1, targetMethod);
}
}
else
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< UnhandledExceptionEventArgs_t2886101344 * >::Invoke(targetMethod, ___sender0, ___e1);
else
GenericVirtActionInvoker1< UnhandledExceptionEventArgs_t2886101344 * >::Invoke(targetMethod, ___sender0, ___e1);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< UnhandledExceptionEventArgs_t2886101344 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___sender0, ___e1);
else
VirtActionInvoker1< UnhandledExceptionEventArgs_t2886101344 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___sender0, ___e1);
}
}
else
{
typedef void (*FunctionPointerType) (RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___sender0, ___e1, targetMethod);
}
}
}
}
}
else
{
Il2CppMethodPointer targetMethodPointer = __this->get_method_ptr_0();
RuntimeMethod* targetMethod = (RuntimeMethod*)(__this->get_method_3());
RuntimeObject* targetThis = __this->get_m_target_2();
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
bool ___methodIsStatic = MethodIsStatic(targetMethod);
if (___methodIsStatic)
{
if (il2cpp_codegen_method_parameter_count(targetMethod) == 2)
{
// open
{
typedef void (*FunctionPointerType) (RuntimeObject *, RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(NULL, ___sender0, ___e1, targetMethod);
}
}
else
{
// closed
{
typedef void (*FunctionPointerType) (RuntimeObject *, void*, RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(NULL, targetThis, ___sender0, ___e1, targetMethod);
}
}
}
else
{
if (il2cpp_codegen_method_parameter_count(targetMethod) == 2)
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 * >::Invoke(targetMethod, targetThis, ___sender0, ___e1);
else
GenericVirtActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 * >::Invoke(targetMethod, targetThis, ___sender0, ___e1);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___sender0, ___e1);
else
VirtActionInvoker2< RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___sender0, ___e1);
}
}
else
{
typedef void (*FunctionPointerType) (void*, RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___sender0, ___e1, targetMethod);
}
}
else
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< UnhandledExceptionEventArgs_t2886101344 * >::Invoke(targetMethod, ___sender0, ___e1);
else
GenericVirtActionInvoker1< UnhandledExceptionEventArgs_t2886101344 * >::Invoke(targetMethod, ___sender0, ___e1);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< UnhandledExceptionEventArgs_t2886101344 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___sender0, ___e1);
else
VirtActionInvoker1< UnhandledExceptionEventArgs_t2886101344 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___sender0, ___e1);
}
}
else
{
typedef void (*FunctionPointerType) (RuntimeObject *, UnhandledExceptionEventArgs_t2886101344 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___sender0, ___e1, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.UnhandledExceptionEventHandler::BeginInvoke(System.Object,System.UnhandledExceptionEventArgs,System.AsyncCallback,System.Object)
extern "C" RuntimeObject* UnhandledExceptionEventHandler_BeginInvoke_m1761611550 (UnhandledExceptionEventHandler_t3101989324 * __this, RuntimeObject * ___sender0, UnhandledExceptionEventArgs_t2886101344 * ___e1, AsyncCallback_t3962456242 * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
void *__d_args[3] = {0};
__d_args[0] = ___sender0;
__d_args[1] = ___e1;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// System.Void System.UnhandledExceptionEventHandler::EndInvoke(System.IAsyncResult)
extern "C" void UnhandledExceptionEventHandler_EndInvoke_m2316153791 (UnhandledExceptionEventHandler_t3101989324 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.UnitySerializationHolder::GetUnitySerializationInfo(System.Runtime.Serialization.SerializationInfo,System.Reflection.Missing)
extern "C" void UnitySerializationHolder_GetUnitySerializationInfo_m927411785 (RuntimeObject * __this /* static, unused */, SerializationInfo_t950877179 * ___info0, Missing_t508514592 * ___missing1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetUnitySerializationInfo_m927411785_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
SerializationInfo_t950877179 * L_0 = ___info0;
RuntimeTypeHandle_t3027515415 L_1 = { reinterpret_cast<intptr_t> (UnitySerializationHolder_t431912834_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_2 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
NullCheck(L_0);
SerializationInfo_SetType_m3923964808(L_0, L_2, /*hidden argument*/NULL);
SerializationInfo_t950877179 * L_3 = ___info0;
NullCheck(L_3);
SerializationInfo_AddValue_m412754688(L_3, _stringLiteral3283586028, 3, /*hidden argument*/NULL);
return;
}
}
// System.RuntimeType System.UnitySerializationHolder::AddElementTypes(System.Runtime.Serialization.SerializationInfo,System.RuntimeType)
extern "C" RuntimeType_t3636489352 * UnitySerializationHolder_AddElementTypes_m2711578409 (RuntimeObject * __this /* static, unused */, SerializationInfo_t950877179 * ___info0, RuntimeType_t3636489352 * ___type1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_AddElementTypes_m2711578409_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
List_1_t128053199 * V_0 = NULL;
{
List_1_t128053199 * L_0 = (List_1_t128053199 *)il2cpp_codegen_object_new(List_1_t128053199_il2cpp_TypeInfo_var);
List_1__ctor_m1204004817(L_0, /*hidden argument*/List_1__ctor_m1204004817_RuntimeMethod_var);
V_0 = L_0;
goto IL_0063;
}
IL_0008:
{
RuntimeType_t3636489352 * L_1 = ___type1;
NullCheck(L_1);
bool L_2 = VirtFuncInvoker0< bool >::Invoke(77 /* System.Boolean System.Type::get_IsSzArray() */, L_1);
if (!L_2)
{
goto IL_0019;
}
}
{
List_1_t128053199 * L_3 = V_0;
NullCheck(L_3);
List_1_Add_m2080863212(L_3, 3, /*hidden argument*/List_1_Add_m2080863212_RuntimeMethod_var);
goto IL_0056;
}
IL_0019:
{
RuntimeType_t3636489352 * L_4 = ___type1;
NullCheck(L_4);
bool L_5 = Type_get_IsArray_m2591212821(L_4, /*hidden argument*/NULL);
if (!L_5)
{
goto IL_0036;
}
}
{
List_1_t128053199 * L_6 = V_0;
RuntimeType_t3636489352 * L_7 = ___type1;
NullCheck(L_7);
int32_t L_8 = VirtFuncInvoker0< int32_t >::Invoke(29 /* System.Int32 System.Type::GetArrayRank() */, L_7);
NullCheck(L_6);
List_1_Add_m2080863212(L_6, L_8, /*hidden argument*/List_1_Add_m2080863212_RuntimeMethod_var);
List_1_t128053199 * L_9 = V_0;
NullCheck(L_9);
List_1_Add_m2080863212(L_9, 2, /*hidden argument*/List_1_Add_m2080863212_RuntimeMethod_var);
goto IL_0056;
}
IL_0036:
{
RuntimeType_t3636489352 * L_10 = ___type1;
NullCheck(L_10);
bool L_11 = Type_get_IsPointer_m4067542339(L_10, /*hidden argument*/NULL);
if (!L_11)
{
goto IL_0047;
}
}
{
List_1_t128053199 * L_12 = V_0;
NullCheck(L_12);
List_1_Add_m2080863212(L_12, 1, /*hidden argument*/List_1_Add_m2080863212_RuntimeMethod_var);
goto IL_0056;
}
IL_0047:
{
RuntimeType_t3636489352 * L_13 = ___type1;
NullCheck(L_13);
bool L_14 = Type_get_IsByRef_m1262524108(L_13, /*hidden argument*/NULL);
if (!L_14)
{
goto IL_0056;
}
}
{
List_1_t128053199 * L_15 = V_0;
NullCheck(L_15);
List_1_Add_m2080863212(L_15, 4, /*hidden argument*/List_1_Add_m2080863212_RuntimeMethod_var);
}
IL_0056:
{
RuntimeType_t3636489352 * L_16 = ___type1;
NullCheck(L_16);
Type_t * L_17 = VirtFuncInvoker0< Type_t * >::Invoke(101 /* System.Type System.Type::GetElementType() */, L_16);
___type1 = ((RuntimeType_t3636489352 *)CastclassClass((RuntimeObject*)L_17, RuntimeType_t3636489352_il2cpp_TypeInfo_var));
}
IL_0063:
{
RuntimeType_t3636489352 * L_18 = ___type1;
NullCheck(L_18);
bool L_19 = Type_get_HasElementType_m710151977(L_18, /*hidden argument*/NULL);
if (L_19)
{
goto IL_0008;
}
}
{
SerializationInfo_t950877179 * L_20 = ___info0;
List_1_t128053199 * L_21 = V_0;
NullCheck(L_21);
Int32U5BU5D_t385246372* L_22 = List_1_ToArray_m1469074435(L_21, /*hidden argument*/List_1_ToArray_m1469074435_RuntimeMethod_var);
RuntimeTypeHandle_t3027515415 L_23 = { reinterpret_cast<intptr_t> (Int32U5BU5D_t385246372_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_24 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_23, /*hidden argument*/NULL);
NullCheck(L_20);
SerializationInfo_AddValue_m3906743584(L_20, _stringLiteral3927933503, (RuntimeObject *)(RuntimeObject *)L_22, L_24, /*hidden argument*/NULL);
RuntimeType_t3636489352 * L_25 = ___type1;
return L_25;
}
}
// System.Type System.UnitySerializationHolder::MakeElementTypes(System.Type)
extern "C" Type_t * UnitySerializationHolder_MakeElementTypes_m672301684 (UnitySerializationHolder_t431912834 * __this, Type_t * ___type0, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
Int32U5BU5D_t385246372* L_0 = __this->get_m_elementTypes_1();
NullCheck(L_0);
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)(((int32_t)((int32_t)(((RuntimeArray *)L_0)->max_length)))), (int32_t)1));
goto IL_006f;
}
IL_000d:
{
Int32U5BU5D_t385246372* L_1 = __this->get_m_elementTypes_1();
int32_t L_2 = V_0;
NullCheck(L_1);
int32_t L_3 = L_2;
int32_t L_4 = (L_1)->GetAt(static_cast<il2cpp_array_size_t>(L_3));
if ((!(((uint32_t)L_4) == ((uint32_t)3))))
{
goto IL_0022;
}
}
{
Type_t * L_5 = ___type0;
NullCheck(L_5);
Type_t * L_6 = VirtFuncInvoker0< Type_t * >::Invoke(19 /* System.Type System.Type::MakeArrayType() */, L_5);
___type0 = L_6;
goto IL_006b;
}
IL_0022:
{
Int32U5BU5D_t385246372* L_7 = __this->get_m_elementTypes_1();
int32_t L_8 = V_0;
NullCheck(L_7);
int32_t L_9 = L_8;
int32_t L_10 = (L_7)->GetAt(static_cast<il2cpp_array_size_t>(L_9));
if ((!(((uint32_t)L_10) == ((uint32_t)2))))
{
goto IL_0043;
}
}
{
Type_t * L_11 = ___type0;
Int32U5BU5D_t385246372* L_12 = __this->get_m_elementTypes_1();
int32_t L_13 = V_0;
int32_t L_14 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_13, (int32_t)1));
V_0 = L_14;
NullCheck(L_12);
int32_t L_15 = L_14;
int32_t L_16 = (L_12)->GetAt(static_cast<il2cpp_array_size_t>(L_15));
NullCheck(L_11);
Type_t * L_17 = VirtFuncInvoker1< Type_t *, int32_t >::Invoke(20 /* System.Type System.Type::MakeArrayType(System.Int32) */, L_11, L_16);
___type0 = L_17;
goto IL_006b;
}
IL_0043:
{
Int32U5BU5D_t385246372* L_18 = __this->get_m_elementTypes_1();
int32_t L_19 = V_0;
NullCheck(L_18);
int32_t L_20 = L_19;
int32_t L_21 = (L_18)->GetAt(static_cast<il2cpp_array_size_t>(L_20));
if ((!(((uint32_t)L_21) == ((uint32_t)1))))
{
goto IL_0058;
}
}
{
Type_t * L_22 = ___type0;
NullCheck(L_22);
Type_t * L_23 = VirtFuncInvoker0< Type_t * >::Invoke(17 /* System.Type System.Type::MakePointerType() */, L_22);
___type0 = L_23;
goto IL_006b;
}
IL_0058:
{
Int32U5BU5D_t385246372* L_24 = __this->get_m_elementTypes_1();
int32_t L_25 = V_0;
NullCheck(L_24);
int32_t L_26 = L_25;
int32_t L_27 = (L_24)->GetAt(static_cast<il2cpp_array_size_t>(L_26));
if ((!(((uint32_t)L_27) == ((uint32_t)4))))
{
goto IL_006b;
}
}
{
Type_t * L_28 = ___type0;
NullCheck(L_28);
Type_t * L_29 = VirtFuncInvoker0< Type_t * >::Invoke(18 /* System.Type System.Type::MakeByRefType() */, L_28);
___type0 = L_29;
}
IL_006b:
{
int32_t L_30 = V_0;
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_30, (int32_t)1));
}
IL_006f:
{
int32_t L_31 = V_0;
if ((((int32_t)L_31) >= ((int32_t)0)))
{
goto IL_000d;
}
}
{
Type_t * L_32 = ___type0;
return L_32;
}
}
// System.Void System.UnitySerializationHolder::GetUnitySerializationInfo(System.Runtime.Serialization.SerializationInfo,System.RuntimeType)
extern "C" void UnitySerializationHolder_GetUnitySerializationInfo_m3060468266 (RuntimeObject * __this /* static, unused */, SerializationInfo_t950877179 * ___info0, RuntimeType_t3636489352 * ___type1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetUnitySerializationInfo_m3060468266_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
RuntimeType_t3636489352 * L_0 = ___type1;
NullCheck(L_0);
Type_t * L_1 = Type_GetRootElementType_m2028550026(L_0, /*hidden argument*/NULL);
NullCheck(L_1);
bool L_2 = VirtFuncInvoker0< bool >::Invoke(80 /* System.Boolean System.Type::get_IsGenericParameter() */, L_1);
if (!L_2)
{
goto IL_007a;
}
}
{
SerializationInfo_t950877179 * L_3 = ___info0;
RuntimeType_t3636489352 * L_4 = ___type1;
RuntimeType_t3636489352 * L_5 = UnitySerializationHolder_AddElementTypes_m2711578409(NULL /*static, unused*/, L_3, L_4, /*hidden argument*/NULL);
___type1 = L_5;
SerializationInfo_t950877179 * L_6 = ___info0;
RuntimeTypeHandle_t3027515415 L_7 = { reinterpret_cast<intptr_t> (UnitySerializationHolder_t431912834_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_8 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_7, /*hidden argument*/NULL);
NullCheck(L_6);
SerializationInfo_SetType_m3923964808(L_6, L_8, /*hidden argument*/NULL);
SerializationInfo_t950877179 * L_9 = ___info0;
NullCheck(L_9);
SerializationInfo_AddValue_m412754688(L_9, _stringLiteral3283586028, 7, /*hidden argument*/NULL);
SerializationInfo_t950877179 * L_10 = ___info0;
RuntimeType_t3636489352 * L_11 = ___type1;
NullCheck(L_11);
int32_t L_12 = VirtFuncInvoker0< int32_t >::Invoke(81 /* System.Int32 System.Type::get_GenericParameterPosition() */, L_11);
NullCheck(L_10);
SerializationInfo_AddValue_m412754688(L_10, _stringLiteral3378664767, L_12, /*hidden argument*/NULL);
SerializationInfo_t950877179 * L_13 = ___info0;
RuntimeType_t3636489352 * L_14 = ___type1;
NullCheck(L_14);
MethodBase_t * L_15 = VirtFuncInvoker0< MethodBase_t * >::Invoke(16 /* System.Reflection.MethodBase System.Type::get_DeclaringMethod() */, L_14);
RuntimeTypeHandle_t3027515415 L_16 = { reinterpret_cast<intptr_t> (MethodBase_t_0_0_0_var) };
Type_t * L_17 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_16, /*hidden argument*/NULL);
NullCheck(L_13);
SerializationInfo_AddValue_m3906743584(L_13, _stringLiteral98117656, L_15, L_17, /*hidden argument*/NULL);
SerializationInfo_t950877179 * L_18 = ___info0;
RuntimeType_t3636489352 * L_19 = ___type1;
NullCheck(L_19);
Type_t * L_20 = VirtFuncInvoker0< Type_t * >::Invoke(8 /* System.Type System.Reflection.MemberInfo::get_DeclaringType() */, L_19);
RuntimeTypeHandle_t3027515415 L_21 = { reinterpret_cast<intptr_t> (Type_t_0_0_0_var) };
Type_t * L_22 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_21, /*hidden argument*/NULL);
NullCheck(L_18);
SerializationInfo_AddValue_m3906743584(L_18, _stringLiteral2725392681, L_20, L_22, /*hidden argument*/NULL);
return;
}
IL_007a:
{
V_0 = 4;
RuntimeType_t3636489352 * L_23 = ___type1;
NullCheck(L_23);
bool L_24 = VirtFuncInvoker0< bool >::Invoke(79 /* System.Boolean System.Type::get_IsGenericTypeDefinition() */, L_23);
if (L_24)
{
goto IL_00bf;
}
}
{
RuntimeType_t3636489352 * L_25 = ___type1;
NullCheck(L_25);
bool L_26 = VirtFuncInvoker0< bool >::Invoke(82 /* System.Boolean System.Type::get_ContainsGenericParameters() */, L_25);
if (!L_26)
{
goto IL_00bf;
}
}
{
V_0 = 8;
SerializationInfo_t950877179 * L_27 = ___info0;
RuntimeType_t3636489352 * L_28 = ___type1;
RuntimeType_t3636489352 * L_29 = UnitySerializationHolder_AddElementTypes_m2711578409(NULL /*static, unused*/, L_27, L_28, /*hidden argument*/NULL);
___type1 = L_29;
SerializationInfo_t950877179 * L_30 = ___info0;
RuntimeType_t3636489352 * L_31 = ___type1;
NullCheck(L_31);
TypeU5BU5D_t3940880105* L_32 = VirtFuncInvoker0< TypeU5BU5D_t3940880105* >::Invoke(102 /* System.Type[] System.Type::GetGenericArguments() */, L_31);
RuntimeTypeHandle_t3027515415 L_33 = { reinterpret_cast<intptr_t> (TypeU5BU5D_t3940880105_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_34 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_33, /*hidden argument*/NULL);
NullCheck(L_30);
SerializationInfo_AddValue_m3906743584(L_30, _stringLiteral1245918466, (RuntimeObject *)(RuntimeObject *)L_32, L_34, /*hidden argument*/NULL);
RuntimeType_t3636489352 * L_35 = ___type1;
NullCheck(L_35);
Type_t * L_36 = VirtFuncInvoker0< Type_t * >::Invoke(103 /* System.Type System.Type::GetGenericTypeDefinition() */, L_35);
___type1 = ((RuntimeType_t3636489352 *)CastclassClass((RuntimeObject*)L_36, RuntimeType_t3636489352_il2cpp_TypeInfo_var));
}
IL_00bf:
{
SerializationInfo_t950877179 * L_37 = ___info0;
int32_t L_38 = V_0;
RuntimeType_t3636489352 * L_39 = ___type1;
NullCheck(L_39);
String_t* L_40 = VirtFuncInvoker0< String_t* >::Invoke(26 /* System.String System.Type::get_FullName() */, L_39);
RuntimeType_t3636489352 * L_41 = ___type1;
NullCheck(L_41);
RuntimeAssembly_t1451753063 * L_42 = RuntimeType_GetRuntimeAssembly_m2955606119(L_41, /*hidden argument*/NULL);
UnitySerializationHolder_GetUnitySerializationInfo_m3966690610(NULL /*static, unused*/, L_37, L_38, L_40, L_42, /*hidden argument*/NULL);
return;
}
}
// System.Void System.UnitySerializationHolder::GetUnitySerializationInfo(System.Runtime.Serialization.SerializationInfo,System.Int32,System.String,System.Reflection.RuntimeAssembly)
extern "C" void UnitySerializationHolder_GetUnitySerializationInfo_m3966690610 (RuntimeObject * __this /* static, unused */, SerializationInfo_t950877179 * ___info0, int32_t ___unityType1, String_t* ___data2, RuntimeAssembly_t1451753063 * ___assembly3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetUnitySerializationInfo_m3966690610_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
SerializationInfo_t950877179 * L_0 = ___info0;
RuntimeTypeHandle_t3027515415 L_1 = { reinterpret_cast<intptr_t> (UnitySerializationHolder_t431912834_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_2 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
NullCheck(L_0);
SerializationInfo_SetType_m3923964808(L_0, L_2, /*hidden argument*/NULL);
SerializationInfo_t950877179 * L_3 = ___info0;
String_t* L_4 = ___data2;
RuntimeTypeHandle_t3027515415 L_5 = { reinterpret_cast<intptr_t> (String_t_0_0_0_var) };
Type_t * L_6 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_5, /*hidden argument*/NULL);
NullCheck(L_3);
SerializationInfo_AddValue_m3906743584(L_3, _stringLiteral2037252898, L_4, L_6, /*hidden argument*/NULL);
SerializationInfo_t950877179 * L_7 = ___info0;
int32_t L_8 = ___unityType1;
NullCheck(L_7);
SerializationInfo_AddValue_m412754688(L_7, _stringLiteral3283586028, L_8, /*hidden argument*/NULL);
RuntimeAssembly_t1451753063 * L_9 = ___assembly3;
bool L_10 = Assembly_op_Equality_m3828289814(NULL /*static, unused*/, L_9, (Assembly_t *)NULL, /*hidden argument*/NULL);
if (!L_10)
{
goto IL_0043;
}
}
{
String_t* L_11 = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
V_0 = L_11;
goto IL_004a;
}
IL_0043:
{
RuntimeAssembly_t1451753063 * L_12 = ___assembly3;
NullCheck(L_12);
String_t* L_13 = VirtFuncInvoker0< String_t* >::Invoke(8 /* System.String System.Reflection.Assembly::get_FullName() */, L_12);
V_0 = L_13;
}
IL_004a:
{
SerializationInfo_t950877179 * L_14 = ___info0;
String_t* L_15 = V_0;
NullCheck(L_14);
SerializationInfo_AddValue_m2872281893(L_14, _stringLiteral209558951, L_15, /*hidden argument*/NULL);
return;
}
}
// System.Void System.UnitySerializationHolder::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void UnitySerializationHolder__ctor_m3869442095 (UnitySerializationHolder_t431912834 * __this, SerializationInfo_t950877179 * ___info0, StreamingContext_t3711869237 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder__ctor_m3869442095_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Object__ctor_m297566312(__this, /*hidden argument*/NULL);
SerializationInfo_t950877179 * L_0 = ___info0;
if (L_0)
{
goto IL_0014;
}
}
{
ArgumentNullException_t1615371798 * L_1 = (ArgumentNullException_t1615371798 *)il2cpp_codegen_object_new(ArgumentNullException_t1615371798_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m1170824041(L_1, _stringLiteral79347, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, UnitySerializationHolder__ctor_m3869442095_RuntimeMethod_var);
}
IL_0014:
{
SerializationInfo_t950877179 * L_2 = ___info0;
NullCheck(L_2);
int32_t L_3 = SerializationInfo_GetInt32_m2640574809(L_2, _stringLiteral3283586028, /*hidden argument*/NULL);
__this->set_m_unityType_7(L_3);
int32_t L_4 = __this->get_m_unityType_7();
if ((!(((uint32_t)L_4) == ((uint32_t)3))))
{
goto IL_002f;
}
}
{
return;
}
IL_002f:
{
int32_t L_5 = __this->get_m_unityType_7();
if ((!(((uint32_t)L_5) == ((uint32_t)7))))
{
goto IL_00aa;
}
}
{
SerializationInfo_t950877179 * L_6 = ___info0;
RuntimeTypeHandle_t3027515415 L_7 = { reinterpret_cast<intptr_t> (MethodBase_t_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_8 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_7, /*hidden argument*/NULL);
NullCheck(L_6);
RuntimeObject * L_9 = SerializationInfo_GetValue_m42271953(L_6, _stringLiteral98117656, L_8, /*hidden argument*/NULL);
__this->set_m_declaringMethod_4(((MethodBase_t *)IsInstClass((RuntimeObject*)L_9, MethodBase_t_il2cpp_TypeInfo_var)));
SerializationInfo_t950877179 * L_10 = ___info0;
RuntimeTypeHandle_t3027515415 L_11 = { reinterpret_cast<intptr_t> (Type_t_0_0_0_var) };
Type_t * L_12 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_11, /*hidden argument*/NULL);
NullCheck(L_10);
RuntimeObject * L_13 = SerializationInfo_GetValue_m42271953(L_10, _stringLiteral2725392681, L_12, /*hidden argument*/NULL);
__this->set_m_declaringType_3(((Type_t *)IsInstClass((RuntimeObject*)L_13, Type_t_il2cpp_TypeInfo_var)));
SerializationInfo_t950877179 * L_14 = ___info0;
NullCheck(L_14);
int32_t L_15 = SerializationInfo_GetInt32_m2640574809(L_14, _stringLiteral3378664767, /*hidden argument*/NULL);
__this->set_m_genericParameterPosition_2(L_15);
SerializationInfo_t950877179 * L_16 = ___info0;
RuntimeTypeHandle_t3027515415 L_17 = { reinterpret_cast<intptr_t> (Int32U5BU5D_t385246372_0_0_0_var) };
Type_t * L_18 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_17, /*hidden argument*/NULL);
NullCheck(L_16);
RuntimeObject * L_19 = SerializationInfo_GetValue_m42271953(L_16, _stringLiteral3927933503, L_18, /*hidden argument*/NULL);
__this->set_m_elementTypes_1(((Int32U5BU5D_t385246372*)IsInst((RuntimeObject*)L_19, Int32U5BU5D_t385246372_il2cpp_TypeInfo_var)));
return;
}
IL_00aa:
{
int32_t L_20 = __this->get_m_unityType_7();
if ((!(((uint32_t)L_20) == ((uint32_t)8))))
{
goto IL_00f3;
}
}
{
SerializationInfo_t950877179 * L_21 = ___info0;
RuntimeTypeHandle_t3027515415 L_22 = { reinterpret_cast<intptr_t> (TypeU5BU5D_t3940880105_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_23 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_22, /*hidden argument*/NULL);
NullCheck(L_21);
RuntimeObject * L_24 = SerializationInfo_GetValue_m42271953(L_21, _stringLiteral1245918466, L_23, /*hidden argument*/NULL);
__this->set_m_instantiation_0(((TypeU5BU5D_t3940880105*)IsInst((RuntimeObject*)L_24, TypeU5BU5D_t3940880105_il2cpp_TypeInfo_var)));
SerializationInfo_t950877179 * L_25 = ___info0;
RuntimeTypeHandle_t3027515415 L_26 = { reinterpret_cast<intptr_t> (Int32U5BU5D_t385246372_0_0_0_var) };
Type_t * L_27 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_26, /*hidden argument*/NULL);
NullCheck(L_25);
RuntimeObject * L_28 = SerializationInfo_GetValue_m42271953(L_25, _stringLiteral3927933503, L_27, /*hidden argument*/NULL);
__this->set_m_elementTypes_1(((Int32U5BU5D_t385246372*)IsInst((RuntimeObject*)L_28, Int32U5BU5D_t385246372_il2cpp_TypeInfo_var)));
}
IL_00f3:
{
SerializationInfo_t950877179 * L_29 = ___info0;
NullCheck(L_29);
String_t* L_30 = SerializationInfo_GetString_m3155282843(L_29, _stringLiteral2037252898, /*hidden argument*/NULL);
__this->set_m_data_5(L_30);
SerializationInfo_t950877179 * L_31 = ___info0;
NullCheck(L_31);
String_t* L_32 = SerializationInfo_GetString_m3155282843(L_31, _stringLiteral209558951, /*hidden argument*/NULL);
__this->set_m_assemblyName_6(L_32);
return;
}
}
// System.Void System.UnitySerializationHolder::ThrowInsufficientInformation(System.String)
extern "C" void UnitySerializationHolder_ThrowInsufficientInformation_m1747464776 (UnitySerializationHolder_t431912834 * __this, String_t* ___field0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_ThrowInsufficientInformation_m1747464776_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ObjectU5BU5D_t2843939325* L_0 = (ObjectU5BU5D_t2843939325*)SZArrayNew(ObjectU5BU5D_t2843939325_il2cpp_TypeInfo_var, (uint32_t)1);
ObjectU5BU5D_t2843939325* L_1 = L_0;
String_t* L_2 = ___field0;
NullCheck(L_1);
ArrayElementTypeCheck (L_1, L_2);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)L_2);
String_t* L_3 = Environment_GetResourceString_m479507158(NULL /*static, unused*/, _stringLiteral3245515088, L_1, /*hidden argument*/NULL);
SerializationException_t3941511869 * L_4 = (SerializationException_t3941511869 *)il2cpp_codegen_object_new(SerializationException_t3941511869_il2cpp_TypeInfo_var);
SerializationException__ctor_m3862484944(L_4, L_3, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_4, NULL, UnitySerializationHolder_ThrowInsufficientInformation_m1747464776_RuntimeMethod_var);
}
}
// System.Void System.UnitySerializationHolder::GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void UnitySerializationHolder_GetObjectData_m3377455907 (UnitySerializationHolder_t431912834 * __this, SerializationInfo_t950877179 * ___info0, StreamingContext_t3711869237 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetObjectData_m3377455907_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral532335187, /*hidden argument*/NULL);
NotSupportedException_t1314879016 * L_1 = (NotSupportedException_t1314879016 *)il2cpp_codegen_object_new(NotSupportedException_t1314879016_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m2494070935(L_1, L_0, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, UnitySerializationHolder_GetObjectData_m3377455907_RuntimeMethod_var);
}
}
// System.Object System.UnitySerializationHolder::GetRealObject(System.Runtime.Serialization.StreamingContext)
extern "C" RuntimeObject * UnitySerializationHolder_GetRealObject_m1624354633 (UnitySerializationHolder_t431912834 * __this, StreamingContext_t3711869237 ___context0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnitySerializationHolder_GetRealObject_m1624354633_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
Type_t * V_1 = NULL;
Module_t2987026101 * V_2 = NULL;
{
int32_t L_0 = __this->get_m_unityType_7();
V_0 = L_0;
int32_t L_1 = V_0;
switch (((int32_t)il2cpp_codegen_subtract((int32_t)L_1, (int32_t)1)))
{
case 0:
{
goto IL_0034;
}
case 1:
{
goto IL_003a;
}
case 2:
{
goto IL_0040;
}
case 3:
{
goto IL_00e7;
}
case 4:
{
goto IL_014e;
}
case 5:
{
goto IL_01cb;
}
case 6:
{
goto IL_0086;
}
case 7:
{
goto IL_0046;
}
}
}
{
goto IL_020a;
}
IL_0034:
{
IL2CPP_RUNTIME_CLASS_INIT(Empty_t4129602447_il2cpp_TypeInfo_var);
Empty_t4129602447 * L_2 = ((Empty_t4129602447_StaticFields*)il2cpp_codegen_static_fields_for(Empty_t4129602447_il2cpp_TypeInfo_var))->get_Value_0();
return L_2;
}
IL_003a:
{
IL2CPP_RUNTIME_CLASS_INIT(DBNull_t3725197148_il2cpp_TypeInfo_var);
DBNull_t3725197148 * L_3 = ((DBNull_t3725197148_StaticFields*)il2cpp_codegen_static_fields_for(DBNull_t3725197148_il2cpp_TypeInfo_var))->get_Value_0();
return L_3;
}
IL_0040:
{
IL2CPP_RUNTIME_CLASS_INIT(Missing_t508514592_il2cpp_TypeInfo_var);
Missing_t508514592 * L_4 = ((Missing_t508514592_StaticFields*)il2cpp_codegen_static_fields_for(Missing_t508514592_il2cpp_TypeInfo_var))->get_Value_0();
return L_4;
}
IL_0046:
{
__this->set_m_unityType_7(4);
StreamingContext_t3711869237 L_5 = ___context0;
RuntimeObject * L_6 = VirtFuncInvoker1< RuntimeObject *, StreamingContext_t3711869237 >::Invoke(7 /* System.Object System.UnitySerializationHolder::GetRealObject(System.Runtime.Serialization.StreamingContext) */, __this, L_5);
V_1 = ((Type_t *)IsInstClass((RuntimeObject*)L_6, Type_t_il2cpp_TypeInfo_var));
__this->set_m_unityType_7(8);
TypeU5BU5D_t3940880105* L_7 = __this->get_m_instantiation_0();
NullCheck(L_7);
int32_t L_8 = 0;
Type_t * L_9 = (L_7)->GetAt(static_cast<il2cpp_array_size_t>(L_8));
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
bool L_10 = Type_op_Equality_m2683486427(NULL /*static, unused*/, L_9, (Type_t *)NULL, /*hidden argument*/NULL);
if (!L_10)
{
goto IL_0073;
}
}
{
return NULL;
}
IL_0073:
{
Type_t * L_11 = V_1;
TypeU5BU5D_t3940880105* L_12 = __this->get_m_instantiation_0();
NullCheck(L_11);
Type_t * L_13 = VirtFuncInvoker1< Type_t *, TypeU5BU5D_t3940880105* >::Invoke(98 /* System.Type System.Type::MakeGenericType(System.Type[]) */, L_11, L_12);
Type_t * L_14 = UnitySerializationHolder_MakeElementTypes_m672301684(__this, L_13, /*hidden argument*/NULL);
return L_14;
}
IL_0086:
{
MethodBase_t * L_15 = __this->get_m_declaringMethod_4();
bool L_16 = MethodBase_op_Equality_m2405991987(NULL /*static, unused*/, L_15, (MethodBase_t *)NULL, /*hidden argument*/NULL);
if (!L_16)
{
goto IL_00ad;
}
}
{
Type_t * L_17 = __this->get_m_declaringType_3();
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
bool L_18 = Type_op_Equality_m2683486427(NULL /*static, unused*/, L_17, (Type_t *)NULL, /*hidden argument*/NULL);
if (!L_18)
{
goto IL_00ad;
}
}
{
UnitySerializationHolder_ThrowInsufficientInformation_m1747464776(__this, _stringLiteral1313207612, /*hidden argument*/NULL);
}
IL_00ad:
{
MethodBase_t * L_19 = __this->get_m_declaringMethod_4();
bool L_20 = MethodBase_op_Inequality_m736913402(NULL /*static, unused*/, L_19, (MethodBase_t *)NULL, /*hidden argument*/NULL);
if (!L_20)
{
goto IL_00ce;
}
}
{
MethodBase_t * L_21 = __this->get_m_declaringMethod_4();
NullCheck(L_21);
TypeU5BU5D_t3940880105* L_22 = VirtFuncInvoker0< TypeU5BU5D_t3940880105* >::Invoke(23 /* System.Type[] System.Reflection.MethodBase::GetGenericArguments() */, L_21);
int32_t L_23 = __this->get_m_genericParameterPosition_2();
NullCheck(L_22);
int32_t L_24 = L_23;
Type_t * L_25 = (L_22)->GetAt(static_cast<il2cpp_array_size_t>(L_24));
return L_25;
}
IL_00ce:
{
Type_t * L_26 = __this->get_m_declaringType_3();
NullCheck(L_26);
TypeU5BU5D_t3940880105* L_27 = VirtFuncInvoker0< TypeU5BU5D_t3940880105* >::Invoke(102 /* System.Type[] System.Type::GetGenericArguments() */, L_26);
int32_t L_28 = __this->get_m_genericParameterPosition_2();
NullCheck(L_27);
int32_t L_29 = L_28;
Type_t * L_30 = (L_27)->GetAt(static_cast<il2cpp_array_size_t>(L_29));
Type_t * L_31 = UnitySerializationHolder_MakeElementTypes_m672301684(__this, L_30, /*hidden argument*/NULL);
return L_31;
}
IL_00e7:
{
String_t* L_32 = __this->get_m_data_5();
if (!L_32)
{
goto IL_00fc;
}
}
{
String_t* L_33 = __this->get_m_data_5();
NullCheck(L_33);
int32_t L_34 = String_get_Length_m3847582255(L_33, /*hidden argument*/NULL);
if (L_34)
{
goto IL_0107;
}
}
IL_00fc:
{
UnitySerializationHolder_ThrowInsufficientInformation_m1747464776(__this, _stringLiteral2037252898, /*hidden argument*/NULL);
}
IL_0107:
{
String_t* L_35 = __this->get_m_assemblyName_6();
if (L_35)
{
goto IL_011a;
}
}
{
UnitySerializationHolder_ThrowInsufficientInformation_m1747464776(__this, _stringLiteral209558951, /*hidden argument*/NULL);
}
IL_011a:
{
String_t* L_36 = __this->get_m_assemblyName_6();
NullCheck(L_36);
int32_t L_37 = String_get_Length_m3847582255(L_36, /*hidden argument*/NULL);
if (L_37)
{
goto IL_0135;
}
}
{
String_t* L_38 = __this->get_m_data_5();
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_39 = il2cpp_codegen_get_type((Il2CppMethodPointer)&Type_GetType_m3971160356, L_38, (bool)1, (bool)0, "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
return L_39;
}
IL_0135:
{
String_t* L_40 = __this->get_m_assemblyName_6();
Assembly_t * L_41 = Assembly_Load_m3487507613(NULL /*static, unused*/, L_40, /*hidden argument*/NULL);
String_t* L_42 = __this->get_m_data_5();
NullCheck(L_41);
Type_t * L_43 = VirtFuncInvoker3< Type_t *, String_t*, bool, bool >::Invoke(23 /* System.Type System.Reflection.Assembly::GetType(System.String,System.Boolean,System.Boolean) */, L_41, L_42, (bool)1, (bool)0);
return L_43;
}
IL_014e:
{
String_t* L_44 = __this->get_m_data_5();
if (!L_44)
{
goto IL_0163;
}
}
{
String_t* L_45 = __this->get_m_data_5();
NullCheck(L_45);
int32_t L_46 = String_get_Length_m3847582255(L_45, /*hidden argument*/NULL);
if (L_46)
{
goto IL_016e;
}
}
IL_0163:
{
UnitySerializationHolder_ThrowInsufficientInformation_m1747464776(__this, _stringLiteral2037252898, /*hidden argument*/NULL);
}
IL_016e:
{
String_t* L_47 = __this->get_m_assemblyName_6();
if (L_47)
{
goto IL_0181;
}
}
{
UnitySerializationHolder_ThrowInsufficientInformation_m1747464776(__this, _stringLiteral209558951, /*hidden argument*/NULL);
}
IL_0181:
{
String_t* L_48 = __this->get_m_assemblyName_6();
Assembly_t * L_49 = Assembly_Load_m3487507613(NULL /*static, unused*/, L_48, /*hidden argument*/NULL);
String_t* L_50 = __this->get_m_data_5();
NullCheck(L_49);
Module_t2987026101 * L_51 = VirtFuncInvoker1< Module_t2987026101 *, String_t* >::Invoke(24 /* System.Reflection.Module System.Reflection.Assembly::GetModule(System.String) */, L_49, L_50);
V_2 = L_51;
Module_t2987026101 * L_52 = V_2;
IL2CPP_RUNTIME_CLASS_INIT(Module_t2987026101_il2cpp_TypeInfo_var);
bool L_53 = Module_op_Equality_m1102431980(NULL /*static, unused*/, L_52, (Module_t2987026101 *)NULL, /*hidden argument*/NULL);
if (!L_53)
{
goto IL_01c9;
}
}
{
ObjectU5BU5D_t2843939325* L_54 = (ObjectU5BU5D_t2843939325*)SZArrayNew(ObjectU5BU5D_t2843939325_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t2843939325* L_55 = L_54;
String_t* L_56 = __this->get_m_data_5();
NullCheck(L_55);
ArrayElementTypeCheck (L_55, L_56);
(L_55)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)L_56);
ObjectU5BU5D_t2843939325* L_57 = L_55;
String_t* L_58 = __this->get_m_assemblyName_6();
NullCheck(L_57);
ArrayElementTypeCheck (L_57, L_58);
(L_57)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)L_58);
String_t* L_59 = Environment_GetResourceString_m479507158(NULL /*static, unused*/, _stringLiteral1498318814, L_57, /*hidden argument*/NULL);
SerializationException_t3941511869 * L_60 = (SerializationException_t3941511869 *)il2cpp_codegen_object_new(SerializationException_t3941511869_il2cpp_TypeInfo_var);
SerializationException__ctor_m3862484944(L_60, L_59, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_60, NULL, UnitySerializationHolder_GetRealObject_m1624354633_RuntimeMethod_var);
}
IL_01c9:
{
Module_t2987026101 * L_61 = V_2;
return L_61;
}
IL_01cb:
{
String_t* L_62 = __this->get_m_data_5();
if (!L_62)
{
goto IL_01e0;
}
}
{
String_t* L_63 = __this->get_m_data_5();
NullCheck(L_63);
int32_t L_64 = String_get_Length_m3847582255(L_63, /*hidden argument*/NULL);
if (L_64)
{
goto IL_01eb;
}
}
IL_01e0:
{
UnitySerializationHolder_ThrowInsufficientInformation_m1747464776(__this, _stringLiteral2037252898, /*hidden argument*/NULL);
}
IL_01eb:
{
String_t* L_65 = __this->get_m_assemblyName_6();
if (L_65)
{
goto IL_01fe;
}
}
{
UnitySerializationHolder_ThrowInsufficientInformation_m1747464776(__this, _stringLiteral209558951, /*hidden argument*/NULL);
}
IL_01fe:
{
String_t* L_66 = __this->get_m_assemblyName_6();
Assembly_t * L_67 = Assembly_Load_m3487507613(NULL /*static, unused*/, L_66, /*hidden argument*/NULL);
return L_67;
}
IL_020a:
{
String_t* L_68 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral3407159193, /*hidden argument*/NULL);
ArgumentException_t132251570 * L_69 = (ArgumentException_t132251570 *)il2cpp_codegen_object_new(ArgumentException_t132251570_il2cpp_TypeInfo_var);
ArgumentException__ctor_m1312628991(L_69, L_68, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_69, NULL, UnitySerializationHolder_GetRealObject_m1624354633_RuntimeMethod_var);
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Conversion methods for marshalling of: System.UnSafeCharBuffer
extern "C" void UnSafeCharBuffer_t2176740272_marshal_pinvoke(const UnSafeCharBuffer_t2176740272& unmarshaled, UnSafeCharBuffer_t2176740272_marshaled_pinvoke& marshaled)
{
marshaled.___m_buffer_0 = unmarshaled.get_m_buffer_0();
marshaled.___m_totalSize_1 = unmarshaled.get_m_totalSize_1();
marshaled.___m_length_2 = unmarshaled.get_m_length_2();
}
extern "C" void UnSafeCharBuffer_t2176740272_marshal_pinvoke_back(const UnSafeCharBuffer_t2176740272_marshaled_pinvoke& marshaled, UnSafeCharBuffer_t2176740272& unmarshaled)
{
unmarshaled.set_m_buffer_0(marshaled.___m_buffer_0);
int32_t unmarshaled_m_totalSize_temp_1 = 0;
unmarshaled_m_totalSize_temp_1 = marshaled.___m_totalSize_1;
unmarshaled.set_m_totalSize_1(unmarshaled_m_totalSize_temp_1);
int32_t unmarshaled_m_length_temp_2 = 0;
unmarshaled_m_length_temp_2 = marshaled.___m_length_2;
unmarshaled.set_m_length_2(unmarshaled_m_length_temp_2);
}
// Conversion method for clean up from marshalling of: System.UnSafeCharBuffer
extern "C" void UnSafeCharBuffer_t2176740272_marshal_pinvoke_cleanup(UnSafeCharBuffer_t2176740272_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: System.UnSafeCharBuffer
extern "C" void UnSafeCharBuffer_t2176740272_marshal_com(const UnSafeCharBuffer_t2176740272& unmarshaled, UnSafeCharBuffer_t2176740272_marshaled_com& marshaled)
{
marshaled.___m_buffer_0 = unmarshaled.get_m_buffer_0();
marshaled.___m_totalSize_1 = unmarshaled.get_m_totalSize_1();
marshaled.___m_length_2 = unmarshaled.get_m_length_2();
}
extern "C" void UnSafeCharBuffer_t2176740272_marshal_com_back(const UnSafeCharBuffer_t2176740272_marshaled_com& marshaled, UnSafeCharBuffer_t2176740272& unmarshaled)
{
unmarshaled.set_m_buffer_0(marshaled.___m_buffer_0);
int32_t unmarshaled_m_totalSize_temp_1 = 0;
unmarshaled_m_totalSize_temp_1 = marshaled.___m_totalSize_1;
unmarshaled.set_m_totalSize_1(unmarshaled_m_totalSize_temp_1);
int32_t unmarshaled_m_length_temp_2 = 0;
unmarshaled_m_length_temp_2 = marshaled.___m_length_2;
unmarshaled.set_m_length_2(unmarshaled_m_length_temp_2);
}
// Conversion method for clean up from marshalling of: System.UnSafeCharBuffer
extern "C" void UnSafeCharBuffer_t2176740272_marshal_com_cleanup(UnSafeCharBuffer_t2176740272_marshaled_com& marshaled)
{
}
// System.Void System.UnSafeCharBuffer::.ctor(System.Char*,System.Int32)
extern "C" void UnSafeCharBuffer__ctor_m1145239641 (UnSafeCharBuffer_t2176740272 * __this, Il2CppChar* ___buffer0, int32_t ___bufferSize1, const RuntimeMethod* method)
{
{
Il2CppChar* L_0 = ___buffer0;
__this->set_m_buffer_0((Il2CppChar*)L_0);
int32_t L_1 = ___bufferSize1;
__this->set_m_totalSize_1(L_1);
__this->set_m_length_2(0);
return;
}
}
extern "C" void UnSafeCharBuffer__ctor_m1145239641_AdjustorThunk (RuntimeObject * __this, Il2CppChar* ___buffer0, int32_t ___bufferSize1, const RuntimeMethod* method)
{
UnSafeCharBuffer_t2176740272 * _thisAdjusted = reinterpret_cast<UnSafeCharBuffer_t2176740272 *>(__this + 1);
UnSafeCharBuffer__ctor_m1145239641(_thisAdjusted, ___buffer0, ___bufferSize1, method);
}
// System.Void System.UnSafeCharBuffer::AppendString(System.String)
extern "C" void UnSafeCharBuffer_AppendString_m2223303597 (UnSafeCharBuffer_t2176740272 * __this, String_t* ___stringToAppend0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (UnSafeCharBuffer_AppendString_m2223303597_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Il2CppChar* V_0 = NULL;
String_t* V_1 = NULL;
{
String_t* L_0 = ___stringToAppend0;
bool L_1 = String_IsNullOrEmpty_m2969720369(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0009;
}
}
{
return;
}
IL_0009:
{
int32_t L_2 = __this->get_m_totalSize_1();
int32_t L_3 = __this->get_m_length_2();
String_t* L_4 = ___stringToAppend0;
NullCheck(L_4);
int32_t L_5 = String_get_Length_m3847582255(L_4, /*hidden argument*/NULL);
if ((((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_2, (int32_t)L_3))) >= ((int32_t)L_5)))
{
goto IL_0024;
}
}
{
IndexOutOfRangeException_t1578797820 * L_6 = (IndexOutOfRangeException_t1578797820 *)il2cpp_codegen_object_new(IndexOutOfRangeException_t1578797820_il2cpp_TypeInfo_var);
IndexOutOfRangeException__ctor_m2441337274(L_6, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6, NULL, UnSafeCharBuffer_AppendString_m2223303597_RuntimeMethod_var);
}
IL_0024:
{
String_t* L_7 = ___stringToAppend0;
V_1 = L_7;
String_t* L_8 = V_1;
V_0 = (Il2CppChar*)(((uintptr_t)L_8));
Il2CppChar* L_9 = V_0;
if (!L_9)
{
goto IL_0034;
}
}
{
Il2CppChar* L_10 = V_0;
int32_t L_11 = RuntimeHelpers_get_OffsetToStringData_m2192601476(NULL /*static, unused*/, /*hidden argument*/NULL);
V_0 = (Il2CppChar*)((Il2CppChar*)il2cpp_codegen_add((intptr_t)L_10, (int32_t)L_11));
}
IL_0034:
{
Il2CppChar* L_12 = __this->get_m_buffer_0();
int32_t L_13 = __this->get_m_length_2();
Il2CppChar* L_14 = V_0;
String_t* L_15 = ___stringToAppend0;
NullCheck(L_15);
int32_t L_16 = String_get_Length_m3847582255(L_15, /*hidden argument*/NULL);
Buffer_Memcpy_m2035854300(NULL /*static, unused*/, (uint8_t*)(uint8_t*)((Il2CppChar*)il2cpp_codegen_add((intptr_t)L_12, (intptr_t)((intptr_t)il2cpp_codegen_multiply((intptr_t)(((intptr_t)L_13)), (int32_t)2)))), (uint8_t*)(uint8_t*)L_14, ((int32_t)il2cpp_codegen_multiply((int32_t)L_16, (int32_t)2)), /*hidden argument*/NULL);
V_1 = (String_t*)NULL;
int32_t L_17 = __this->get_m_length_2();
String_t* L_18 = ___stringToAppend0;
NullCheck(L_18);
int32_t L_19 = String_get_Length_m3847582255(L_18, /*hidden argument*/NULL);
__this->set_m_length_2(((int32_t)il2cpp_codegen_add((int32_t)L_17, (int32_t)L_19)));
return;
}
}
extern "C" void UnSafeCharBuffer_AppendString_m2223303597_AdjustorThunk (RuntimeObject * __this, String_t* ___stringToAppend0, const RuntimeMethod* method)
{
UnSafeCharBuffer_t2176740272 * _thisAdjusted = reinterpret_cast<UnSafeCharBuffer_t2176740272 *>(__this + 1);
UnSafeCharBuffer_AppendString_m2223303597(_thisAdjusted, ___stringToAppend0, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Boolean System.ValueTuple::Equals(System.Object)
extern "C" bool ValueTuple_Equals_m3777586424 (ValueTuple_t3168505507 * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_Equals_m3777586424_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___obj0;
return (bool)((!(((RuntimeObject*)(RuntimeObject *)((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, ValueTuple_t3168505507_il2cpp_TypeInfo_var))) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0);
}
}
extern "C" bool ValueTuple_Equals_m3777586424_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
ValueTuple_t3168505507 * _thisAdjusted = reinterpret_cast<ValueTuple_t3168505507 *>(__this + 1);
return ValueTuple_Equals_m3777586424(_thisAdjusted, ___obj0, method);
}
// System.Boolean System.ValueTuple::Equals(System.ValueTuple)
extern "C" bool ValueTuple_Equals_m3868013840 (ValueTuple_t3168505507 * __this, ValueTuple_t3168505507 ___other0, const RuntimeMethod* method)
{
{
return (bool)1;
}
}
extern "C" bool ValueTuple_Equals_m3868013840_AdjustorThunk (RuntimeObject * __this, ValueTuple_t3168505507 ___other0, const RuntimeMethod* method)
{
ValueTuple_t3168505507 * _thisAdjusted = reinterpret_cast<ValueTuple_t3168505507 *>(__this + 1);
return ValueTuple_Equals_m3868013840(_thisAdjusted, ___other0, method);
}
// System.Boolean System.ValueTuple::System.Collections.IStructuralEquatable.Equals(System.Object,System.Collections.IEqualityComparer)
extern "C" bool ValueTuple_System_Collections_IStructuralEquatable_Equals_m1158377527 (ValueTuple_t3168505507 * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_System_Collections_IStructuralEquatable_Equals_m1158377527_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___other0;
return (bool)((!(((RuntimeObject*)(RuntimeObject *)((RuntimeObject *)IsInstSealed((RuntimeObject*)L_0, ValueTuple_t3168505507_il2cpp_TypeInfo_var))) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0);
}
}
extern "C" bool ValueTuple_System_Collections_IStructuralEquatable_Equals_m1158377527_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method)
{
ValueTuple_t3168505507 * _thisAdjusted = reinterpret_cast<ValueTuple_t3168505507 *>(__this + 1);
return ValueTuple_System_Collections_IStructuralEquatable_Equals_m1158377527(_thisAdjusted, ___other0, ___comparer1, method);
}
// System.Int32 System.ValueTuple::System.IComparable.CompareTo(System.Object)
extern "C" int32_t ValueTuple_System_IComparable_CompareTo_m3152321575 (ValueTuple_t3168505507 * __this, RuntimeObject * ___other0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_System_IComparable_CompareTo_m3152321575_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___other0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___other0;
if (((RuntimeObject *)IsInstSealed((RuntimeObject*)L_1, ValueTuple_t3168505507_il2cpp_TypeInfo_var)))
{
goto IL_0037;
}
}
{
ValueTuple_t3168505507 L_2 = (*(ValueTuple_t3168505507 *)__this);
RuntimeObject * L_3 = Box(ValueTuple_t3168505507_il2cpp_TypeInfo_var, &L_2);
NullCheck(L_3);
Type_t * L_4 = Object_GetType_m88164663(L_3, /*hidden argument*/NULL);
NullCheck(L_4);
String_t* L_5 = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, L_4);
String_t* L_6 = SR_Format_m1749913990(NULL /*static, unused*/, _stringLiteral4055290125, L_5, /*hidden argument*/NULL);
ArgumentException_t132251570 * L_7 = (ArgumentException_t132251570 *)il2cpp_codegen_object_new(ArgumentException_t132251570_il2cpp_TypeInfo_var);
ArgumentException__ctor_m1216717135(L_7, L_6, _stringLiteral2432405111, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_7, NULL, ValueTuple_System_IComparable_CompareTo_m3152321575_RuntimeMethod_var);
}
IL_0037:
{
return 0;
}
}
extern "C" int32_t ValueTuple_System_IComparable_CompareTo_m3152321575_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___other0, const RuntimeMethod* method)
{
ValueTuple_t3168505507 * _thisAdjusted = reinterpret_cast<ValueTuple_t3168505507 *>(__this + 1);
return ValueTuple_System_IComparable_CompareTo_m3152321575(_thisAdjusted, ___other0, method);
}
// System.Int32 System.ValueTuple::CompareTo(System.ValueTuple)
extern "C" int32_t ValueTuple_CompareTo_m2936302085 (ValueTuple_t3168505507 * __this, ValueTuple_t3168505507 ___other0, const RuntimeMethod* method)
{
{
return 0;
}
}
extern "C" int32_t ValueTuple_CompareTo_m2936302085_AdjustorThunk (RuntimeObject * __this, ValueTuple_t3168505507 ___other0, const RuntimeMethod* method)
{
ValueTuple_t3168505507 * _thisAdjusted = reinterpret_cast<ValueTuple_t3168505507 *>(__this + 1);
return ValueTuple_CompareTo_m2936302085(_thisAdjusted, ___other0, method);
}
// System.Int32 System.ValueTuple::System.Collections.IStructuralComparable.CompareTo(System.Object,System.Collections.IComparer)
extern "C" int32_t ValueTuple_System_Collections_IStructuralComparable_CompareTo_m1147772089 (ValueTuple_t3168505507 * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_System_Collections_IStructuralComparable_CompareTo_m1147772089_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
RuntimeObject * L_0 = ___other0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___other0;
if (((RuntimeObject *)IsInstSealed((RuntimeObject*)L_1, ValueTuple_t3168505507_il2cpp_TypeInfo_var)))
{
goto IL_0037;
}
}
{
ValueTuple_t3168505507 L_2 = (*(ValueTuple_t3168505507 *)__this);
RuntimeObject * L_3 = Box(ValueTuple_t3168505507_il2cpp_TypeInfo_var, &L_2);
NullCheck(L_3);
Type_t * L_4 = Object_GetType_m88164663(L_3, /*hidden argument*/NULL);
NullCheck(L_4);
String_t* L_5 = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, L_4);
String_t* L_6 = SR_Format_m1749913990(NULL /*static, unused*/, _stringLiteral4055290125, L_5, /*hidden argument*/NULL);
ArgumentException_t132251570 * L_7 = (ArgumentException_t132251570 *)il2cpp_codegen_object_new(ArgumentException_t132251570_il2cpp_TypeInfo_var);
ArgumentException__ctor_m1216717135(L_7, L_6, _stringLiteral2432405111, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_7, NULL, ValueTuple_System_Collections_IStructuralComparable_CompareTo_m1147772089_RuntimeMethod_var);
}
IL_0037:
{
return 0;
}
}
extern "C" int32_t ValueTuple_System_Collections_IStructuralComparable_CompareTo_m1147772089_AdjustorThunk (RuntimeObject * __this, RuntimeObject * ___other0, RuntimeObject* ___comparer1, const RuntimeMethod* method)
{
ValueTuple_t3168505507 * _thisAdjusted = reinterpret_cast<ValueTuple_t3168505507 *>(__this + 1);
return ValueTuple_System_Collections_IStructuralComparable_CompareTo_m1147772089(_thisAdjusted, ___other0, ___comparer1, method);
}
// System.Int32 System.ValueTuple::GetHashCode()
extern "C" int32_t ValueTuple_GetHashCode_m2158739460 (ValueTuple_t3168505507 * __this, const RuntimeMethod* method)
{
{
return 0;
}
}
extern "C" int32_t ValueTuple_GetHashCode_m2158739460_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
ValueTuple_t3168505507 * _thisAdjusted = reinterpret_cast<ValueTuple_t3168505507 *>(__this + 1);
return ValueTuple_GetHashCode_m2158739460(_thisAdjusted, method);
}
// System.Int32 System.ValueTuple::System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer)
extern "C" int32_t ValueTuple_System_Collections_IStructuralEquatable_GetHashCode_m3160204034 (ValueTuple_t3168505507 * __this, RuntimeObject* ___comparer0, const RuntimeMethod* method)
{
{
return 0;
}
}
extern "C" int32_t ValueTuple_System_Collections_IStructuralEquatable_GetHashCode_m3160204034_AdjustorThunk (RuntimeObject * __this, RuntimeObject* ___comparer0, const RuntimeMethod* method)
{
ValueTuple_t3168505507 * _thisAdjusted = reinterpret_cast<ValueTuple_t3168505507 *>(__this + 1);
return ValueTuple_System_Collections_IStructuralEquatable_GetHashCode_m3160204034(_thisAdjusted, ___comparer0, method);
}
// System.String System.ValueTuple::ToString()
extern "C" String_t* ValueTuple_ToString_m2213345710 (ValueTuple_t3168505507 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_ToString_m2213345710_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
return _stringLiteral3450976136;
}
}
extern "C" String_t* ValueTuple_ToString_m2213345710_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
ValueTuple_t3168505507 * _thisAdjusted = reinterpret_cast<ValueTuple_t3168505507 *>(__this + 1);
return ValueTuple_ToString_m2213345710(_thisAdjusted, method);
}
// System.Int32 System.ValueTuple::CombineHashCodes(System.Int32,System.Int32)
extern "C" int32_t ValueTuple_CombineHashCodes_m2782652282 (RuntimeObject * __this /* static, unused */, int32_t ___h10, int32_t ___h21, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueTuple_CombineHashCodes_m2782652282_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(HashHelpers_t1653534276_il2cpp_TypeInfo_var);
int32_t L_0 = ((HashHelpers_t1653534276_StaticFields*)il2cpp_codegen_static_fields_for(HashHelpers_t1653534276_il2cpp_TypeInfo_var))->get_RandomSeed_0();
int32_t L_1 = ___h10;
int32_t L_2 = HashHelpers_Combine_m3459330122(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
int32_t L_3 = ___h21;
int32_t L_4 = HashHelpers_Combine_m3459330122(NULL /*static, unused*/, L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Conversion methods for marshalling of: System.ValueType
extern "C" void ValueType_t3640485471_marshal_pinvoke(const ValueType_t3640485471& unmarshaled, ValueType_t3640485471_marshaled_pinvoke& marshaled)
{
}
extern "C" void ValueType_t3640485471_marshal_pinvoke_back(const ValueType_t3640485471_marshaled_pinvoke& marshaled, ValueType_t3640485471& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: System.ValueType
extern "C" void ValueType_t3640485471_marshal_pinvoke_cleanup(ValueType_t3640485471_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: System.ValueType
extern "C" void ValueType_t3640485471_marshal_com(const ValueType_t3640485471& unmarshaled, ValueType_t3640485471_marshaled_com& marshaled)
{
}
extern "C" void ValueType_t3640485471_marshal_com_back(const ValueType_t3640485471_marshaled_com& marshaled, ValueType_t3640485471& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: System.ValueType
extern "C" void ValueType_t3640485471_marshal_com_cleanup(ValueType_t3640485471_marshaled_com& marshaled)
{
}
// System.Void System.ValueType::.ctor()
extern "C" void ValueType__ctor_m2036258423 (RuntimeObject * __this, const RuntimeMethod* method)
{
{
Object__ctor_m297566312(__this, /*hidden argument*/NULL);
return;
}
}
// System.Boolean System.ValueType::InternalEquals(System.Object,System.Object,System.Object[]&)
extern "C" bool ValueType_InternalEquals_m1384040357 (RuntimeObject * __this /* static, unused */, RuntimeObject * ___o10, RuntimeObject * ___o21, ObjectU5BU5D_t2843939325** ___fields2, const RuntimeMethod* method)
{
typedef bool (*ValueType_InternalEquals_m1384040357_ftn) (RuntimeObject *, RuntimeObject *, ObjectU5BU5D_t2843939325**);
using namespace il2cpp::icalls;
return ((ValueType_InternalEquals_m1384040357_ftn)mscorlib::System::ValueType::InternalEquals) (___o10, ___o21, ___fields2);
}
// System.Boolean System.ValueType::DefaultEquals(System.Object,System.Object)
extern "C" bool ValueType_DefaultEquals_m2927252100 (RuntimeObject * __this /* static, unused */, RuntimeObject * ___o10, RuntimeObject * ___o21, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ValueType_DefaultEquals_m2927252100_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RuntimeType_t3636489352 * V_0 = NULL;
ObjectU5BU5D_t2843939325* V_1 = NULL;
bool V_2 = false;
int32_t V_3 = 0;
RuntimeObject * V_4 = NULL;
RuntimeObject * V_5 = NULL;
{
RuntimeObject * L_0 = ___o10;
if (L_0)
{
goto IL_0008;
}
}
{
RuntimeObject * L_1 = ___o21;
if (L_1)
{
goto IL_0008;
}
}
{
return (bool)1;
}
IL_0008:
{
RuntimeObject * L_2 = ___o10;
if (!L_2)
{
goto IL_000e;
}
}
{
RuntimeObject * L_3 = ___o21;
if (L_3)
{
goto IL_0010;
}
}
IL_000e:
{
return (bool)0;
}
IL_0010:
{
RuntimeObject * L_4 = ___o10;
NullCheck(L_4);
Type_t * L_5 = Object_GetType_m88164663(L_4, /*hidden argument*/NULL);
RuntimeObject * L_6 = ___o21;
NullCheck(L_6);
Type_t * L_7 = Object_GetType_m88164663(L_6, /*hidden argument*/NULL);
V_0 = ((RuntimeType_t3636489352 *)CastclassClass((RuntimeObject*)L_7, RuntimeType_t3636489352_il2cpp_TypeInfo_var));
RuntimeType_t3636489352 * L_8 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(RuntimeType_t3636489352_il2cpp_TypeInfo_var);
bool L_9 = RuntimeType_op_Inequality_m287584116(NULL /*static, unused*/, ((RuntimeType_t3636489352 *)CastclassClass((RuntimeObject*)L_5, RuntimeType_t3636489352_il2cpp_TypeInfo_var)), L_8, /*hidden argument*/NULL);
if (!L_9)
{
goto IL_0031;
}
}
{
return (bool)0;
}
IL_0031:
{
RuntimeObject * L_10 = ___o10;
RuntimeObject * L_11 = ___o21;
bool L_12 = ValueType_InternalEquals_m1384040357(NULL /*static, unused*/, L_10, L_11, (ObjectU5BU5D_t2843939325**)(&V_1), /*hidden argument*/NULL);
V_2 = L_12;
ObjectU5BU5D_t2843939325* L_13 = V_1;
if (L_13)
{
goto IL_0040;
}
}
{
bool L_14 = V_2;
return L_14;
}
IL_0040:
{
V_3 = 0;
goto IL_006b;
}
IL_0044:
{
ObjectU5BU5D_t2843939325* L_15 = V_1;
int32_t L_16 = V_3;
NullCheck(L_15);
int32_t L_17 = L_16;
RuntimeObject * L_18 = (L_15)->GetAt(static_cast<il2cpp_array_size_t>(L_17));
V_4 = L_18;
ObjectU5BU5D_t2843939325* L_19 = V_1;
int32_t L_20 = V_3;
NullCheck(L_19);
int32_t L_21 = ((int32_t)il2cpp_codegen_add((int32_t)L_20, (int32_t)1));
RuntimeObject * L_22 = (L_19)->GetAt(static_cast<il2cpp_array_size_t>(L_21));
V_5 = L_22;
RuntimeObject * L_23 = V_4;
if (L_23)
{
goto IL_005a;
}
}
{
RuntimeObject * L_24 = V_5;
if (!L_24)
{
goto IL_0067;
}
}
{
return (bool)0;
}
IL_005a:
{
RuntimeObject * L_25 = V_4;
RuntimeObject * L_26 = V_5;
NullCheck(L_25);
bool L_27 = VirtFuncInvoker1< bool, RuntimeObject * >::Invoke(0 /* System.Boolean System.Object::Equals(System.Object) */, L_25, L_26);
if (L_27)
{
goto IL_0067;
}
}
{
return (bool)0;
}
IL_0067:
{
int32_t L_28 = V_3;
V_3 = ((int32_t)il2cpp_codegen_add((int32_t)L_28, (int32_t)2));
}
IL_006b:
{
int32_t L_29 = V_3;
ObjectU5BU5D_t2843939325* L_30 = V_1;
NullCheck(L_30);
if ((((int32_t)L_29) < ((int32_t)(((int32_t)((int32_t)(((RuntimeArray *)L_30)->max_length)))))))
{
goto IL_0044;
}
}
{
return (bool)1;
}
}
// System.Boolean System.ValueType::Equals(System.Object)
extern "C" bool ValueType_Equals_m1524437845 (RuntimeObject * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = ___obj0;
bool L_1 = ValueType_DefaultEquals_m2927252100(NULL /*static, unused*/, __this, L_0, /*hidden argument*/NULL);
return L_1;
}
}
// System.Int32 System.ValueType::InternalGetHashCode(System.Object,System.Object[]&)
extern "C" int32_t ValueType_InternalGetHashCode_m58786863 (RuntimeObject * __this /* static, unused */, RuntimeObject * ___o0, ObjectU5BU5D_t2843939325** ___fields1, const RuntimeMethod* method)
{
typedef int32_t (*ValueType_InternalGetHashCode_m58786863_ftn) (RuntimeObject *, ObjectU5BU5D_t2843939325**);
using namespace il2cpp::icalls;
return ((ValueType_InternalGetHashCode_m58786863_ftn)mscorlib::System::ValueType::InternalGetHashCode) (___o0, ___fields1);
}
// System.Int32 System.ValueType::GetHashCode()
extern "C" int32_t ValueType_GetHashCode_m715362416 (RuntimeObject * __this, const RuntimeMethod* method)
{
ObjectU5BU5D_t2843939325* V_0 = NULL;
int32_t V_1 = 0;
int32_t V_2 = 0;
{
int32_t L_0 = ValueType_InternalGetHashCode_m58786863(NULL /*static, unused*/, __this, (ObjectU5BU5D_t2843939325**)(&V_0), /*hidden argument*/NULL);
V_1 = L_0;
ObjectU5BU5D_t2843939325* L_1 = V_0;
if (!L_1)
{
goto IL_002a;
}
}
{
V_2 = 0;
goto IL_0024;
}
IL_0010:
{
ObjectU5BU5D_t2843939325* L_2 = V_0;
int32_t L_3 = V_2;
NullCheck(L_2);
int32_t L_4 = L_3;
RuntimeObject * L_5 = (L_2)->GetAt(static_cast<il2cpp_array_size_t>(L_4));
if (!L_5)
{
goto IL_0020;
}
}
{
int32_t L_6 = V_1;
ObjectU5BU5D_t2843939325* L_7 = V_0;
int32_t L_8 = V_2;
NullCheck(L_7);
int32_t L_9 = L_8;
RuntimeObject * L_10 = (L_7)->GetAt(static_cast<il2cpp_array_size_t>(L_9));
NullCheck(L_10);
int32_t L_11 = VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, L_10);
V_1 = ((int32_t)((int32_t)L_6^(int32_t)L_11));
}
IL_0020:
{
int32_t L_12 = V_2;
V_2 = ((int32_t)il2cpp_codegen_add((int32_t)L_12, (int32_t)1));
}
IL_0024:
{
int32_t L_13 = V_2;
ObjectU5BU5D_t2843939325* L_14 = V_0;
NullCheck(L_14);
if ((((int32_t)L_13) < ((int32_t)(((int32_t)((int32_t)(((RuntimeArray *)L_14)->max_length)))))))
{
goto IL_0010;
}
}
IL_002a:
{
int32_t L_15 = V_1;
return L_15;
}
}
// System.String System.ValueType::ToString()
extern "C" String_t* ValueType_ToString_m2292123621 (RuntimeObject * __this, const RuntimeMethod* method)
{
{
Type_t * L_0 = Object_GetType_m88164663(__this, /*hidden argument*/NULL);
NullCheck(L_0);
String_t* L_1 = VirtFuncInvoker0< String_t* >::Invoke(26 /* System.String System.Type::get_FullName() */, L_0);
return L_1;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Variant::Clear()
extern "C" void Variant_Clear_m3388694274 (Variant_t2753289927 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Variant_Clear_m3388694274_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int16_t L_0 = __this->get_vt_0();
if ((!(((uint32_t)L_0) == ((uint32_t)8))))
{
goto IL_0015;
}
}
{
intptr_t L_1 = __this->get_bstrVal_11();
IL2CPP_RUNTIME_CLASS_INIT(Marshal_t1757017490_il2cpp_TypeInfo_var);
Marshal_FreeBSTR_m2788901813(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
return;
}
IL_0015:
{
int16_t L_2 = __this->get_vt_0();
if ((((int32_t)L_2) == ((int32_t)((int32_t)9))))
{
goto IL_0029;
}
}
{
int16_t L_3 = __this->get_vt_0();
if ((!(((uint32_t)L_3) == ((uint32_t)((int32_t)13)))))
{
goto IL_0047;
}
}
IL_0029:
{
intptr_t L_4 = __this->get_pdispVal_18();
bool L_5 = IntPtr_op_Inequality_m3063970704(NULL /*static, unused*/, L_4, (intptr_t)(0), /*hidden argument*/NULL);
if (!L_5)
{
goto IL_0047;
}
}
{
intptr_t L_6 = __this->get_pdispVal_18();
IL2CPP_RUNTIME_CLASS_INIT(Marshal_t1757017490_il2cpp_TypeInfo_var);
Marshal_Release_m3880542832(NULL /*static, unused*/, L_6, /*hidden argument*/NULL);
}
IL_0047:
{
return;
}
}
extern "C" void Variant_Clear_m3388694274_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
Variant_t2753289927 * _thisAdjusted = reinterpret_cast<Variant_t2753289927 *>(__this + 1);
Variant_Clear_m3388694274(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Version::.ctor(System.Int32,System.Int32,System.Int32,System.Int32)
extern "C" void Version__ctor_m417728625 (Version_t3456873960 * __this, int32_t ___major0, int32_t ___minor1, int32_t ___build2, int32_t ___revision3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version__ctor_m417728625_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
__this->set__Build_2((-1));
__this->set__Revision_3((-1));
Object__ctor_m297566312(__this, /*hidden argument*/NULL);
int32_t L_0 = ___major0;
if ((((int32_t)L_0) >= ((int32_t)0)))
{
goto IL_002d;
}
}
{
String_t* L_1 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral2448690427, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t777629997 * L_2 = (ArgumentOutOfRangeException_t777629997 *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t777629997_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m282481429(L_2, _stringLiteral419133523, L_1, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, NULL, Version__ctor_m417728625_RuntimeMethod_var);
}
IL_002d:
{
int32_t L_3 = ___minor1;
if ((((int32_t)L_3) >= ((int32_t)0)))
{
goto IL_0046;
}
}
{
String_t* L_4 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral2448690427, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t777629997 * L_5 = (ArgumentOutOfRangeException_t777629997 *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t777629997_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m282481429(L_5, _stringLiteral2762033855, L_4, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, Version__ctor_m417728625_RuntimeMethod_var);
}
IL_0046:
{
int32_t L_6 = ___build2;
if ((((int32_t)L_6) >= ((int32_t)0)))
{
goto IL_005f;
}
}
{
String_t* L_7 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral2448690427, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t777629997 * L_8 = (ArgumentOutOfRangeException_t777629997 *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t777629997_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m282481429(L_8, _stringLiteral437191301, L_7, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_8, NULL, Version__ctor_m417728625_RuntimeMethod_var);
}
IL_005f:
{
int32_t L_9 = ___revision3;
if ((((int32_t)L_9) >= ((int32_t)0)))
{
goto IL_0079;
}
}
{
String_t* L_10 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral2448690427, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t777629997 * L_11 = (ArgumentOutOfRangeException_t777629997 *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t777629997_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m282481429(L_11, _stringLiteral3187820736, L_10, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_11, NULL, Version__ctor_m417728625_RuntimeMethod_var);
}
IL_0079:
{
int32_t L_12 = ___major0;
__this->set__Major_0(L_12);
int32_t L_13 = ___minor1;
__this->set__Minor_1(L_13);
int32_t L_14 = ___build2;
__this->set__Build_2(L_14);
int32_t L_15 = ___revision3;
__this->set__Revision_3(L_15);
return;
}
}
// System.Void System.Version::.ctor(System.Int32,System.Int32)
extern "C" void Version__ctor_m3537335798 (Version_t3456873960 * __this, int32_t ___major0, int32_t ___minor1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version__ctor_m3537335798_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
__this->set__Build_2((-1));
__this->set__Revision_3((-1));
Object__ctor_m297566312(__this, /*hidden argument*/NULL);
int32_t L_0 = ___major0;
if ((((int32_t)L_0) >= ((int32_t)0)))
{
goto IL_002d;
}
}
{
String_t* L_1 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral2448690427, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t777629997 * L_2 = (ArgumentOutOfRangeException_t777629997 *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t777629997_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m282481429(L_2, _stringLiteral419133523, L_1, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, NULL, Version__ctor_m3537335798_RuntimeMethod_var);
}
IL_002d:
{
int32_t L_3 = ___minor1;
if ((((int32_t)L_3) >= ((int32_t)0)))
{
goto IL_0046;
}
}
{
String_t* L_4 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral2448690427, /*hidden argument*/NULL);
ArgumentOutOfRangeException_t777629997 * L_5 = (ArgumentOutOfRangeException_t777629997 *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t777629997_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m282481429(L_5, _stringLiteral2762033855, L_4, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, Version__ctor_m3537335798_RuntimeMethod_var);
}
IL_0046:
{
int32_t L_6 = ___major0;
__this->set__Major_0(L_6);
int32_t L_7 = ___minor1;
__this->set__Minor_1(L_7);
return;
}
}
// System.Void System.Version::.ctor()
extern "C" void Version__ctor_m872301635 (Version_t3456873960 * __this, const RuntimeMethod* method)
{
{
__this->set__Build_2((-1));
__this->set__Revision_3((-1));
Object__ctor_m297566312(__this, /*hidden argument*/NULL);
__this->set__Major_0(0);
__this->set__Minor_1(0);
return;
}
}
// System.Int32 System.Version::get_Major()
extern "C" int32_t Version_get_Major_m2457928275 (Version_t3456873960 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Major_0();
return L_0;
}
}
// System.Int32 System.Version::get_Minor()
extern "C" int32_t Version_get_Minor_m150536655 (Version_t3456873960 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Minor_1();
return L_0;
}
}
// System.Int32 System.Version::get_Build()
extern "C" int32_t Version_get_Build_m3667751407 (Version_t3456873960 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Build_2();
return L_0;
}
}
// System.Int32 System.Version::get_Revision()
extern "C" int32_t Version_get_Revision_m3982234017 (Version_t3456873960 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Revision_3();
return L_0;
}
}
// System.Object System.Version::Clone()
extern "C" RuntimeObject * Version_Clone_m1749041863 (Version_t3456873960 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_Clone_m1749041863_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_t3456873960 * L_0 = (Version_t3456873960 *)il2cpp_codegen_object_new(Version_t3456873960_il2cpp_TypeInfo_var);
Version__ctor_m872301635(L_0, /*hidden argument*/NULL);
Version_t3456873960 * L_1 = L_0;
int32_t L_2 = __this->get__Major_0();
NullCheck(L_1);
L_1->set__Major_0(L_2);
Version_t3456873960 * L_3 = L_1;
int32_t L_4 = __this->get__Minor_1();
NullCheck(L_3);
L_3->set__Minor_1(L_4);
Version_t3456873960 * L_5 = L_3;
int32_t L_6 = __this->get__Build_2();
NullCheck(L_5);
L_5->set__Build_2(L_6);
Version_t3456873960 * L_7 = L_5;
int32_t L_8 = __this->get__Revision_3();
NullCheck(L_7);
L_7->set__Revision_3(L_8);
return L_7;
}
}
// System.Int32 System.Version::CompareTo(System.Object)
extern "C" int32_t Version_CompareTo_m1662919407 (Version_t3456873960 * __this, RuntimeObject * ___version0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_CompareTo_m1662919407_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Version_t3456873960 * V_0 = NULL;
{
RuntimeObject * L_0 = ___version0;
if (L_0)
{
goto IL_0005;
}
}
{
return 1;
}
IL_0005:
{
RuntimeObject * L_1 = ___version0;
V_0 = ((Version_t3456873960 *)IsInstSealed((RuntimeObject*)L_1, Version_t3456873960_il2cpp_TypeInfo_var));
Version_t3456873960 * L_2 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_t3456873960_il2cpp_TypeInfo_var);
bool L_3 = Version_op_Equality_m3804852517(NULL /*static, unused*/, L_2, (Version_t3456873960 *)NULL, /*hidden argument*/NULL);
if (!L_3)
{
goto IL_0025;
}
}
{
String_t* L_4 = Environment_GetResourceString_m2063689938(NULL /*static, unused*/, _stringLiteral1182144617, /*hidden argument*/NULL);
ArgumentException_t132251570 * L_5 = (ArgumentException_t132251570 *)il2cpp_codegen_object_new(ArgumentException_t132251570_il2cpp_TypeInfo_var);
ArgumentException__ctor_m1312628991(L_5, L_4, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, Version_CompareTo_m1662919407_RuntimeMethod_var);
}
IL_0025:
{
int32_t L_6 = __this->get__Major_0();
Version_t3456873960 * L_7 = V_0;
NullCheck(L_7);
int32_t L_8 = L_7->get__Major_0();
if ((((int32_t)L_6) == ((int32_t)L_8)))
{
goto IL_0045;
}
}
{
int32_t L_9 = __this->get__Major_0();
Version_t3456873960 * L_10 = V_0;
NullCheck(L_10);
int32_t L_11 = L_10->get__Major_0();
if ((((int32_t)L_9) <= ((int32_t)L_11)))
{
goto IL_0043;
}
}
{
return 1;
}
IL_0043:
{
return (-1);
}
IL_0045:
{
int32_t L_12 = __this->get__Minor_1();
Version_t3456873960 * L_13 = V_0;
NullCheck(L_13);
int32_t L_14 = L_13->get__Minor_1();
if ((((int32_t)L_12) == ((int32_t)L_14)))
{
goto IL_0065;
}
}
{
int32_t L_15 = __this->get__Minor_1();
Version_t3456873960 * L_16 = V_0;
NullCheck(L_16);
int32_t L_17 = L_16->get__Minor_1();
if ((((int32_t)L_15) <= ((int32_t)L_17)))
{
goto IL_0063;
}
}
{
return 1;
}
IL_0063:
{
return (-1);
}
IL_0065:
{
int32_t L_18 = __this->get__Build_2();
Version_t3456873960 * L_19 = V_0;
NullCheck(L_19);
int32_t L_20 = L_19->get__Build_2();
if ((((int32_t)L_18) == ((int32_t)L_20)))
{
goto IL_0085;
}
}
{
int32_t L_21 = __this->get__Build_2();
Version_t3456873960 * L_22 = V_0;
NullCheck(L_22);
int32_t L_23 = L_22->get__Build_2();
if ((((int32_t)L_21) <= ((int32_t)L_23)))
{
goto IL_0083;
}
}
{
return 1;
}
IL_0083:
{
return (-1);
}
IL_0085:
{
int32_t L_24 = __this->get__Revision_3();
Version_t3456873960 * L_25 = V_0;
NullCheck(L_25);
int32_t L_26 = L_25->get__Revision_3();
if ((((int32_t)L_24) == ((int32_t)L_26)))
{
goto IL_00a5;
}
}
{
int32_t L_27 = __this->get__Revision_3();
Version_t3456873960 * L_28 = V_0;
NullCheck(L_28);
int32_t L_29 = L_28->get__Revision_3();
if ((((int32_t)L_27) <= ((int32_t)L_29)))
{
goto IL_00a3;
}
}
{
return 1;
}
IL_00a3:
{
return (-1);
}
IL_00a5:
{
return 0;
}
}
// System.Int32 System.Version::CompareTo(System.Version)
extern "C" int32_t Version_CompareTo_m3146217210 (Version_t3456873960 * __this, Version_t3456873960 * ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_CompareTo_m3146217210_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_t3456873960 * L_0 = ___value0;
IL2CPP_RUNTIME_CLASS_INIT(Version_t3456873960_il2cpp_TypeInfo_var);
bool L_1 = Version_op_Equality_m3804852517(NULL /*static, unused*/, L_0, (Version_t3456873960 *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_000b;
}
}
{
return 1;
}
IL_000b:
{
int32_t L_2 = __this->get__Major_0();
Version_t3456873960 * L_3 = ___value0;
NullCheck(L_3);
int32_t L_4 = L_3->get__Major_0();
if ((((int32_t)L_2) == ((int32_t)L_4)))
{
goto IL_002b;
}
}
{
int32_t L_5 = __this->get__Major_0();
Version_t3456873960 * L_6 = ___value0;
NullCheck(L_6);
int32_t L_7 = L_6->get__Major_0();
if ((((int32_t)L_5) <= ((int32_t)L_7)))
{
goto IL_0029;
}
}
{
return 1;
}
IL_0029:
{
return (-1);
}
IL_002b:
{
int32_t L_8 = __this->get__Minor_1();
Version_t3456873960 * L_9 = ___value0;
NullCheck(L_9);
int32_t L_10 = L_9->get__Minor_1();
if ((((int32_t)L_8) == ((int32_t)L_10)))
{
goto IL_004b;
}
}
{
int32_t L_11 = __this->get__Minor_1();
Version_t3456873960 * L_12 = ___value0;
NullCheck(L_12);
int32_t L_13 = L_12->get__Minor_1();
if ((((int32_t)L_11) <= ((int32_t)L_13)))
{
goto IL_0049;
}
}
{
return 1;
}
IL_0049:
{
return (-1);
}
IL_004b:
{
int32_t L_14 = __this->get__Build_2();
Version_t3456873960 * L_15 = ___value0;
NullCheck(L_15);
int32_t L_16 = L_15->get__Build_2();
if ((((int32_t)L_14) == ((int32_t)L_16)))
{
goto IL_006b;
}
}
{
int32_t L_17 = __this->get__Build_2();
Version_t3456873960 * L_18 = ___value0;
NullCheck(L_18);
int32_t L_19 = L_18->get__Build_2();
if ((((int32_t)L_17) <= ((int32_t)L_19)))
{
goto IL_0069;
}
}
{
return 1;
}
IL_0069:
{
return (-1);
}
IL_006b:
{
int32_t L_20 = __this->get__Revision_3();
Version_t3456873960 * L_21 = ___value0;
NullCheck(L_21);
int32_t L_22 = L_21->get__Revision_3();
if ((((int32_t)L_20) == ((int32_t)L_22)))
{
goto IL_008b;
}
}
{
int32_t L_23 = __this->get__Revision_3();
Version_t3456873960 * L_24 = ___value0;
NullCheck(L_24);
int32_t L_25 = L_24->get__Revision_3();
if ((((int32_t)L_23) <= ((int32_t)L_25)))
{
goto IL_0089;
}
}
{
return 1;
}
IL_0089:
{
return (-1);
}
IL_008b:
{
return 0;
}
}
// System.Boolean System.Version::Equals(System.Object)
extern "C" bool Version_Equals_m3073813696 (Version_t3456873960 * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_Equals_m3073813696_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Version_t3456873960 * V_0 = NULL;
{
RuntimeObject * L_0 = ___obj0;
V_0 = ((Version_t3456873960 *)IsInstSealed((RuntimeObject*)L_0, Version_t3456873960_il2cpp_TypeInfo_var));
Version_t3456873960 * L_1 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_t3456873960_il2cpp_TypeInfo_var);
bool L_2 = Version_op_Equality_m3804852517(NULL /*static, unused*/, L_1, (Version_t3456873960 *)NULL, /*hidden argument*/NULL);
if (!L_2)
{
goto IL_0012;
}
}
{
return (bool)0;
}
IL_0012:
{
int32_t L_3 = __this->get__Major_0();
Version_t3456873960 * L_4 = V_0;
NullCheck(L_4);
int32_t L_5 = L_4->get__Major_0();
if ((!(((uint32_t)L_3) == ((uint32_t)L_5))))
{
goto IL_004a;
}
}
{
int32_t L_6 = __this->get__Minor_1();
Version_t3456873960 * L_7 = V_0;
NullCheck(L_7);
int32_t L_8 = L_7->get__Minor_1();
if ((!(((uint32_t)L_6) == ((uint32_t)L_8))))
{
goto IL_004a;
}
}
{
int32_t L_9 = __this->get__Build_2();
Version_t3456873960 * L_10 = V_0;
NullCheck(L_10);
int32_t L_11 = L_10->get__Build_2();
if ((!(((uint32_t)L_9) == ((uint32_t)L_11))))
{
goto IL_004a;
}
}
{
int32_t L_12 = __this->get__Revision_3();
Version_t3456873960 * L_13 = V_0;
NullCheck(L_13);
int32_t L_14 = L_13->get__Revision_3();
if ((((int32_t)L_12) == ((int32_t)L_14)))
{
goto IL_004c;
}
}
IL_004a:
{
return (bool)0;
}
IL_004c:
{
return (bool)1;
}
}
// System.Boolean System.Version::Equals(System.Version)
extern "C" bool Version_Equals_m1564427710 (Version_t3456873960 * __this, Version_t3456873960 * ___obj0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_Equals_m1564427710_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_t3456873960 * L_0 = ___obj0;
IL2CPP_RUNTIME_CLASS_INIT(Version_t3456873960_il2cpp_TypeInfo_var);
bool L_1 = Version_op_Equality_m3804852517(NULL /*static, unused*/, L_0, (Version_t3456873960 *)NULL, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_000b;
}
}
{
return (bool)0;
}
IL_000b:
{
int32_t L_2 = __this->get__Major_0();
Version_t3456873960 * L_3 = ___obj0;
NullCheck(L_3);
int32_t L_4 = L_3->get__Major_0();
if ((!(((uint32_t)L_2) == ((uint32_t)L_4))))
{
goto IL_0043;
}
}
{
int32_t L_5 = __this->get__Minor_1();
Version_t3456873960 * L_6 = ___obj0;
NullCheck(L_6);
int32_t L_7 = L_6->get__Minor_1();
if ((!(((uint32_t)L_5) == ((uint32_t)L_7))))
{
goto IL_0043;
}
}
{
int32_t L_8 = __this->get__Build_2();
Version_t3456873960 * L_9 = ___obj0;
NullCheck(L_9);
int32_t L_10 = L_9->get__Build_2();
if ((!(((uint32_t)L_8) == ((uint32_t)L_10))))
{
goto IL_0043;
}
}
{
int32_t L_11 = __this->get__Revision_3();
Version_t3456873960 * L_12 = ___obj0;
NullCheck(L_12);
int32_t L_13 = L_12->get__Revision_3();
if ((((int32_t)L_11) == ((int32_t)L_13)))
{
goto IL_0045;
}
}
IL_0043:
{
return (bool)0;
}
IL_0045:
{
return (bool)1;
}
}
// System.Int32 System.Version::GetHashCode()
extern "C" int32_t Version_GetHashCode_m672974201 (Version_t3456873960 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Major_0();
int32_t L_1 = __this->get__Minor_1();
int32_t L_2 = __this->get__Build_2();
int32_t L_3 = __this->get__Revision_3();
return ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)0|(int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_0&(int32_t)((int32_t)15)))<<(int32_t)((int32_t)28)))))|(int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_1&(int32_t)((int32_t)255)))<<(int32_t)((int32_t)20)))))|(int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_2&(int32_t)((int32_t)255)))<<(int32_t)((int32_t)12)))))|(int32_t)((int32_t)((int32_t)L_3&(int32_t)((int32_t)4095)))));
}
}
// System.String System.Version::ToString()
extern "C" String_t* Version_ToString_m2279867705 (Version_t3456873960 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get__Build_2();
if ((!(((uint32_t)L_0) == ((uint32_t)(-1)))))
{
goto IL_0011;
}
}
{
String_t* L_1 = Version_ToString_m3654989516(__this, 2, /*hidden argument*/NULL);
return L_1;
}
IL_0011:
{
int32_t L_2 = __this->get__Revision_3();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0022;
}
}
{
String_t* L_3 = Version_ToString_m3654989516(__this, 3, /*hidden argument*/NULL);
return L_3;
}
IL_0022:
{
String_t* L_4 = Version_ToString_m3654989516(__this, 4, /*hidden argument*/NULL);
return L_4;
}
}
// System.String System.Version::ToString(System.Int32)
extern "C" String_t* Version_ToString_m3654989516 (Version_t3456873960 * __this, int32_t ___fieldCount0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_ToString_m3654989516_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
StringBuilder_t * V_0 = NULL;
{
int32_t L_0 = ___fieldCount0;
switch (L_0)
{
case 0:
{
goto IL_0014;
}
case 1:
{
goto IL_001a;
}
case 2:
{
goto IL_0026;
}
}
}
{
goto IL_0056;
}
IL_0014:
{
String_t* L_1 = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
return L_1;
}
IL_001a:
{
int32_t* L_2 = __this->get_address_of__Major_0();
String_t* L_3 = Int32_ToString_m141394615((int32_t*)L_2, /*hidden argument*/NULL);
return L_3;
}
IL_0026:
{
StringBuilder_t * L_4 = StringBuilderCache_Acquire_m4169564332(NULL /*static, unused*/, ((int32_t)16), /*hidden argument*/NULL);
V_0 = L_4;
int32_t L_5 = __this->get__Major_0();
StringBuilder_t * L_6 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_t3456873960_il2cpp_TypeInfo_var);
Version_AppendPositiveNumber_m308762805(NULL /*static, unused*/, L_5, L_6, /*hidden argument*/NULL);
StringBuilder_t * L_7 = V_0;
NullCheck(L_7);
StringBuilder_Append_m2383614642(L_7, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_8 = __this->get__Minor_1();
StringBuilder_t * L_9 = V_0;
Version_AppendPositiveNumber_m308762805(NULL /*static, unused*/, L_8, L_9, /*hidden argument*/NULL);
StringBuilder_t * L_10 = V_0;
String_t* L_11 = StringBuilderCache_GetStringAndRelease_m1110745745(NULL /*static, unused*/, L_10, /*hidden argument*/NULL);
return L_11;
}
IL_0056:
{
int32_t L_12 = __this->get__Build_2();
if ((!(((uint32_t)L_12) == ((uint32_t)(-1)))))
{
goto IL_008a;
}
}
{
ObjectU5BU5D_t2843939325* L_13 = (ObjectU5BU5D_t2843939325*)SZArrayNew(ObjectU5BU5D_t2843939325_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t2843939325* L_14 = L_13;
NullCheck(L_14);
ArrayElementTypeCheck (L_14, _stringLiteral3452614544);
(L_14)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteral3452614544);
ObjectU5BU5D_t2843939325* L_15 = L_14;
NullCheck(L_15);
ArrayElementTypeCheck (L_15, _stringLiteral3452614542);
(L_15)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteral3452614542);
String_t* L_16 = Environment_GetResourceString_m479507158(NULL /*static, unused*/, _stringLiteral3104458722, L_15, /*hidden argument*/NULL);
ArgumentException_t132251570 * L_17 = (ArgumentException_t132251570 *)il2cpp_codegen_object_new(ArgumentException_t132251570_il2cpp_TypeInfo_var);
ArgumentException__ctor_m1216717135(L_17, L_16, _stringLiteral3976682977, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_17, NULL, Version_ToString_m3654989516_RuntimeMethod_var);
}
IL_008a:
{
int32_t L_18 = ___fieldCount0;
if ((!(((uint32_t)L_18) == ((uint32_t)3))))
{
goto IL_00d3;
}
}
{
StringBuilder_t * L_19 = StringBuilderCache_Acquire_m4169564332(NULL /*static, unused*/, ((int32_t)16), /*hidden argument*/NULL);
V_0 = L_19;
int32_t L_20 = __this->get__Major_0();
StringBuilder_t * L_21 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_t3456873960_il2cpp_TypeInfo_var);
Version_AppendPositiveNumber_m308762805(NULL /*static, unused*/, L_20, L_21, /*hidden argument*/NULL);
StringBuilder_t * L_22 = V_0;
NullCheck(L_22);
StringBuilder_Append_m2383614642(L_22, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_23 = __this->get__Minor_1();
StringBuilder_t * L_24 = V_0;
Version_AppendPositiveNumber_m308762805(NULL /*static, unused*/, L_23, L_24, /*hidden argument*/NULL);
StringBuilder_t * L_25 = V_0;
NullCheck(L_25);
StringBuilder_Append_m2383614642(L_25, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_26 = __this->get__Build_2();
StringBuilder_t * L_27 = V_0;
Version_AppendPositiveNumber_m308762805(NULL /*static, unused*/, L_26, L_27, /*hidden argument*/NULL);
StringBuilder_t * L_28 = V_0;
String_t* L_29 = StringBuilderCache_GetStringAndRelease_m1110745745(NULL /*static, unused*/, L_28, /*hidden argument*/NULL);
return L_29;
}
IL_00d3:
{
int32_t L_30 = __this->get__Revision_3();
if ((!(((uint32_t)L_30) == ((uint32_t)(-1)))))
{
goto IL_0107;
}
}
{
ObjectU5BU5D_t2843939325* L_31 = (ObjectU5BU5D_t2843939325*)SZArrayNew(ObjectU5BU5D_t2843939325_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t2843939325* L_32 = L_31;
NullCheck(L_32);
ArrayElementTypeCheck (L_32, _stringLiteral3452614544);
(L_32)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteral3452614544);
ObjectU5BU5D_t2843939325* L_33 = L_32;
NullCheck(L_33);
ArrayElementTypeCheck (L_33, _stringLiteral3452614541);
(L_33)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteral3452614541);
String_t* L_34 = Environment_GetResourceString_m479507158(NULL /*static, unused*/, _stringLiteral3104458722, L_33, /*hidden argument*/NULL);
ArgumentException_t132251570 * L_35 = (ArgumentException_t132251570 *)il2cpp_codegen_object_new(ArgumentException_t132251570_il2cpp_TypeInfo_var);
ArgumentException__ctor_m1216717135(L_35, L_34, _stringLiteral3976682977, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_35, NULL, Version_ToString_m3654989516_RuntimeMethod_var);
}
IL_0107:
{
int32_t L_36 = ___fieldCount0;
if ((!(((uint32_t)L_36) == ((uint32_t)4))))
{
goto IL_0165;
}
}
{
StringBuilder_t * L_37 = StringBuilderCache_Acquire_m4169564332(NULL /*static, unused*/, ((int32_t)16), /*hidden argument*/NULL);
V_0 = L_37;
int32_t L_38 = __this->get__Major_0();
StringBuilder_t * L_39 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Version_t3456873960_il2cpp_TypeInfo_var);
Version_AppendPositiveNumber_m308762805(NULL /*static, unused*/, L_38, L_39, /*hidden argument*/NULL);
StringBuilder_t * L_40 = V_0;
NullCheck(L_40);
StringBuilder_Append_m2383614642(L_40, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_41 = __this->get__Minor_1();
StringBuilder_t * L_42 = V_0;
Version_AppendPositiveNumber_m308762805(NULL /*static, unused*/, L_41, L_42, /*hidden argument*/NULL);
StringBuilder_t * L_43 = V_0;
NullCheck(L_43);
StringBuilder_Append_m2383614642(L_43, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_44 = __this->get__Build_2();
StringBuilder_t * L_45 = V_0;
Version_AppendPositiveNumber_m308762805(NULL /*static, unused*/, L_44, L_45, /*hidden argument*/NULL);
StringBuilder_t * L_46 = V_0;
NullCheck(L_46);
StringBuilder_Append_m2383614642(L_46, ((int32_t)46), /*hidden argument*/NULL);
int32_t L_47 = __this->get__Revision_3();
StringBuilder_t * L_48 = V_0;
Version_AppendPositiveNumber_m308762805(NULL /*static, unused*/, L_47, L_48, /*hidden argument*/NULL);
StringBuilder_t * L_49 = V_0;
String_t* L_50 = StringBuilderCache_GetStringAndRelease_m1110745745(NULL /*static, unused*/, L_49, /*hidden argument*/NULL);
return L_50;
}
IL_0165:
{
ObjectU5BU5D_t2843939325* L_51 = (ObjectU5BU5D_t2843939325*)SZArrayNew(ObjectU5BU5D_t2843939325_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t2843939325* L_52 = L_51;
NullCheck(L_52);
ArrayElementTypeCheck (L_52, _stringLiteral3452614544);
(L_52)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)_stringLiteral3452614544);
ObjectU5BU5D_t2843939325* L_53 = L_52;
NullCheck(L_53);
ArrayElementTypeCheck (L_53, _stringLiteral3452614540);
(L_53)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)_stringLiteral3452614540);
String_t* L_54 = Environment_GetResourceString_m479507158(NULL /*static, unused*/, _stringLiteral3104458722, L_53, /*hidden argument*/NULL);
ArgumentException_t132251570 * L_55 = (ArgumentException_t132251570 *)il2cpp_codegen_object_new(ArgumentException_t132251570_il2cpp_TypeInfo_var);
ArgumentException__ctor_m1216717135(L_55, L_54, _stringLiteral3976682977, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_55, NULL, Version_ToString_m3654989516_RuntimeMethod_var);
}
}
// System.Void System.Version::AppendPositiveNumber(System.Int32,System.Text.StringBuilder)
extern "C" void Version_AppendPositiveNumber_m308762805 (RuntimeObject * __this /* static, unused */, int32_t ___num0, StringBuilder_t * ___sb1, const RuntimeMethod* method)
{
int32_t V_0 = 0;
int32_t V_1 = 0;
{
StringBuilder_t * L_0 = ___sb1;
NullCheck(L_0);
int32_t L_1 = StringBuilder_get_Length_m3238060835(L_0, /*hidden argument*/NULL);
V_0 = L_1;
}
IL_0007:
{
int32_t L_2 = ___num0;
V_1 = ((int32_t)((int32_t)L_2%(int32_t)((int32_t)10)));
int32_t L_3 = ___num0;
___num0 = ((int32_t)((int32_t)L_3/(int32_t)((int32_t)10)));
StringBuilder_t * L_4 = ___sb1;
int32_t L_5 = V_0;
int32_t L_6 = V_1;
NullCheck(L_4);
StringBuilder_Insert_m1076119876(L_4, L_5, (((int32_t)((uint16_t)((int32_t)il2cpp_codegen_add((int32_t)((int32_t)48), (int32_t)L_6))))), /*hidden argument*/NULL);
int32_t L_7 = ___num0;
if ((((int32_t)L_7) > ((int32_t)0)))
{
goto IL_0007;
}
}
{
return;
}
}
// System.Boolean System.Version::op_Equality(System.Version,System.Version)
extern "C" bool Version_op_Equality_m3804852517 (RuntimeObject * __this /* static, unused */, Version_t3456873960 * ___v10, Version_t3456873960 * ___v21, const RuntimeMethod* method)
{
{
Version_t3456873960 * L_0 = ___v10;
if (L_0)
{
goto IL_0008;
}
}
{
Version_t3456873960 * L_1 = ___v21;
return (bool)((((RuntimeObject*)(Version_t3456873960 *)L_1) == ((RuntimeObject*)(RuntimeObject *)NULL))? 1 : 0);
}
IL_0008:
{
Version_t3456873960 * L_2 = ___v10;
Version_t3456873960 * L_3 = ___v21;
NullCheck(L_2);
bool L_4 = Version_Equals_m1564427710(L_2, L_3, /*hidden argument*/NULL);
return L_4;
}
}
// System.Boolean System.Version::op_Inequality(System.Version,System.Version)
extern "C" bool Version_op_Inequality_m1696193441 (RuntimeObject * __this /* static, unused */, Version_t3456873960 * ___v10, Version_t3456873960 * ___v21, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_op_Inequality_m1696193441_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_t3456873960 * L_0 = ___v10;
Version_t3456873960 * L_1 = ___v21;
IL2CPP_RUNTIME_CLASS_INIT(Version_t3456873960_il2cpp_TypeInfo_var);
bool L_2 = Version_op_Equality_m3804852517(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
return (bool)((((int32_t)L_2) == ((int32_t)0))? 1 : 0);
}
}
// System.Boolean System.Version::op_LessThan(System.Version,System.Version)
extern "C" bool Version_op_LessThan_m3745610070 (RuntimeObject * __this /* static, unused */, Version_t3456873960 * ___v10, Version_t3456873960 * ___v21, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_op_LessThan_m3745610070_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_t3456873960 * L_0 = ___v10;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t1615371798 * L_1 = (ArgumentNullException_t1615371798 *)il2cpp_codegen_object_new(ArgumentNullException_t1615371798_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m1170824041(L_1, _stringLiteral3451500490, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, Version_op_LessThan_m3745610070_RuntimeMethod_var);
}
IL_000e:
{
Version_t3456873960 * L_2 = ___v10;
Version_t3456873960 * L_3 = ___v21;
NullCheck(L_2);
int32_t L_4 = Version_CompareTo_m3146217210(L_2, L_3, /*hidden argument*/NULL);
return (bool)((((int32_t)L_4) < ((int32_t)0))? 1 : 0);
}
}
// System.Boolean System.Version::op_LessThanOrEqual(System.Version,System.Version)
extern "C" bool Version_op_LessThanOrEqual_m666140174 (RuntimeObject * __this /* static, unused */, Version_t3456873960 * ___v10, Version_t3456873960 * ___v21, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_op_LessThanOrEqual_m666140174_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_t3456873960 * L_0 = ___v10;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t1615371798 * L_1 = (ArgumentNullException_t1615371798 *)il2cpp_codegen_object_new(ArgumentNullException_t1615371798_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m1170824041(L_1, _stringLiteral3451500490, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, Version_op_LessThanOrEqual_m666140174_RuntimeMethod_var);
}
IL_000e:
{
Version_t3456873960 * L_2 = ___v10;
Version_t3456873960 * L_3 = ___v21;
NullCheck(L_2);
int32_t L_4 = Version_CompareTo_m3146217210(L_2, L_3, /*hidden argument*/NULL);
return (bool)((((int32_t)((((int32_t)L_4) > ((int32_t)0))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
}
// System.Boolean System.Version::op_GreaterThanOrEqual(System.Version,System.Version)
extern "C" bool Version_op_GreaterThanOrEqual_m474945801 (RuntimeObject * __this /* static, unused */, Version_t3456873960 * ___v10, Version_t3456873960 * ___v21, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version_op_GreaterThanOrEqual_m474945801_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Version_t3456873960 * L_0 = ___v21;
Version_t3456873960 * L_1 = ___v10;
IL2CPP_RUNTIME_CLASS_INIT(Version_t3456873960_il2cpp_TypeInfo_var);
bool L_2 = Version_op_LessThanOrEqual_m666140174(NULL /*static, unused*/, L_0, L_1, /*hidden argument*/NULL);
return L_2;
}
}
// System.Void System.Version::.cctor()
extern "C" void Version__cctor_m3568671087 (RuntimeObject * __this /* static, unused */, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Version__cctor_m3568671087_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
CharU5BU5D_t3528271667* L_0 = (CharU5BU5D_t3528271667*)SZArrayNew(CharU5BU5D_t3528271667_il2cpp_TypeInfo_var, (uint32_t)1);
CharU5BU5D_t3528271667* L_1 = L_0;
NullCheck(L_1);
(L_1)->SetAt(static_cast<il2cpp_array_size_t>(0), (Il2CppChar)((int32_t)46));
((Version_t3456873960_StaticFields*)il2cpp_codegen_static_fields_for(Version_t3456873960_il2cpp_TypeInfo_var))->set_SeparatorsArray_4(L_1);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.WeakReference::AllocateHandle(System.Object)
extern "C" void WeakReference_AllocateHandle_m1478975559 (WeakReference_t1334886716 * __this, RuntimeObject * ___target0, const RuntimeMethod* method)
{
{
bool L_0 = __this->get_isLongReference_0();
if (!L_0)
{
goto IL_0016;
}
}
{
RuntimeObject * L_1 = ___target0;
GCHandle_t3351438187 L_2 = GCHandle_Alloc_m3823409740(NULL /*static, unused*/, L_1, 1, /*hidden argument*/NULL);
__this->set_gcHandle_1(L_2);
return;
}
IL_0016:
{
RuntimeObject * L_3 = ___target0;
GCHandle_t3351438187 L_4 = GCHandle_Alloc_m3823409740(NULL /*static, unused*/, L_3, 0, /*hidden argument*/NULL);
__this->set_gcHandle_1(L_4);
return;
}
}
// System.Void System.WeakReference::.ctor(System.Object)
extern "C" void WeakReference__ctor_m2401547918 (WeakReference_t1334886716 * __this, RuntimeObject * ___target0, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = ___target0;
WeakReference__ctor_m1054065938(__this, L_0, (bool)0, /*hidden argument*/NULL);
return;
}
}
// System.Void System.WeakReference::.ctor(System.Object,System.Boolean)
extern "C" void WeakReference__ctor_m1054065938 (WeakReference_t1334886716 * __this, RuntimeObject * ___target0, bool ___trackResurrection1, const RuntimeMethod* method)
{
{
Object__ctor_m297566312(__this, /*hidden argument*/NULL);
bool L_0 = ___trackResurrection1;
__this->set_isLongReference_0(L_0);
RuntimeObject * L_1 = ___target0;
WeakReference_AllocateHandle_m1478975559(__this, L_1, /*hidden argument*/NULL);
return;
}
}
// System.Void System.WeakReference::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void WeakReference__ctor_m1244067698 (WeakReference_t1334886716 * __this, SerializationInfo_t950877179 * ___info0, StreamingContext_t3711869237 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WeakReference__ctor_m1244067698_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RuntimeObject * V_0 = NULL;
{
Object__ctor_m297566312(__this, /*hidden argument*/NULL);
SerializationInfo_t950877179 * L_0 = ___info0;
if (L_0)
{
goto IL_0014;
}
}
{
ArgumentNullException_t1615371798 * L_1 = (ArgumentNullException_t1615371798 *)il2cpp_codegen_object_new(ArgumentNullException_t1615371798_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m1170824041(L_1, _stringLiteral79347, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, WeakReference__ctor_m1244067698_RuntimeMethod_var);
}
IL_0014:
{
SerializationInfo_t950877179 * L_2 = ___info0;
NullCheck(L_2);
bool L_3 = SerializationInfo_GetBoolean_m1756153320(L_2, _stringLiteral3234942771, /*hidden argument*/NULL);
__this->set_isLongReference_0(L_3);
SerializationInfo_t950877179 * L_4 = ___info0;
RuntimeTypeHandle_t3027515415 L_5 = { reinterpret_cast<intptr_t> (RuntimeObject_0_0_0_var) };
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_6 = Type_GetTypeFromHandle_m1620074514(NULL /*static, unused*/, L_5, /*hidden argument*/NULL);
NullCheck(L_4);
RuntimeObject * L_7 = SerializationInfo_GetValue_m42271953(L_4, _stringLiteral2922588279, L_6, /*hidden argument*/NULL);
V_0 = L_7;
RuntimeObject * L_8 = V_0;
WeakReference_AllocateHandle_m1478975559(__this, L_8, /*hidden argument*/NULL);
return;
}
}
// System.Boolean System.WeakReference::get_IsAlive()
extern "C" bool WeakReference_get_IsAlive_m1867740323 (WeakReference_t1334886716 * __this, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = VirtFuncInvoker0< RuntimeObject * >::Invoke(6 /* System.Object System.WeakReference::get_Target() */, __this);
return (bool)((!(((RuntimeObject*)(RuntimeObject *)L_0) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0);
}
}
// System.Object System.WeakReference::get_Target()
extern "C" RuntimeObject * WeakReference_get_Target_m168713953 (WeakReference_t1334886716 * __this, const RuntimeMethod* method)
{
{
GCHandle_t3351438187 * L_0 = __this->get_address_of_gcHandle_1();
bool L_1 = GCHandle_get_IsAllocated_m1058226959((GCHandle_t3351438187 *)L_0, /*hidden argument*/NULL);
if (L_1)
{
goto IL_000f;
}
}
{
return NULL;
}
IL_000f:
{
GCHandle_t3351438187 * L_2 = __this->get_address_of_gcHandle_1();
RuntimeObject * L_3 = GCHandle_get_Target_m1824973883((GCHandle_t3351438187 *)L_2, /*hidden argument*/NULL);
return L_3;
}
}
// System.Boolean System.WeakReference::get_TrackResurrection()
extern "C" bool WeakReference_get_TrackResurrection_m942701017 (WeakReference_t1334886716 * __this, const RuntimeMethod* method)
{
{
bool L_0 = __this->get_isLongReference_0();
return L_0;
}
}
// System.Void System.WeakReference::Finalize()
extern "C" void WeakReference_Finalize_m2841826116 (WeakReference_t1334886716 * __this, const RuntimeMethod* method)
{
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
IL_0000:
try
{ // begin try (depth: 1)
GCHandle_t3351438187 * L_0 = __this->get_address_of_gcHandle_1();
GCHandle_Free_m1457699368((GCHandle_t3351438187 *)L_0, /*hidden argument*/NULL);
IL2CPP_LEAVE(0x14, FINALLY_000d);
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t *)e.ex;
goto FINALLY_000d;
}
FINALLY_000d:
{ // begin finally (depth: 1)
Object_Finalize_m3076187857(__this, /*hidden argument*/NULL);
IL2CPP_END_FINALLY(13)
} // end finally (depth: 1)
IL2CPP_CLEANUP(13)
{
IL2CPP_JUMP_TBL(0x14, IL_0014)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
}
IL_0014:
{
return;
}
}
// System.Void System.WeakReference::GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void WeakReference_GetObjectData_m2192383095 (WeakReference_t1334886716 * __this, SerializationInfo_t950877179 * ___info0, StreamingContext_t3711869237 ___context1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WeakReference_GetObjectData_m2192383095_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
int32_t __leave_target = 0;
NO_UNUSED_WARNING (__leave_target);
{
SerializationInfo_t950877179 * L_0 = ___info0;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t1615371798 * L_1 = (ArgumentNullException_t1615371798 *)il2cpp_codegen_object_new(ArgumentNullException_t1615371798_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m1170824041(L_1, _stringLiteral79347, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, WeakReference_GetObjectData_m2192383095_RuntimeMethod_var);
}
IL_000e:
{
SerializationInfo_t950877179 * L_2 = ___info0;
bool L_3 = VirtFuncInvoker0< bool >::Invoke(7 /* System.Boolean System.WeakReference::get_TrackResurrection() */, __this);
NullCheck(L_2);
SerializationInfo_AddValue_m3427199315(L_2, _stringLiteral3234942771, L_3, /*hidden argument*/NULL);
}
IL_001f:
try
{ // begin try (depth: 1)
SerializationInfo_t950877179 * L_4 = ___info0;
RuntimeObject * L_5 = VirtFuncInvoker0< RuntimeObject * >::Invoke(6 /* System.Object System.WeakReference::get_Target() */, __this);
NullCheck(L_4);
SerializationInfo_AddValue_m2872281893(L_4, _stringLiteral2922588279, L_5, /*hidden argument*/NULL);
goto IL_0041;
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__exception_local = (Exception_t *)e.ex;
if(il2cpp_codegen_class_is_assignable_from (Exception_t_il2cpp_TypeInfo_var, il2cpp_codegen_object_class(e.ex)))
goto CATCH_0032;
throw e;
}
CATCH_0032:
{ // begin catch(System.Exception)
SerializationInfo_t950877179 * L_6 = ___info0;
NullCheck(L_6);
SerializationInfo_AddValue_m2872281893(L_6, _stringLiteral2922588279, NULL, /*hidden argument*/NULL);
goto IL_0041;
} // end catch (depth: 1)
IL_0041:
{
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.WindowsConsoleDriver::.ctor()
extern "C" void WindowsConsoleDriver__ctor_m141100690 (WindowsConsoleDriver_t3991887195 * __this, const RuntimeMethod* method)
{
ConsoleScreenBufferInfo_t3095351730 V_0;
memset(&V_0, 0, sizeof(V_0));
{
Object__ctor_m297566312(__this, /*hidden argument*/NULL);
intptr_t L_0 = WindowsConsoleDriver_GetStdHandle_m23119533(NULL /*static, unused*/, ((int32_t)-11), /*hidden argument*/NULL);
__this->set_outputHandle_1(L_0);
intptr_t L_1 = WindowsConsoleDriver_GetStdHandle_m23119533(NULL /*static, unused*/, ((int32_t)-10), /*hidden argument*/NULL);
__this->set_inputHandle_0(L_1);
il2cpp_codegen_initobj((&V_0), sizeof(ConsoleScreenBufferInfo_t3095351730 ));
intptr_t L_2 = __this->get_outputHandle_1();
WindowsConsoleDriver_GetConsoleScreenBufferInfo_m3609341087(NULL /*static, unused*/, L_2, (ConsoleScreenBufferInfo_t3095351730 *)(&V_0), /*hidden argument*/NULL);
ConsoleScreenBufferInfo_t3095351730 L_3 = V_0;
int16_t L_4 = L_3.get_Attribute_2();
__this->set_defaultAttribute_2(L_4);
return;
}
}
// System.ConsoleKeyInfo System.WindowsConsoleDriver::ReadKey(System.Boolean)
extern "C" ConsoleKeyInfo_t1802691652 WindowsConsoleDriver_ReadKey_m209631140 (WindowsConsoleDriver_t3991887195 * __this, bool ___intercept0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WindowsConsoleDriver_ReadKey_m209631140_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
InputRecord_t2660212290 V_1;
memset(&V_1, 0, sizeof(V_1));
bool V_2 = false;
bool V_3 = false;
bool V_4 = false;
{
il2cpp_codegen_initobj((&V_1), sizeof(InputRecord_t2660212290 ));
}
IL_0008:
{
intptr_t L_0 = __this->get_inputHandle_0();
bool L_1 = WindowsConsoleDriver_ReadConsoleInput_m1790694890(NULL /*static, unused*/, L_0, (InputRecord_t2660212290 *)(&V_1), 1, (int32_t*)(&V_0), /*hidden argument*/NULL);
if (L_1)
{
goto IL_0034;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Marshal_t1757017490_il2cpp_TypeInfo_var);
int32_t L_2 = Marshal_GetLastWin32Error_m1272610344(NULL /*static, unused*/, /*hidden argument*/NULL);
int32_t L_3 = L_2;
RuntimeObject * L_4 = Box(Int32_t2950945753_il2cpp_TypeInfo_var, &L_3);
String_t* L_5 = String_Concat_m904156431(NULL /*static, unused*/, _stringLiteral1071424308, L_4, /*hidden argument*/NULL);
InvalidOperationException_t56020091 * L_6 = (InvalidOperationException_t56020091 *)il2cpp_codegen_object_new(InvalidOperationException_t56020091_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m237278729(L_6, L_5, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6, NULL, WindowsConsoleDriver_ReadKey_m209631140_RuntimeMethod_var);
}
IL_0034:
{
InputRecord_t2660212290 L_7 = V_1;
bool L_8 = L_7.get_KeyDown_1();
if (!L_8)
{
goto IL_0008;
}
}
{
InputRecord_t2660212290 L_9 = V_1;
int16_t L_10 = L_9.get_EventType_0();
if ((!(((uint32_t)L_10) == ((uint32_t)1))))
{
goto IL_0008;
}
}
{
InputRecord_t2660212290 L_11 = V_1;
int16_t L_12 = L_11.get_VirtualKeyCode_3();
bool L_13 = WindowsConsoleDriver_IsModifierKey_m1974886538(NULL /*static, unused*/, L_12, /*hidden argument*/NULL);
if (L_13)
{
goto IL_0008;
}
}
{
InputRecord_t2660212290 L_14 = V_1;
int32_t L_15 = L_14.get_ControlKeyState_6();
V_2 = (bool)((!(((uint32_t)((int32_t)((int32_t)L_15&(int32_t)3))) <= ((uint32_t)0)))? 1 : 0);
InputRecord_t2660212290 L_16 = V_1;
int32_t L_17 = L_16.get_ControlKeyState_6();
V_3 = (bool)((!(((uint32_t)((int32_t)((int32_t)L_17&(int32_t)((int32_t)12)))) <= ((uint32_t)0)))? 1 : 0);
InputRecord_t2660212290 L_18 = V_1;
int32_t L_19 = L_18.get_ControlKeyState_6();
V_4 = (bool)((!(((uint32_t)((int32_t)((int32_t)L_19&(int32_t)((int32_t)16)))) <= ((uint32_t)0)))? 1 : 0);
InputRecord_t2660212290 L_20 = V_1;
Il2CppChar L_21 = L_20.get_Character_5();
InputRecord_t2660212290 L_22 = V_1;
int16_t L_23 = L_22.get_VirtualKeyCode_3();
bool L_24 = V_4;
bool L_25 = V_2;
bool L_26 = V_3;
ConsoleKeyInfo_t1802691652 L_27;
memset(&L_27, 0, sizeof(L_27));
ConsoleKeyInfo__ctor_m535940175((&L_27), L_21, L_23, L_24, L_25, L_26, /*hidden argument*/NULL);
return L_27;
}
}
// System.Boolean System.WindowsConsoleDriver::IsModifierKey(System.Int16)
extern "C" bool WindowsConsoleDriver_IsModifierKey_m1974886538 (RuntimeObject * __this /* static, unused */, int16_t ___virtualKeyCode0, const RuntimeMethod* method)
{
{
int16_t L_0 = ___virtualKeyCode0;
if ((!(((uint32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_0, (int32_t)((int32_t)16)))) > ((uint32_t)2))))
{
goto IL_0016;
}
}
{
int16_t L_1 = ___virtualKeyCode0;
if ((((int32_t)L_1) == ((int32_t)((int32_t)20))))
{
goto IL_0016;
}
}
{
int16_t L_2 = ___virtualKeyCode0;
if ((!(((uint32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_2, (int32_t)((int32_t)144)))) <= ((uint32_t)1))))
{
goto IL_0018;
}
}
IL_0016:
{
return (bool)1;
}
IL_0018:
{
return (bool)0;
}
}
// System.IntPtr System.WindowsConsoleDriver::GetStdHandle(System.Handles)
extern "C" intptr_t WindowsConsoleDriver_GetStdHandle_m23119533 (RuntimeObject * __this /* static, unused */, int32_t ___handle0, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (int32_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(int32_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("kernel32.dll"), "GetStdHandle", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'GetStdHandle'"), NULL, NULL);
}
}
// Native function invocation
intptr_t returnValue = il2cppPInvokeFunc(___handle0);
il2cpp_codegen_marshal_store_last_error();
return returnValue;
}
// System.Boolean System.WindowsConsoleDriver::GetConsoleScreenBufferInfo(System.IntPtr,System.ConsoleScreenBufferInfo&)
extern "C" bool WindowsConsoleDriver_GetConsoleScreenBufferInfo_m3609341087 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, ConsoleScreenBufferInfo_t3095351730 * ___info1, const RuntimeMethod* method)
{
typedef int32_t (DEFAULT_CALL *PInvokeFunc) (intptr_t, ConsoleScreenBufferInfo_t3095351730 *);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t) + sizeof(ConsoleScreenBufferInfo_t3095351730 *);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("kernel32.dll"), "GetConsoleScreenBufferInfo", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'GetConsoleScreenBufferInfo'"), NULL, NULL);
}
}
// Marshaling of parameter '___info1' to native representation
ConsoleScreenBufferInfo_t3095351730 ____info1_empty = {};
// Native function invocation
int32_t returnValue = il2cppPInvokeFunc(___handle0, (&____info1_empty));
il2cpp_codegen_marshal_store_last_error();
// Marshaling of parameter '___info1' back from native representation
*___info1 = ____info1_empty;
return static_cast<bool>(returnValue);
}
// System.Boolean System.WindowsConsoleDriver::ReadConsoleInput(System.IntPtr,System.InputRecord&,System.Int32,System.Int32&)
extern "C" bool WindowsConsoleDriver_ReadConsoleInput_m1790694890 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, InputRecord_t2660212290 * ___record1, int32_t ___length2, int32_t* ___nread3, const RuntimeMethod* method)
{
typedef int32_t (DEFAULT_CALL *PInvokeFunc) (intptr_t, InputRecord_t2660212290_marshaled_pinvoke*, int32_t, int32_t*);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t) + sizeof(InputRecord_t2660212290_marshaled_pinvoke*) + sizeof(int32_t) + sizeof(int32_t*);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("kernel32.dll"), "ReadConsoleInput", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'ReadConsoleInput'"), NULL, NULL);
}
}
// Marshaling of parameter '___record1' to native representation
InputRecord_t2660212290_marshaled_pinvoke ____record1_empty = {};
InputRecord_t2660212290_marshaled_pinvoke* ____record1_marshaled = &____record1_empty;
// Marshaling of parameter '___nread3' to native representation
int32_t ____nread3_empty = 0;
// Native function invocation
int32_t returnValue = il2cppPInvokeFunc(___handle0, ____record1_marshaled, ___length2, (&____nread3_empty));
il2cpp_codegen_marshal_store_last_error();
// Marshaling of parameter '___record1' back from native representation
InputRecord_t2660212290 _____record1_marshaled_unmarshaled_dereferenced;
memset(&_____record1_marshaled_unmarshaled_dereferenced, 0, sizeof(_____record1_marshaled_unmarshaled_dereferenced));
InputRecord_t2660212290_marshal_pinvoke_back(*____record1_marshaled, _____record1_marshaled_unmarshaled_dereferenced);
*___record1 = _____record1_marshaled_unmarshaled_dereferenced;
// Marshaling cleanup of parameter '___record1' native representation
InputRecord_t2660212290_marshal_pinvoke_cleanup(*____record1_marshaled);
// Marshaling of parameter '___nread3' back from native representation
*___nread3 = ____nread3_empty;
return static_cast<bool>(returnValue);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void XamMac.CoreFoundation.CFHelpers::CFRelease(System.IntPtr)
extern "C" void CFHelpers_CFRelease_m3206817372 (RuntimeObject * __this /* static, unused */, intptr_t ___obj0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc) (intptr_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"), "CFRelease", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'CFRelease'"), NULL, NULL);
}
}
// Native function invocation
il2cppPInvokeFunc(___obj0);
}
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFRetain(System.IntPtr)
extern "C" intptr_t CFHelpers_CFRetain_m47160182 (RuntimeObject * __this /* static, unused */, intptr_t ___obj0, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (intptr_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"), "CFRetain", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'CFRetain'"), NULL, NULL);
}
}
// Native function invocation
intptr_t returnValue = il2cppPInvokeFunc(___obj0);
return returnValue;
}
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFStringGetLength(System.IntPtr)
extern "C" intptr_t CFHelpers_CFStringGetLength_m1003035781 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (intptr_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"), "CFStringGetLength", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'CFStringGetLength'"), NULL, NULL);
}
}
// Native function invocation
intptr_t returnValue = il2cppPInvokeFunc(___handle0);
return returnValue;
}
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFStringGetCharactersPtr(System.IntPtr)
extern "C" intptr_t CFHelpers_CFStringGetCharactersPtr_m1790634856 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (intptr_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"), "CFStringGetCharactersPtr", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'CFStringGetCharactersPtr'"), NULL, NULL);
}
}
// Native function invocation
intptr_t returnValue = il2cppPInvokeFunc(___handle0);
return returnValue;
}
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFStringGetCharacters(System.IntPtr,XamMac.CoreFoundation.CFHelpers/CFRange,System.IntPtr)
extern "C" intptr_t CFHelpers_CFStringGetCharacters_m1195295518 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, CFRange_t1233619878 ___range1, intptr_t ___buffer2, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (intptr_t, CFRange_t1233619878 , intptr_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t) + sizeof(CFRange_t1233619878 ) + sizeof(intptr_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"), "CFStringGetCharacters", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'CFStringGetCharacters'"), NULL, NULL);
}
}
// Native function invocation
intptr_t returnValue = il2cppPInvokeFunc(___handle0, ___range1, ___buffer2);
return returnValue;
}
// System.String XamMac.CoreFoundation.CFHelpers::FetchString(System.IntPtr)
extern "C" String_t* CFHelpers_FetchString_m1875874129 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (CFHelpers_FetchString_m1875874129_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
intptr_t V_1;
memset(&V_1, 0, sizeof(V_1));
intptr_t V_2;
memset(&V_2, 0, sizeof(V_2));
CFRange_t1233619878 V_3;
memset(&V_3, 0, sizeof(V_3));
String_t* G_B6_0 = NULL;
String_t* G_B5_0 = NULL;
{
intptr_t L_0 = ___handle0;
bool L_1 = IntPtr_op_Equality_m408849716(NULL /*static, unused*/, L_0, (intptr_t)(0), /*hidden argument*/NULL);
if (!L_1)
{
goto IL_000f;
}
}
{
return (String_t*)NULL;
}
IL_000f:
{
intptr_t L_2 = ___handle0;
intptr_t L_3 = CFHelpers_CFStringGetLength_m1003035781(NULL /*static, unused*/, L_2, /*hidden argument*/NULL);
int32_t L_4 = IntPtr_op_Explicit_m4220076518(NULL /*static, unused*/, L_3, /*hidden argument*/NULL);
V_0 = L_4;
intptr_t L_5 = ___handle0;
intptr_t L_6 = CFHelpers_CFStringGetCharactersPtr_m1790634856(NULL /*static, unused*/, L_5, /*hidden argument*/NULL);
V_1 = L_6;
V_2 = (intptr_t)(0);
intptr_t L_7 = V_1;
bool L_8 = IntPtr_op_Equality_m408849716(NULL /*static, unused*/, L_7, (intptr_t)(0), /*hidden argument*/NULL);
if (!L_8)
{
goto IL_0052;
}
}
{
int32_t L_9 = V_0;
CFRange__ctor_m1242434219((CFRange_t1233619878 *)(&V_3), 0, L_9, /*hidden argument*/NULL);
int32_t L_10 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Marshal_t1757017490_il2cpp_TypeInfo_var);
intptr_t L_11 = Marshal_AllocCoTaskMem_m1327939722(NULL /*static, unused*/, ((int32_t)il2cpp_codegen_multiply((int32_t)L_10, (int32_t)2)), /*hidden argument*/NULL);
V_2 = L_11;
intptr_t L_12 = ___handle0;
CFRange_t1233619878 L_13 = V_3;
intptr_t L_14 = V_2;
CFHelpers_CFStringGetCharacters_m1195295518(NULL /*static, unused*/, L_12, L_13, L_14, /*hidden argument*/NULL);
intptr_t L_15 = V_2;
V_1 = L_15;
}
IL_0052:
{
intptr_t L_16 = V_1;
void* L_17 = IntPtr_op_Explicit_m2520637223(NULL /*static, unused*/, L_16, /*hidden argument*/NULL);
int32_t L_18 = V_0;
String_t* L_19 = String_CreateString_m3400201881(NULL, (Il2CppChar*)(Il2CppChar*)L_17, 0, L_18, /*hidden argument*/NULL);
intptr_t L_20 = V_2;
bool L_21 = IntPtr_op_Inequality_m3063970704(NULL /*static, unused*/, L_20, (intptr_t)(0), /*hidden argument*/NULL);
G_B5_0 = L_19;
if (!L_21)
{
G_B6_0 = L_19;
goto IL_0072;
}
}
{
intptr_t L_22 = V_2;
IL2CPP_RUNTIME_CLASS_INIT(Marshal_t1757017490_il2cpp_TypeInfo_var);
Marshal_FreeCoTaskMem_m3753155979(NULL /*static, unused*/, L_22, /*hidden argument*/NULL);
G_B6_0 = G_B5_0;
}
IL_0072:
{
return G_B6_0;
}
}
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFDataGetLength(System.IntPtr)
extern "C" intptr_t CFHelpers_CFDataGetLength_m3730685275 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (intptr_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"), "CFDataGetLength", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'CFDataGetLength'"), NULL, NULL);
}
}
// Native function invocation
intptr_t returnValue = il2cppPInvokeFunc(___handle0);
return returnValue;
}
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFDataGetBytePtr(System.IntPtr)
extern "C" intptr_t CFHelpers_CFDataGetBytePtr_m1648767664 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (intptr_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"), "CFDataGetBytePtr", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'CFDataGetBytePtr'"), NULL, NULL);
}
}
// Native function invocation
intptr_t returnValue = il2cppPInvokeFunc(___handle0);
return returnValue;
}
// System.Byte[] XamMac.CoreFoundation.CFHelpers::FetchDataBuffer(System.IntPtr)
extern "C" ByteU5BU5D_t4116647657* CFHelpers_FetchDataBuffer_m2260522698 (RuntimeObject * __this /* static, unused */, intptr_t ___handle0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (CFHelpers_FetchDataBuffer_m2260522698_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ByteU5BU5D_t4116647657* V_0 = NULL;
{
intptr_t L_0 = ___handle0;
intptr_t L_1 = CFHelpers_CFDataGetLength_m3730685275(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
int32_t L_2 = IntPtr_op_Explicit_m4220076518(NULL /*static, unused*/, L_1, /*hidden argument*/NULL);
ByteU5BU5D_t4116647657* L_3 = (ByteU5BU5D_t4116647657*)SZArrayNew(ByteU5BU5D_t4116647657_il2cpp_TypeInfo_var, (uint32_t)L_2);
V_0 = L_3;
intptr_t L_4 = ___handle0;
intptr_t L_5 = CFHelpers_CFDataGetBytePtr_m1648767664(NULL /*static, unused*/, L_4, /*hidden argument*/NULL);
ByteU5BU5D_t4116647657* L_6 = V_0;
ByteU5BU5D_t4116647657* L_7 = V_0;
NullCheck(L_7);
IL2CPP_RUNTIME_CLASS_INIT(Marshal_t1757017490_il2cpp_TypeInfo_var);
Marshal_Copy_m1222846562(NULL /*static, unused*/, L_5, L_6, 0, (((int32_t)((int32_t)(((RuntimeArray *)L_7)->max_length)))), /*hidden argument*/NULL);
ByteU5BU5D_t4116647657* L_8 = V_0;
return L_8;
}
}
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CFDataCreate(System.IntPtr,System.IntPtr,System.IntPtr)
extern "C" intptr_t CFHelpers_CFDataCreate_m3875740957 (RuntimeObject * __this /* static, unused */, intptr_t ___allocator0, intptr_t ___bytes1, intptr_t ___length2, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (intptr_t, intptr_t, intptr_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t) + sizeof(intptr_t) + sizeof(intptr_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation"), "CFDataCreate", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'CFDataCreate'"), NULL, NULL);
}
}
// Native function invocation
intptr_t returnValue = il2cppPInvokeFunc(___allocator0, ___bytes1, ___length2);
return returnValue;
}
// System.IntPtr XamMac.CoreFoundation.CFHelpers::SecCertificateCreateWithData(System.IntPtr,System.IntPtr)
extern "C" intptr_t CFHelpers_SecCertificateCreateWithData_m1682200427 (RuntimeObject * __this /* static, unused */, intptr_t ___allocator0, intptr_t ___cfData1, const RuntimeMethod* method)
{
typedef intptr_t (DEFAULT_CALL *PInvokeFunc) (intptr_t, intptr_t);
static PInvokeFunc il2cppPInvokeFunc;
if (il2cppPInvokeFunc == NULL)
{
int parameterSize = sizeof(intptr_t) + sizeof(intptr_t);
il2cppPInvokeFunc = il2cpp_codegen_resolve_pinvoke<PInvokeFunc>(IL2CPP_NATIVE_STRING("/System/Library/Frameworks/Security.framework/Security"), "SecCertificateCreateWithData", IL2CPP_CALL_DEFAULT, CHARSET_UNICODE, parameterSize, false);
if (il2cppPInvokeFunc == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_not_supported_exception("Unable to find method for p/invoke: 'SecCertificateCreateWithData'"), NULL, NULL);
}
}
// Native function invocation
intptr_t returnValue = il2cppPInvokeFunc(___allocator0, ___cfData1);
return returnValue;
}
// System.IntPtr XamMac.CoreFoundation.CFHelpers::CreateCertificateFromData(System.Byte[])
extern "C" intptr_t CFHelpers_CreateCertificateFromData_m702581168 (RuntimeObject * __this /* static, unused */, ByteU5BU5D_t4116647657* ___data0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (CFHelpers_CreateCertificateFromData_m702581168_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void* V_0 = NULL;
ByteU5BU5D_t4116647657* V_1 = NULL;
intptr_t V_2;
memset(&V_2, 0, sizeof(V_2));
intptr_t G_B8_0;
memset(&G_B8_0, 0, sizeof(G_B8_0));
intptr_t G_B7_0;
memset(&G_B7_0, 0, sizeof(G_B7_0));
{
ByteU5BU5D_t4116647657* L_0 = ___data0;
ByteU5BU5D_t4116647657* L_1 = L_0;
V_1 = L_1;
if (!L_1)
{
goto IL_000a;
}
}
{
ByteU5BU5D_t4116647657* L_2 = V_1;
NullCheck(L_2);
if ((((int32_t)((int32_t)(((RuntimeArray *)L_2)->max_length)))))
{
goto IL_000f;
}
}
IL_000a:
{
V_0 = (void*)(((uintptr_t)0));
goto IL_0018;
}
IL_000f:
{
ByteU5BU5D_t4116647657* L_3 = V_1;
NullCheck(L_3);
V_0 = (void*)(((uintptr_t)((L_3)->GetAddressAt(static_cast<il2cpp_array_size_t>(0)))));
}
IL_0018:
{
void* L_4 = V_0;
intptr_t L_5 = IntPtr_op_Explicit_m536245531(NULL /*static, unused*/, (void*)(void*)L_4, /*hidden argument*/NULL);
ByteU5BU5D_t4116647657* L_6 = ___data0;
NullCheck(L_6);
intptr_t L_7;
memset(&L_7, 0, sizeof(L_7));
IntPtr__ctor_m987082960((&L_7), (((int32_t)((int32_t)(((RuntimeArray *)L_6)->max_length)))), /*hidden argument*/NULL);
intptr_t L_8 = CFHelpers_CFDataCreate_m3875740957(NULL /*static, unused*/, (intptr_t)(0), L_5, L_7, /*hidden argument*/NULL);
V_2 = L_8;
intptr_t L_9 = V_2;
bool L_10 = IntPtr_op_Equality_m408849716(NULL /*static, unused*/, L_9, (intptr_t)(0), /*hidden argument*/NULL);
if (!L_10)
{
goto IL_0044;
}
}
{
return (intptr_t)(0);
}
IL_0044:
{
intptr_t L_11 = V_2;
intptr_t L_12 = CFHelpers_SecCertificateCreateWithData_m1682200427(NULL /*static, unused*/, (intptr_t)(0), L_11, /*hidden argument*/NULL);
intptr_t L_13 = V_2;
bool L_14 = IntPtr_op_Inequality_m3063970704(NULL /*static, unused*/, L_13, (intptr_t)(0), /*hidden argument*/NULL);
G_B7_0 = L_12;
if (!L_14)
{
G_B8_0 = L_12;
goto IL_0062;
}
}
{
intptr_t L_15 = V_2;
CFHelpers_CFRelease_m3206817372(NULL /*static, unused*/, L_15, /*hidden argument*/NULL);
G_B8_0 = G_B7_0;
}
IL_0062:
{
return G_B8_0;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void XamMac.CoreFoundation.CFHelpers/CFRange::.ctor(System.Int32,System.Int32)
extern "C" void CFRange__ctor_m1242434219 (CFRange_t1233619878 * __this, int32_t ___loc0, int32_t ___len1, const RuntimeMethod* method)
{
{
int32_t L_0 = ___loc0;
int32_t L_1 = ___len1;
CFRange__ctor_m3401693388((CFRange_t1233619878 *)__this, (((int64_t)((int64_t)L_0))), (((int64_t)((int64_t)L_1))), /*hidden argument*/NULL);
return;
}
}
extern "C" void CFRange__ctor_m1242434219_AdjustorThunk (RuntimeObject * __this, int32_t ___loc0, int32_t ___len1, const RuntimeMethod* method)
{
CFRange_t1233619878 * _thisAdjusted = reinterpret_cast<CFRange_t1233619878 *>(__this + 1);
CFRange__ctor_m1242434219(_thisAdjusted, ___loc0, ___len1, method);
}
// System.Void XamMac.CoreFoundation.CFHelpers/CFRange::.ctor(System.Int64,System.Int64)
extern "C" void CFRange__ctor_m3401693388 (CFRange_t1233619878 * __this, int64_t ___l0, int64_t ___len1, const RuntimeMethod* method)
{
{
int64_t L_0 = ___l0;
intptr_t L_1 = IntPtr_op_Explicit_m1593085246(NULL /*static, unused*/, L_0, /*hidden argument*/NULL);
__this->set_loc_0(L_1);
int64_t L_2 = ___len1;
intptr_t L_3 = IntPtr_op_Explicit_m1593085246(NULL /*static, unused*/, L_2, /*hidden argument*/NULL);
__this->set_len_1(L_3);
return;
}
}
extern "C" void CFRange__ctor_m3401693388_AdjustorThunk (RuntimeObject * __this, int64_t ___l0, int64_t ___len1, const RuntimeMethod* method)
{
CFRange_t1233619878 * _thisAdjusted = reinterpret_cast<CFRange_t1233619878 *>(__this + 1);
CFRange__ctor_m3401693388(_thisAdjusted, ___l0, ___len1, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| 40.760793 | 473 | 0.799416 | bsgbryan |
09cfd0af802e077f58331b449d3787aa8dbb69a4 | 666 | cpp | C++ | lib/rpkeys/base.cpp | seanhagen/macropad | 3375e427f5606bec0d1b50ca44ac9140e686a6da | [
"MIT"
] | null | null | null | lib/rpkeys/base.cpp | seanhagen/macropad | 3375e427f5606bec0d1b50ca44ac9140e686a6da | [
"MIT"
] | null | null | null | lib/rpkeys/base.cpp | seanhagen/macropad | 3375e427f5606bec0d1b50ca44ac9140e686a6da | [
"MIT"
] | null | null | null | #include "base.h"
/*
Station::Station(void) { _setup(); }
Station::Station(stationConfig conf) {
_config = conf;
_setup();
}
*/
RPKeyboard::RPKeyboard() {
Serial.begin(115200);
// while (!Serial) { delay(10); } // wait till serial port is opened
delay(100); // RP2040 delay is not a bad idea
Serial.println("Adafruit Macropad with RP2040");
}
void RPKeyboard::setup(void) {
// setupNeopixels();
// setupDisplay();
// setupSpeaker();
// setupKeys();
setupEncoder();
// // We will use I2C for scanning the Stemma QT port
// Wire.begin();
}
void RPKeyboard::loop(void) {
loopEncoder();
// loopNeopixels();
// loopDisplay();
}
| 18.5 | 74 | 0.633634 | seanhagen |
09d052200eb4a0a2e2dce198359ddb925f636a40 | 22 | cpp | C++ | Coffee/src/CoffeePCH.cpp | SentientCoffee/HazelnutEngine | b1e9e29d50119a2882d840c47078363db71b266b | [
"Apache-2.0"
] | 1 | 2020-07-19T20:07:25.000Z | 2020-07-19T20:07:25.000Z | Coffee/src/CoffeePCH.cpp | SentientCoffee/CoffeeEngine | b1e9e29d50119a2882d840c47078363db71b266b | [
"Apache-2.0"
] | null | null | null | Coffee/src/CoffeePCH.cpp | SentientCoffee/CoffeeEngine | b1e9e29d50119a2882d840c47078363db71b266b | [
"Apache-2.0"
] | null | null | null | #include "CoffeePCH.h" | 22 | 22 | 0.772727 | SentientCoffee |
09d26388b8b89fbfaa1d1e750faa1902c5880c87 | 897 | cpp | C++ | sources/RandNano.cpp | usernameHed/Worms | 35ee28362b936b46d24e7c911a46a2cfd615128b | [
"MIT"
] | null | null | null | sources/RandNano.cpp | usernameHed/Worms | 35ee28362b936b46d24e7c911a46a2cfd615128b | [
"MIT"
] | null | null | null | sources/RandNano.cpp | usernameHed/Worms | 35ee28362b936b46d24e7c911a46a2cfd615128b | [
"MIT"
] | null | null | null | #include "RandNano.hh"
#include <cstdlib>
#include <ctime>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#ifdef _WIN32
#include <Windows.h>
#endif
#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>
#endif
RandNano::RandNano()
{
this->setRandInNano();
}
RandNano::~RandNano()
{
}
void RandNano::setRandInNano() const
{
#ifdef __MACH__ // OS X does not have clock_gettime, use clock_get_time
struct timespec ts;
clock_serv_t cclock;
mach_timespec_t mts;
host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
clock_get_time(cclock, &mts);
mach_port_deallocate(mach_task_self(), cclock);
ts.tv_sec = mts.tv_sec;
ts.tv_nsec = mts.tv_nsec;
srand((time_t)ts.tv_nsec);
#elif _WIN32
SYSTEMTIME st;
GetSystemTime(&st);
srand((time_t)st.wMilliseconds);
#else
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
srand((time_t)ts.tv_nsec);
#endif
}
| 18.6875 | 71 | 0.740245 | usernameHed |
09d28960d296bbb22f4969a271c8ac4a9ca05326 | 3,882 | hpp | C++ | src/types/ds/circular_queue.hpp | iamantony/CppNotes | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | [
"MIT"
] | 2 | 2020-07-31T14:13:56.000Z | 2021-02-03T09:51:43.000Z | src/types/ds/circular_queue.hpp | iamantony/CppNotes | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | [
"MIT"
] | 28 | 2015-09-22T07:38:21.000Z | 2018-10-02T11:00:58.000Z | src/types/ds/circular_queue.hpp | iamantony/CppNotes | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | [
"MIT"
] | 2 | 2018-10-11T14:10:50.000Z | 2021-02-27T08:53:50.000Z | #ifndef CIRCULAR_QUEUE_HPP
#define CIRCULAR_QUEUE_HPP
/*
https://leetcode.com/problems/design-circular-queue/description/
Design your implementation of the circular queue. The circular queue is
a linear data structure in which the operations are performed based on
FIFO (First In First Out) principle and the last position is connected
back to the first position to make a circle. It is also called "Ring Buffer".
One of the benefits of the circular queue is that we can make use of
the spaces in front of the queue. In a normal queue, once the queue
becomes full, we cannot insert the next element even if there is a
space in front of the queue. But using the circular queue, we can
use the space to store new values.
Your implementation should support following operations:
MyCircularQueue(k): Constructor, set the size of the queue to be k.
Front: Get the front item from the queue. If the queue is empty, return -1.
Rear: Get the last item from the queue. If the queue is empty, return -1.
enQueue(value): Insert an element into the circular queue. Return
true if the operation is successful.
deQueue(): Delete an element from the circular queue. Return true
if the operation is successful.
isEmpty(): Checks whether the circular queue is empty or not.
isFull(): Checks whether the circular queue is full or not.
Example:
MyCircularQueue circularQueue = new MycircularQueue(3); // set the size to be 3
circularQueue.enQueue(1); // return true
circularQueue.enQueue(2); // return true
circularQueue.enQueue(3); // return true
circularQueue.enQueue(4); // return false, the queue is full
circularQueue.Rear(); // return 3
circularQueue.isFull(); // return true
circularQueue.deQueue(); // return true
circularQueue.enQueue(4); // return true
circularQueue.Rear(); // return 4
Note:
All values will be in the range of [0, 1000].
The number of operations will be in the range of [1, 1000].
Please do not use the built-in Queue library.
*/
#include <vector>
#include <exception>
namespace Types::DS {
// TODO: add tests
template <typename T>
class CircularQueue {
std::vector<T> m_data;
bool m_full = false;
// Position of first element
size_t m_start = 0;
// Position one past the last element
size_t m_end = 0;
public:
CircularQueue(const size_t& size) {
m_data.resize(size, 0);
}
bool push(const T& value) {
if (m_data.size() == 0 || isFull()) {
return false;
}
// Check base case - queue is empty
if (m_start == m_end) {
m_data[m_start] = value;
m_end = 1;
}
else {
// Otherwise insert element to the end of the queue
m_data[m_end++] = value;
// Check if we need to move end position to the start of the vector
m_end = (m_end >= m_data.size()) ? 0 : m_end;
// Check if queue become full
if (m_start == m_end) {
m_full = true;
}
}
return true;
}
bool pop() {
if (isEmpty()) {
return false;
}
++m_start;
m_full = false;
if (m_start >= m_data.size()) {
m_start = 0;
}
if (m_start == m_end) {
m_start = m_end = 0;
}
return true;
}
T front() {
if (isEmpty()) {
throw std::logic_error("Circular queue is empty");
}
return m_data[m_start];
}
T back() {
if (isEmpty()) {
throw std::logic_error("Circular queue is empty");
}
return (m_end > 0) ? m_data[m_end - 1] : m_data[m_data.size() - 1];
}
bool isEmpty() {
return m_data.size() == 0 || (!isFull() && m_start == m_end);
}
bool isFull() {
return m_data.size() == 0 || m_full;
}
};
}
#endif // CIRCULAR_QUEUE_HPP
| 27.338028 | 79 | 0.627769 | iamantony |
09d83033574328c83b5c540bf4c080b54efd4fae | 16,526 | cc | C++ | src/mshines_render.cc | fuzziqersoftware/realmz_dasm | fbfa118de5f232fd7169fbff13d434164a67ee90 | [
"MIT"
] | 1 | 2018-03-20T13:06:16.000Z | 2018-03-20T13:06:16.000Z | src/mshines_render.cc | fuzziqersoftware/realmz_dasm | fbfa118de5f232fd7169fbff13d434164a67ee90 | [
"MIT"
] | null | null | null | src/mshines_render.cc | fuzziqersoftware/realmz_dasm | fbfa118de5f232fd7169fbff13d434164a67ee90 | [
"MIT"
] | null | null | null | #include <inttypes.h>
#include <stdlib.h>
#include <phosg/Encoding.hh>
#include <phosg/Filesystem.hh>
#include <phosg/Image.hh>
#include <phosg/Strings.hh>
#include <stdexcept>
#include <vector>
#include "IndexFormats/Formats.hh"
#include "ResourceFile.hh"
using namespace std;
struct MonkeyShinesRoom {
struct EnemyEntry {
be_uint16_t y_pixels;
be_uint16_t x_pixels;
be_int16_t y_min;
be_int16_t x_min;
be_int16_t y_max;
be_int16_t x_max;
be_int16_t y_speed; // in pixels per frame
be_int16_t x_speed; // in pixels per frame
be_int16_t type;
be_uint16_t flags;
// Sprite flags are:
// - increasing frames or cycling frames
// - slow animation
// - two sets horizontal
// - two sets vertical
// - normal sprite, energy drainer, or door
} __attribute__((packed));
struct BonusEntry {
be_uint16_t y_pixels;
be_uint16_t x_pixels;
be_int32_t unknown[3]; // these appear to be unused
be_int16_t type;
be_uint16_t id;
} __attribute__((packed));
be_uint16_t enemy_count;
be_uint16_t bonus_count;
EnemyEntry enemies[10];
BonusEntry bonuses[25];
be_uint16_t tile_ids[0x20 * 0x14]; // width=32, height=20
be_uint16_t player_start_y; // unused except in rooms 1000 and 10000
be_uint16_t player_start_x; // unused except in rooms 1000 and 10000
be_uint16_t background_ppat_id;
} __attribute__((packed));
struct MonkeyShinesWorld {
be_uint16_t num_exit_keys;
be_uint16_t num_bonus_keys;
be_uint16_t num_bonuses;
be_int16_t exit_door_room;
be_int16_t bonus_door_room;
// Hazard types are:
// 1 - burned
// 2 - electrocuted
// 3 - bee sting
// 4 - fall
// 5 - monster
be_uint16_t hazard_types[16];
uint8_t hazards_explode[16]; // really just an array of bools
// Hazard death sounds are:
// 12 - normal
// 13 - death from long fall
// 14 - death from bee sting
// 15 - death from bomb
// 16 - death by electrocution
// 20 - death by lava
be_uint16_t hazard_death_sounds[16];
// Explosion sounds can be any of the above or 18 (bomb explosion)
be_uint16_t hazard_explosion_sounds[16];
};
vector<unordered_map<int16_t, pair<int16_t, int16_t>>> generate_room_placement_maps(
const vector<int16_t>& room_ids) {
unordered_set<int16_t> remaining_room_ids(room_ids.begin(), room_ids.end());
// The basic idea is that when Bonzo moves right or left out of a room, the
// room number is increased or decreased by 1; when he moves up or down out of
// a room, it's increased or decreased by 100. There's no notion of rooms
// linking to each other; links are stored implicitly by the room IDs
// (resource IDs). To convert this format into something we can actually use,
// we have to find all the connected components of this graph.
// It occurs to me that this function might be a good basic algorithms
// interview question.
// This recursive lambda adds a single room to a placement map, then uses the
// flood-fill algorithm to find all the rooms it's connected to. This
// declaration looks super-gross because lambdas can't be recursive if you
// declare them with auto. Sigh...
function<void(unordered_map<int16_t, pair<int16_t, int16_t>>&, int16_t room_id,
int16_t x_offset, int16_t y_offset)> process_room = [&](
unordered_map<int16_t, pair<int16_t, int16_t>>& ret, int16_t room_id,
int16_t x_offset, int16_t y_offset) {
if (!remaining_room_ids.erase(room_id)) {
return;
}
ret.emplace(room_id, make_pair(x_offset, y_offset));
process_room(ret, room_id - 1, x_offset - 1, y_offset);
process_room(ret, room_id + 1, x_offset + 1, y_offset);
process_room(ret, room_id - 100, x_offset, y_offset - 1);
process_room(ret, room_id + 100, x_offset, y_offset + 1);
};
// This function generates a placement map with nonnegative offsets that
// contains the given room
vector<unordered_map<int16_t, pair<int16_t, int16_t>>> ret;
auto process_component = [&](int16_t start_room_id) {
ret.emplace_back();
auto& placement_map = ret.back();
process_room(placement_map, start_room_id, 0, 0);
if (placement_map.empty()) {
ret.pop_back();
} else {
// Make all offsets nonnegative
int16_t delta_x = 0, delta_y = 0;
for (const auto& it : placement_map) {
if (it.second.first < delta_x) {
delta_x = it.second.first;
}
if (it.second.second < delta_y) {
delta_y = it.second.second;
}
}
for (auto& it : placement_map) {
it.second.first -= delta_x;
it.second.second -= delta_y;
}
}
};
// Start at room 1000 (for main level) and 10000 (for bonus level) and go
// outward. Both of these start room IDs seem to be hardcoded
process_component(1000);
process_component(10000);
// If there are any rooms left over, process them individually
while (!remaining_room_ids.empty()) {
size_t starting_size = remaining_room_ids.size();
process_component(*remaining_room_ids.begin());
if (remaining_room_ids.size() >= starting_size) {
throw logic_error("did not make progress generating room placement maps");
}
}
return ret;
}
int main(int argc, char** argv) {
if (argc < 2) {
throw invalid_argument("no filename given");
}
const string filename = argv[1];
const string out_prefix = (argc < 3) ? filename : argv[2];
ResourceFile rf(parse_resource_fork(load_file(filename + "/..namedfork/rsrc")));
const uint32_t room_type = 0x506C766C; // Plvl
auto room_resource_ids = rf.all_resources_of_type(room_type);
auto sprites_pict = rf.decode_PICT(130); // hardcoded ID for all worlds
auto& sprites = sprites_pict.image;
// Assemble index for animated sprites
unordered_map<int16_t, pair<shared_ptr<const Image>, size_t>> enemy_image_locations;
{
size_t next_type_id = 0;
for (int16_t id = 1000; ; id++) {
if (!rf.resource_exists(RESOURCE_TYPE_PICT, id)) {
break;
}
auto pict = rf.decode_PICT(id);
shared_ptr<const Image> img(new Image(pict.image));
for (size_t z = 0; z < img->get_height(); z += 80) {
enemy_image_locations.emplace(next_type_id, make_pair(img, z));
next_type_id++;
}
}
}
// Decode the default ppat (we'll use it if a room references a missing ppat,
// which apparently happens quite a lot - it looks like the ppat id field used
// to be the room id field and they just never updated it after implementing
// the custom backgrounds feature)
unordered_map<int16_t, const Image> background_ppat_cache;
const Image* default_background_ppat = &background_ppat_cache.emplace(1000,
rf.decode_ppat(1000).pattern).first->second;
size_t component_number = 0;
auto placement_maps = generate_room_placement_maps(room_resource_ids);
for (const auto& placement_map : placement_maps) {
// First figure out the width and height of this component
uint16_t w_rooms = 0, h_rooms = 0;
bool component_contains_start = false, component_contains_bonus_start = false;
for (const auto& it : placement_map) {
if (it.second.first >= w_rooms) {
w_rooms = it.second.first + 1;
}
if (it.second.second >= h_rooms) {
h_rooms = it.second.second + 1;
}
if (it.first == 1000) {
component_contains_start = true;
} else if (it.first == 10000) {
component_contains_bonus_start = true;
}
}
// Then render the rooms
Image result(20 * 32 * w_rooms, 20 * 20 * h_rooms);
result.clear(0x202020FF);
for (auto it : placement_map) {
int16_t room_id = it.first;
size_t room_x = it.second.first;
size_t room_y = it.second.second;
size_t room_px = 20 * 32 * room_x;
size_t room_py = 20 * 20 * room_y;
string room_data = rf.get_resource(room_type, room_id)->data;
if (room_data.size() != sizeof(MonkeyShinesRoom)) {
fprintf(stderr, "warning: room 0x%04hX is not the correct size (expected %zu bytes, got %zu bytes)\n",
room_id, sizeof(MonkeyShinesRoom), room_data.size());
result.fill_rect(room_px, room_py, 32 * 20, 20 * 20, 0xFF00FFFF);
continue;
}
const auto* room = reinterpret_cast<const MonkeyShinesRoom*>(room_data.data());
// Render the appropriate ppat in the background of every room. We don't
// use Image::blit() here just in case the room dimensions aren't a
// multiple of the ppat dimensions
const Image* background_ppat = nullptr;
try {
background_ppat = &background_ppat_cache.at(room->background_ppat_id);
} catch (const out_of_range&) {
try {
auto ppat_id = room->background_ppat_id;
background_ppat = &background_ppat_cache.emplace(ppat_id,
rf.decode_ppat(room->background_ppat_id).pattern).first->second;
} catch (const exception& e) {
fprintf(stderr, "warning: room %hd uses ppat %hd but it can\'t be decoded (%s)\n",
room_id, room->background_ppat_id.load(), e.what());
background_ppat = default_background_ppat;
}
}
if (background_ppat) {
for (size_t y = 0; y < 400; y++) {
for (size_t x = 0; x < 640; x++) {
uint32_t c = background_ppat->read_pixel(x % background_ppat->get_width(),
y % background_ppat->get_height());
result.write_pixel(room_px + x, room_py + y, c);
}
}
} else {
result.fill_rect(room_px, room_py, 640, 400, 0xFF00FFFF);
}
// Render tiles. Each tile is 20x20
for (size_t y = 0; y < 20; y++) {
for (size_t x = 0; x < 32; x++) {
// Looks like there are 21 rows of sprites in PICT 130, with 16 on
// each row
uint16_t tile_id = room->tile_ids[x * 20 + y];
if (tile_id == 0) {
continue;
}
tile_id--;
size_t tile_x = 0xFFFFFFFF;
size_t tile_y = 0xFFFFFFFF;
if (tile_id < 0x90) { // <0x20: walls, <0x50: jump-through platforms, <0x90: scenery
tile_x = tile_id % 16;
tile_y = tile_id / 16;
} else if (tile_id < 0xA0) { // 2-frame animated tiles
tile_x = tile_id & 0x0F;
tile_y = 11;
} else if (tile_id < 0xB0) { // rollers (usually)
tile_x = tile_id & 0x0F;
tile_y = 15;
} else if (tile_id < 0xB2) { // collapsing floor
tile_x = 0;
tile_y = 17 + (tile_id & 1);
} else if (tile_id < 0xC0) { // 2-frame animated tiles
tile_x = tile_id & 0x0F;
tile_y = 11;
} else if (tile_id < 0xD0) { // 2-frame animated tiles
tile_x = tile_id & 0x0F;
tile_y = 13;
} else if (tile_id < 0xF0) { // more scenery
tile_x = tile_id & 0x0F;
tile_y = (tile_id - 0x40) / 16;
}
// TODO: there may be more cases than the above; figure them out
if (tile_x == 0xFFFFFFFF || tile_y == 0xFFFFFFFF) {
result.fill_rect(room_px + x * 20, room_py + y * 20, 20, 20, 0xFF00FFFF);
fprintf(stderr, "warning: no known tile for %02hX (room %hd, x=%zu, y=%zu)\n",
tile_id, room_id, x, y);
} else {
for (size_t py = 0; py < 20; py++) {
for (size_t px = 0; px < 20; px++) {
uint64_t r, g, b;
sprites.read_pixel(tile_x * 20 + px, tile_y * 40 + py + 20,
&r, &g, &b);
if (r && g && b) {
sprites.read_pixel(tile_x * 20 + px, tile_y * 40 + py,
&r, &g, &b);
result.write_pixel(room_px + x * 20 + px, room_py + y * 20 + py,
r, g, b, 0xFF);
}
}
}
}
}
}
// Render enemies
for (size_t z = 0; z < room->enemy_count; z++) {
// It looks like the y coords are off by 80 pixels because of the HUD,
// which renders at the top. High-quality engineering!
size_t enemy_px = room_px + room->enemies[z].x_pixels;
size_t enemy_py = room_py + room->enemies[z].y_pixels - 80;
try {
const auto& image_loc = enemy_image_locations.at(room->enemies[z].type);
const auto& enemy_pict = image_loc.first;
size_t enemy_pict_py = image_loc.second;
for (size_t py = 0; py < 40; py++) {
for (size_t px = 0; px < 40; px++) {
uint32_t c = enemy_pict->read_pixel(px, enemy_pict_py + py);
uint32_t mc = enemy_pict->read_pixel(px, enemy_pict_py + py + 40);
uint32_t ec = result.read_pixel(enemy_px + px, enemy_py + py);
result.write_pixel(enemy_px + px, enemy_py + py, (c & mc) | (ec & ~mc));
}
}
} catch (const out_of_range&) {
result.fill_rect(enemy_px, enemy_px, 20, 20, 0xFF8000FF);
result.draw_text(enemy_px, enemy_px, 0x000000FF, "%04hX",
room->enemies[z].type.load());
}
// Draw a bounding box to show where its range of motion is
size_t x_min = room->enemies[z].x_speed ? room->enemies[z].x_min : room->enemies[z].x_pixels;
size_t x_max = (room->enemies[z].x_speed ? room->enemies[z].x_max : room->enemies[z].x_pixels) + 39;
size_t y_min = (room->enemies[z].y_speed ? room->enemies[z].y_min : room->enemies[z].y_pixels) - 80;
size_t y_max = (room->enemies[z].y_speed ? room->enemies[z].y_max : room->enemies[z].y_pixels) + 39 - 80;
result.draw_horizontal_line(room_px + x_min, room_px + x_max,
room_py + y_min, 0, 0xFF8000FF);
result.draw_horizontal_line(room_px + x_min, room_px + x_max,
room_py + y_max, 0, 0xFF8000FF);
result.draw_vertical_line(room_px + x_min, room_py + y_min,
room_py + y_max, 0, 0xFF8000FF);
result.draw_vertical_line(room_px + x_max, room_py + y_min,
room_py + y_max, 0, 0xFF8000FF);
// Draw its initial velocity as a line from the center
if (room->enemies[z].x_speed || room->enemies[z].y_speed) {
result.fill_rect(enemy_px + 19, enemy_py + 19, 3, 3, 0xFF8000FF);
result.draw_line(enemy_px + 20, enemy_py + 20,
enemy_px + 20 + room->enemies[z].x_speed * 10,
enemy_py + 20 + room->enemies[z].y_speed * 10, 0xFF8000FF);
}
}
// Annotate bonuses with ids
for (size_t z = 0; z < room->bonus_count; z++) {
const auto& bonus = room->bonuses[z];
result.draw_text(room_px + bonus.x_pixels,
room_py + bonus.y_pixels - 80, 0xFFFFFFFF, "%02hX", bonus.id.load());
}
// If this is a starting room, mark the player start location with an
// arrow and the label "START"
if (room_id == 1000 || room_id == 10000) {
size_t x_min = room->player_start_x;
size_t x_max = room->player_start_x + 39;
size_t y_min = room->player_start_y - 80;
size_t y_max = room->player_start_y + 39 - 80;
result.draw_horizontal_line(room_px + x_min, room_px + x_max,
room_py + y_min, 0, 0x00FF80FF);
result.draw_horizontal_line(room_px + x_min, room_px + x_max,
room_py + y_max, 0, 0x00FF80FF);
result.draw_vertical_line(room_px + x_min, room_py + y_min,
room_py + y_max, 0, 0x00FF80FF);
result.draw_vertical_line(room_px + x_max, room_py + y_min,
room_py + y_max, 0, 0x00FF80FF);
result.draw_text(room_px + x_min + 2, room_py + y_min + 2,
0xFFFFFFFF, 0x00000080, "START");
}
result.draw_text(room_px + 2, room_py + 2, 0xFFFFFFFF, 0x00000080,
"Room %hd", room_id);
}
string result_filename;
if (component_contains_start && component_contains_bonus_start) {
result_filename = out_prefix + "_world_and_bonus.bmp";
} else if (component_contains_start) {
result_filename = out_prefix + "_world.bmp";
} else if (component_contains_bonus_start) {
result_filename = out_prefix + "_bonus.bmp";
} else {
result_filename = string_printf("%s_%zu.bmp", out_prefix.c_str(),
component_number);
component_number++;
}
result.save(result_filename.c_str(), Image::Format::WINDOWS_BITMAP);
fprintf(stderr, "... %s\n", result_filename.c_str());
}
return 0;
}
| 38.432558 | 113 | 0.62084 | fuzziqersoftware |
09dbed8a7f6d0555307598f6c79b491a822cbca0 | 396 | hpp | C++ | src/backgroundParticles.hpp | minhoolee/SaveTheWorld | e9d65092237db38fa475d5e32d7b71c477d303dd | [
"BSD-3-Clause"
] | null | null | null | src/backgroundParticles.hpp | minhoolee/SaveTheWorld | e9d65092237db38fa475d5e32d7b71c477d303dd | [
"BSD-3-Clause"
] | null | null | null | src/backgroundParticles.hpp | minhoolee/SaveTheWorld | e9d65092237db38fa475d5e32d7b71c477d303dd | [
"BSD-3-Clause"
] | null | null | null | #ifndef BACKGROUND_PARTICLES_HPP
#define BACKGROUND_PARTICLES_HPP
#include <SFML/Graphics.hpp>
#include <array>
class BackgroundParticles {
public:
BackgroundParticles(int n);
void animateParticlesIdle();
void animateParticlesMovement();
std::array<sf::CircleShape, 50> backgroundParticles;
private:
int num_particles;
};
#endif // BACKGROUND_PARTICLES_HPP
| 18.857143 | 55 | 0.739899 | minhoolee |
09dda72d49223f6f6f3d62cb095ff8988e65c2b8 | 1,489 | cpp | C++ | src/generated/ldb_trooppagecondition_flags.cpp | Albeleon/liblcf | d9dd24d0026b3ab36adb291d205c405122a4332c | [
"MIT"
] | null | null | null | src/generated/ldb_trooppagecondition_flags.cpp | Albeleon/liblcf | d9dd24d0026b3ab36adb291d205c405122a4332c | [
"MIT"
] | null | null | null | src/generated/ldb_trooppagecondition_flags.cpp | Albeleon/liblcf | d9dd24d0026b3ab36adb291d205c405122a4332c | [
"MIT"
] | null | null | null | /* !!!! GENERATED FILE - DO NOT EDIT !!!!
* --------------------------------------
*
* This file is part of liblcf. Copyright (c) 2017 liblcf authors.
* https://github.com/EasyRPG/liblcf - https://easyrpg.org
*
* liblcf is Free/Libre Open Source Software, released under the MIT License.
* For the full copyright and license information, please view the COPYING
* file that was distributed with this source code.
*/
/*
* Headers
*/
#include "ldb_reader.h"
#include "ldb_chunks.h"
#include "reader_struct.h"
// Read TroopPageCondition.
typedef RPG::TroopPageCondition::Flags flags_type;
template <>
char const* const Flags<flags_type>::name("TroopPageCondition_Flags");
template <>
const Flags<flags_type>::Flag* Flags<flags_type>::flags[] = {
new Flags<flags_type>::Flag(&flags_type::switch_a, "switch_a"),
new Flags<flags_type>::Flag(&flags_type::switch_b, "switch_b"),
new Flags<flags_type>::Flag(&flags_type::variable, "variable"),
new Flags<flags_type>::Flag(&flags_type::turn, "turn"),
new Flags<flags_type>::Flag(&flags_type::fatigue, "fatigue"),
new Flags<flags_type>::Flag(&flags_type::enemy_hp, "enemy_hp"),
new Flags<flags_type>::Flag(&flags_type::actor_hp, "actor_hp"),
new Flags<flags_type>::Flag(&flags_type::turn_enemy, "turn_enemy"),
new Flags<flags_type>::Flag(&flags_type::turn_actor, "turn_actor"),
new Flags<flags_type>::Flag(&flags_type::command_actor, "command_actor"),
NULL
};
template <>
const uint32_t Flags<flags_type>::max_size = 2;
| 33.088889 | 77 | 0.709872 | Albeleon |
09df4b2eb1349a31d6bcc3ae7c01a67b8388a4d3 | 6,620 | cpp | C++ | src/models/reviewsmodel.cpp | Maledictus/harbour-sailreads | 2c58aa266ef2dacb790b857c3b6aced937da5c0e | [
"MIT"
] | 3 | 2019-01-05T09:54:19.000Z | 2019-02-26T09:20:23.000Z | src/models/reviewsmodel.cpp | Maledictus/harbour-sailreads | 2c58aa266ef2dacb790b857c3b6aced937da5c0e | [
"MIT"
] | 1 | 2019-01-03T10:02:01.000Z | 2019-01-03T14:08:16.000Z | src/models/reviewsmodel.cpp | Maledictus/harbour-sailreads | 2c58aa266ef2dacb790b857c3b6aced937da5c0e | [
"MIT"
] | null | null | null | /*
Copyright (c) 2018-2019 Oleg Linkin <maledictusdemagog@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include "reviewsmodel.h"
#include "../sailreadsmanager.h"
#include "../objects/book.h"
#include "../objects/review.h"
namespace Sailreads
{
ReviewsModel::ReviewsModel(QObject *parent)
: BaseModel<ReviewPtr>(parent)
, m_UserId("")
, m_BookShelfId(0)
, m_SortOrder(Qt::DescendingOrder)
, m_SortField("date_added")
, m_HasMore(true)
, m_CurrentPage(1)
{
}
QString ReviewsModel::GetUserId() const
{
return m_UserId;
}
void ReviewsModel::SetUserId(const QString& id)
{
if (m_UserId != id) {
m_UserId = id;
emit userIdChanged();
}
}
quint64 ReviewsModel::GetBookShelfId() const
{
return m_BookShelfId;
}
void ReviewsModel::SetBookShelfId(quint64 id)
{
if (m_BookShelfId != id) {
m_BookShelfId = id;
emit bookShelfIdChanged();
}
}
QString ReviewsModel::GetBookShelf() const
{
return m_BookShelf;
}
void ReviewsModel::SetBookShelf(const QString& shelf)
{
if (m_BookShelf != shelf) {
m_BookShelf = shelf;
emit bookShelfChanged();
}
}
bool ReviewsModel::GetHasMore() const
{
return m_HasMore;
}
void ReviewsModel::SetHasMore(bool has)
{
if (m_HasMore != has) {
m_HasMore = has;
emit hasMoreChanged();
}
}
Qt::SortOrder ReviewsModel::GetSortOrder() const
{
return m_SortOrder;
}
void ReviewsModel::SetSortOrder(Qt::SortOrder sortOrder)
{
if (m_SortOrder != sortOrder) {
m_SortOrder = sortOrder;
emit sortOrdereChanged();
}
}
QString ReviewsModel::GetSortField() const
{
return m_SortField;
}
void ReviewsModel::SetSortField(const QString& sortField)
{
if (m_SortField != sortField) {
m_SortField = sortField;
emit sortFieldChanged();
}
}
QVariant ReviewsModel::data(const QModelIndex& index, int role) const
{
if (index.row() > m_Items.count() - 1 || index.row() < 0) {
return QVariant();
}
const auto& review = m_Items.at(index.row());
switch (role) {
case Id:
return review->GetId();
case Book:
return QVariant::fromValue(review->GetBook());
case Rating:
return review->GetRating();
case LikesCount:
return review->GetLikesCount();
case Shelves:
return review->GetShelvesList();
case AddedDate:
return review->GetAddedDate();
case UpdatedDate:
return review->GetUpdatedDate();
case ReadDate:
return review->GetReadDate();
case StartedDate:
return review->GetStartedDate();
case ReadCount:
return review->GetReadCount();
case Body:
return review->GetBody();
case CommentsCount:
return review->GetCommentsCount();
case OwnedCount:
return review->GetOwned();
case Url:
return review->GetUrl();
case ReviewItem:
return QVariant::fromValue(review.get());
default:
return QVariant();
}
}
QHash<int, QByteArray> ReviewsModel::roleNames() const
{
QHash<int, QByteArray> roles;
roles[Id] = "reviewId";
roles[Book] = "reviewBook";
roles[Rating] = "reviewRating";
roles[LikesCount] = "reviewLikesCount";
roles[Shelves] = "reviewShelves";
roles[AddedDate] = "reviewAddDate";
roles[UpdatedDate] = "reviewUpdateDate";
roles[ReadDate] = "reviewReadDate";
roles[StartedDate] = "reviewStartDate";
roles[ReadCount] = "reviewReadCount";
roles[Body] = "reviewBody";
roles[CommentsCount] = "reviewCommentsCount";
roles[OwnedCount] = "reviewOwnedCount";
roles[Url] = "reviewUrl";
roles[ReviewItem] = "reviewReview";
return roles;
}
void ReviewsModel::classBegin()
{
connect(SailreadsManager::Instance(), &SailreadsManager::gotReviews,
this, &ReviewsModel::handleGotReviews);
connect(SailreadsManager::Instance(), &SailreadsManager::gotReviewInfo,
this, &ReviewsModel::handleGotReviewInfo);
}
void ReviewsModel::componentComplete()
{
}
void ReviewsModel::fetchMoreContent()
{
if (m_BookShelf.isEmpty() || m_UserId.isEmpty()) {
SetHasMore(false);
return;
}
SailreadsManager::Instance()->loadReviews(this, m_UserId, m_BookShelf, m_CurrentPage,
m_SortOrder, m_SortField);
}
void ReviewsModel::loadReviews()
{
if (m_BookShelf.isEmpty() || m_UserId.isEmpty()) {
return;
}
SailreadsManager::Instance()->loadReviews(this, m_UserId, m_BookShelf, 1,
m_SortOrder, m_SortField, false);
}
void ReviewsModel::handleGotReviews(quint64 booksShelfId, const CountedItems<ReviewPtr>& reviews)
{
if (m_BookShelfId != booksShelfId) {
return;
}
if (!reviews.m_BeginIndex && !reviews.m_EndIndex)
{
Clear();
}
else if (reviews.m_BeginIndex == 1) {
m_CurrentPage = 1;
SetItems(reviews.m_Items);
}
else {
AddItems(reviews.m_Items);
}
SetHasMore(reviews.m_EndIndex != reviews.m_Count);
if (m_HasMore) {
++m_CurrentPage;
}
}
void ReviewsModel::handleGotReviewInfo(const ReviewInfo& reviewInfo)
{
auto it = std::find_if(m_Items.begin(), m_Items.end(),
[reviewInfo](decltype(m_Items.front()) review)
{ return reviewInfo.m_ReviewId == review->GetId(); });
if (it == m_Items.end() || m_BookShelf == reviewInfo.m_ReadStatus) {
return;
}
const int pos = std::distance(m_Items.begin(), it);
beginRemoveRows(QModelIndex(), pos, pos);
m_Items.removeAt(pos);
endRemoveRows();
}
}
| 25.960784 | 97 | 0.666465 | Maledictus |
09e46675dfb06c0631712c0b461ef44d4a067078 | 1,179 | hpp | C++ | engine/src/vulkan/mesh/Mesh.hpp | Velikss/Bus-Simulator | 13bf0b66b9b44e3f4cb1375fc363720ea8f23e19 | [
"MIT"
] | null | null | null | engine/src/vulkan/mesh/Mesh.hpp | Velikss/Bus-Simulator | 13bf0b66b9b44e3f4cb1375fc363720ea8f23e19 | [
"MIT"
] | null | null | null | engine/src/vulkan/mesh/Mesh.hpp | Velikss/Bus-Simulator | 13bf0b66b9b44e3f4cb1375fc363720ea8f23e19 | [
"MIT"
] | null | null | null | #pragma once
#include <pch.hpp>
#include <vulkan/geometry/Geometry.hpp>
#include <vulkan/texture/Texture.hpp>
#include <vulkan/util/Invalidatable.hpp>
class cMesh : public cInvalidatable
{
private:
cGeometry* ppGeometry;
cTexture* ppTexture;
cTexture* ppMaterial;
public:
cMesh(cGeometry* pGeometry, cTexture* pTexture, cTexture* pMaterial);
cMesh(cGeometry* pGeometry, cTexture* pTexture);
cGeometry* GetGeometry();
cTexture* GetTexture();
cTexture* GetMaterial();
void SetTexture(cTexture* pTexture);
};
cMesh::cMesh(cGeometry* pGeometry, cTexture* pTexture, cTexture* pMaterial)
{
assert(pGeometry != nullptr);
assert(pTexture != nullptr);
assert(pMaterial != nullptr);
ppGeometry = pGeometry;
ppTexture = pTexture;
ppMaterial = pMaterial;
}
cMesh::cMesh(cGeometry* pGeometry, cTexture* pTexture) : cMesh(pGeometry, pTexture, pTexture)
{
}
cGeometry* cMesh::GetGeometry()
{
return ppGeometry;
}
cTexture* cMesh::GetTexture()
{
return ppTexture;
}
cTexture* cMesh::GetMaterial()
{
return ppMaterial;
}
void cMesh::SetTexture(cTexture* pTexture)
{
ppTexture = pTexture;
Invalidate();
}
| 19.327869 | 93 | 0.706531 | Velikss |
09e46bd9c7d97d85a2cc98e44bbe3466a6f4d569 | 688 | cpp | C++ | EasyFramework3d/base/util/FileException.cpp | sizilium/FlexChess | f12b94e800ddcb00535067eca3b560519c9122e0 | [
"MIT"
] | null | null | null | EasyFramework3d/base/util/FileException.cpp | sizilium/FlexChess | f12b94e800ddcb00535067eca3b560519c9122e0 | [
"MIT"
] | null | null | null | EasyFramework3d/base/util/FileException.cpp | sizilium/FlexChess | f12b94e800ddcb00535067eca3b560519c9122e0 | [
"MIT"
] | null | null | null | #include <vs/base/util/FileException.h>
namespace vs
{
namespace base
{
namespace util
{
FileException::FileException(string fileOfOccuredError, string placeOfOccuredError,
string description, string badFile)
:Exception(fileOfOccuredError, placeOfOccuredError, description), corruptedFile(badFile)
{}
FileException::FileException(string fileOfOccuredError, int placeOfOccuredError,
string description, string badFile)
:Exception(fileOfOccuredError, placeOfOccuredError, description), corruptedFile(badFile)
{}
FileException::~FileException() throw()
{
}
string FileException::getCorruptedFile() const
{
return corruptedFile;
}
} // util
} // base
} // vs
| 20.235294 | 88 | 0.768895 | sizilium |
09e8b899528544d05f6b13874715477b89dd7648 | 755 | cpp | C++ | 238.cpp | mudit1729/LeetCode | 766929544b1c87ed4afed120f460d5a4053f6a33 | [
"MIT"
] | null | null | null | 238.cpp | mudit1729/LeetCode | 766929544b1c87ed4afed120f460d5a4053f6a33 | [
"MIT"
] | null | null | null | 238.cpp | mudit1729/LeetCode | 766929544b1c87ed4afed120f460d5a4053f6a33 | [
"MIT"
] | null | null | null |
class Solution {
public:
vector<int> productExceptSelf(vector<int>& nums) {
vector<int> left;
vector<int> right;
vector<int> sol;
int leftProduct = 1;
int rightProduct = 1;
int sz = nums.size();
left.resize(sz);
right.resize(sz);
for(int i = 0; i<sz; i++){
leftProduct = leftProduct*nums[i];
rightProduct = rightProduct*nums[sz-1-i];
left[i] = leftProduct;
right[sz-i-1] = rightProduct;
}
for(int i=0; i<sz; i++){
if(i==0) sol.push_back(right[i+1]);
else if (i==sz-1) sol.push_back(left[i-1]);
else sol.push_back(left[i-1]*right[i+1]);
}
return sol;
}
}; | 29.038462 | 55 | 0.496689 | mudit1729 |
09ea20c17c26a573a528e218640c675dabbadc80 | 4,543 | cpp | C++ | test/test-str-convert.cpp | codalogic/cl-utils | 996452272d4c09b8df7928abdaea75b0e786a244 | [
"BSD-3-Clause"
] | null | null | null | test/test-str-convert.cpp | codalogic/cl-utils | 996452272d4c09b8df7928abdaea75b0e786a244 | [
"BSD-3-Clause"
] | null | null | null | test/test-str-convert.cpp | codalogic/cl-utils | 996452272d4c09b8df7928abdaea75b0e786a244 | [
"BSD-3-Clause"
] | null | null | null | //----------------------------------------------------------------------------
// Copyright (c) 2016, Codalogic Ltd (http://www.codalogic.com)
// All rights reserved.
//
// The license for this file is based on the BSD-3-Clause license
// (http://www.opensource.org/licenses/BSD-3-Clause).
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// - Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// - Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// - Neither the name Codalogic Ltd nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//----------------------------------------------------------------------------
#include "cl-utils/str-convert.h"
#include <string>
#include "clunit.h"
using namespace clutils;
TFEATURE( "convert - Unchecked from_string()" )
{
TTEST( from_string<int>( "123" ) == 123 );
TTEST( from_string<int>( " 123" ) == 123 );
TTEST( from_string<float>( "123.5" ) == 123.5 );
TTEST( from_string<bool>( "false" ) == false );
TTEST( from_string<bool>( "False" ) == false );
TTEST( from_string<bool>( "FALSE" ) == false );
TTEST( from_string<bool>( "true" ) == true );
TTEST( from_string<bool>( "True" ) == true );
TTEST( from_string<bool>( "TRUE" ) == true );
TTEST( from_string<bool>( "0" ) == false );
TTEST( from_string<bool>( "1" ) == true );
TTEST( from_string<bool>( " false" ) == false );
TTEST( from_string<bool>( " true" ) == true );
TTEST( from_string<bool>( " 0" ) == false );
TTEST( from_string<bool>( " 1" ) == true );
// Error cases
TTEST( from_string<int>( "foo" ) == 0 );
}
TFEATURE( "convert - Checked from_string()" )
{
int iout;
TTEST( from_string( iout, "123" ) == true );
TTEST( iout == 123 );
TTEST( from_string( iout, " 123" ) == true );
TTEST( iout == 123 );
float fout;
TTEST( from_string( fout, "123.5" ) == true );
TTEST( fout == 123.5 );
bool bout;
TTEST( from_string( bout, "false" ) == true );
TTEST( bout == false );
TTEST( from_string( bout, "False" ) == true );
TTEST( bout == false );
TTEST( from_string( bout, "FALSE" ) == true );
TTEST( bout == false );
TTEST( from_string( bout, "true" ) == true );
TTEST( bout == true );
TTEST( from_string( bout, "True" ) == true );
TTEST( bout == true );
TTEST( from_string( bout, "TRUE" ) == true );
TTEST( bout == true );
TTEST( from_string( bout, "0" ) == true );
TTEST( bout == false );
TTEST( from_string( bout, "1" ) == true );
TTEST( bout == true );
TTEST( from_string( bout, " false" ) == true );
TTEST( bout == false );
TTEST( from_string( bout, " true" ) == true );
TTEST( bout == true );
TTEST( from_string( bout, " 0" ) == true );
TTEST( bout == false );
TTEST( from_string( bout, " 1" ) == true );
TTEST( bout == true );
TTEST( from_string( iout, "foo" ) == false );
TTEST( from_string( bout, "foo" ) == false );
}
TFEATURE( "convert - to_string()" )
{
TTEST( to_string( "foo" ) == "foo" );
TTEST( to_string( 123 ) == "123" );
TTEST( to_string( 123.5 ) == "123.5" );
TTEST( to_string( 0 ) == "0" );
TTEST( to_string( 1 ) == "1" );
TTEST( to_string( true ) == "true" );
TTEST( to_string( false ) == "false" );
}
| 36.344 | 78 | 0.605107 | codalogic |
09ebcc68dfbb4af9f94e0032a83a7b566a3ffa0f | 30,521 | cc | C++ | proto/echo_test.pb.cc | iwtbabc/irpc | 647b126450b986e73b350ed451c90d48ec3a420c | [
"MIT"
] | 1 | 2018-08-28T12:01:01.000Z | 2018-08-28T12:01:01.000Z | proto/echo_test.pb.cc | majianfei/irpc | 647b126450b986e73b350ed451c90d48ec3a420c | [
"MIT"
] | null | null | null | proto/echo_test.pb.cc | majianfei/irpc | 647b126450b986e73b350ed451c90d48ec3a420c | [
"MIT"
] | 1 | 2018-07-28T04:53:12.000Z | 2018-07-28T04:53:12.000Z | // Generated by the protocol buffer compiler. DO NOT EDIT!
// source: echo_test.proto
#include "echo_test.pb.h"
#include <algorithm>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// This is a temporary google only hack
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
#include "third_party/protobuf/version.h"
#endif
// @@protoc_insertion_point(includes)
namespace echo {
class RequestMessageDefaultTypeInternal {
public:
::google::protobuf::internal::ExplicitlyConstructed<RequestMessage>
_instance;
} _RequestMessage_default_instance_;
class ResponseMessageDefaultTypeInternal {
public:
::google::protobuf::internal::ExplicitlyConstructed<ResponseMessage>
_instance;
} _ResponseMessage_default_instance_;
} // namespace echo
namespace protobuf_echo_5ftest_2eproto {
void InitDefaultsRequestMessageImpl() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
::google::protobuf::internal::InitProtobufDefaults();
#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
{
void* ptr = &::echo::_RequestMessage_default_instance_;
new (ptr) ::echo::RequestMessage();
::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
}
::echo::RequestMessage::InitAsDefaultInstance();
}
void InitDefaultsRequestMessage() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &InitDefaultsRequestMessageImpl);
}
void InitDefaultsResponseMessageImpl() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
::google::protobuf::internal::InitProtobufDefaultsForceUnique();
#else
::google::protobuf::internal::InitProtobufDefaults();
#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
{
void* ptr = &::echo::_ResponseMessage_default_instance_;
new (ptr) ::echo::ResponseMessage();
::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
}
::echo::ResponseMessage::InitAsDefaultInstance();
}
void InitDefaultsResponseMessage() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &InitDefaultsResponseMessageImpl);
}
::google::protobuf::Metadata file_level_metadata[2];
const ::google::protobuf::ServiceDescriptor* file_level_service_descriptors[1];
const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::echo::RequestMessage, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::echo::RequestMessage, id_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::echo::RequestMessage, msg_),
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::echo::ResponseMessage, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
~0u, // no _weak_field_map_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::echo::ResponseMessage, id_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::echo::ResponseMessage, msg_),
};
static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
{ 0, -1, sizeof(::echo::RequestMessage)},
{ 7, -1, sizeof(::echo::ResponseMessage)},
};
static ::google::protobuf::Message const * const file_default_instances[] = {
reinterpret_cast<const ::google::protobuf::Message*>(&::echo::_RequestMessage_default_instance_),
reinterpret_cast<const ::google::protobuf::Message*>(&::echo::_ResponseMessage_default_instance_),
};
void protobuf_AssignDescriptors() {
AddDescriptors();
::google::protobuf::MessageFactory* factory = NULL;
AssignDescriptors(
"echo_test.proto", schemas, file_default_instances, TableStruct::offsets, factory,
file_level_metadata, NULL, file_level_service_descriptors);
}
void protobuf_AssignDescriptorsOnce() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors);
}
void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
void protobuf_RegisterTypes(const ::std::string&) {
protobuf_AssignDescriptorsOnce();
::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 2);
}
void AddDescriptorsImpl() {
InitDefaults();
static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
"\n\017echo_test.proto\022\004echo\")\n\016RequestMessag"
"e\022\n\n\002id\030\001 \001(\005\022\013\n\003msg\030\002 \001(\t\"*\n\017ResponseMe"
"ssage\022\n\n\002id\030\001 \001(\005\022\013\n\003msg\030\002 \001(\t2B\n\013EchoSe"
"rvice\0223\n\004echo\022\024.echo.RequestMessage\032\025.ec"
"ho.ResponseMessageB\006\200\001\001\220\001\001b\006proto3"
};
::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
descriptor, 194);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"echo_test.proto", &protobuf_RegisterTypes);
}
void AddDescriptors() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at dynamic initialization time.
struct StaticDescriptorInitializer {
StaticDescriptorInitializer() {
AddDescriptors();
}
} static_descriptor_initializer;
} // namespace protobuf_echo_5ftest_2eproto
namespace echo {
// ===================================================================
void RequestMessage::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int RequestMessage::kIdFieldNumber;
const int RequestMessage::kMsgFieldNumber;
#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
RequestMessage::RequestMessage()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
::protobuf_echo_5ftest_2eproto::InitDefaultsRequestMessage();
}
SharedCtor();
// @@protoc_insertion_point(constructor:echo.RequestMessage)
}
RequestMessage::RequestMessage(const RequestMessage& from)
: ::google::protobuf::Message(),
_internal_metadata_(NULL),
_cached_size_(0) {
_internal_metadata_.MergeFrom(from._internal_metadata_);
msg_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
if (from.msg().size() > 0) {
msg_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.msg_);
}
id_ = from.id_;
// @@protoc_insertion_point(copy_constructor:echo.RequestMessage)
}
void RequestMessage::SharedCtor() {
msg_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
id_ = 0;
_cached_size_ = 0;
}
RequestMessage::~RequestMessage() {
// @@protoc_insertion_point(destructor:echo.RequestMessage)
SharedDtor();
}
void RequestMessage::SharedDtor() {
msg_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void RequestMessage::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* RequestMessage::descriptor() {
::protobuf_echo_5ftest_2eproto::protobuf_AssignDescriptorsOnce();
return ::protobuf_echo_5ftest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}
const RequestMessage& RequestMessage::default_instance() {
::protobuf_echo_5ftest_2eproto::InitDefaultsRequestMessage();
return *internal_default_instance();
}
RequestMessage* RequestMessage::New(::google::protobuf::Arena* arena) const {
RequestMessage* n = new RequestMessage;
if (arena != NULL) {
arena->Own(n);
}
return n;
}
void RequestMessage::Clear() {
// @@protoc_insertion_point(message_clear_start:echo.RequestMessage)
::google::protobuf::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
msg_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
id_ = 0;
_internal_metadata_.Clear();
}
bool RequestMessage::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:echo.RequestMessage)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// int32 id = 1;
case 1: {
if (static_cast< ::google::protobuf::uint8>(tag) ==
static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &id_)));
} else {
goto handle_unusual;
}
break;
}
// string msg = 2;
case 2: {
if (static_cast< ::google::protobuf::uint8>(tag) ==
static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_msg()));
DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
this->msg().data(), static_cast<int>(this->msg().length()),
::google::protobuf::internal::WireFormatLite::PARSE,
"echo.RequestMessage.msg"));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:echo.RequestMessage)
return true;
failure:
// @@protoc_insertion_point(parse_failure:echo.RequestMessage)
return false;
#undef DO_
}
void RequestMessage::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:echo.RequestMessage)
::google::protobuf::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// int32 id = 1;
if (this->id() != 0) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->id(), output);
}
// string msg = 2;
if (this->msg().size() > 0) {
::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
this->msg().data(), static_cast<int>(this->msg().length()),
::google::protobuf::internal::WireFormatLite::SERIALIZE,
"echo.RequestMessage.msg");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->msg(), output);
}
if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
(::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output);
}
// @@protoc_insertion_point(serialize_end:echo.RequestMessage)
}
::google::protobuf::uint8* RequestMessage::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:echo.RequestMessage)
::google::protobuf::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// int32 id = 1;
if (this->id() != 0) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->id(), target);
}
// string msg = 2;
if (this->msg().size() > 0) {
::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
this->msg().data(), static_cast<int>(this->msg().length()),
::google::protobuf::internal::WireFormatLite::SERIALIZE,
"echo.RequestMessage.msg");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->msg(), target);
}
if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
(::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target);
}
// @@protoc_insertion_point(serialize_to_array_end:echo.RequestMessage)
return target;
}
size_t RequestMessage::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:echo.RequestMessage)
size_t total_size = 0;
if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
(::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()));
}
// string msg = 2;
if (this->msg().size() > 0) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->msg());
}
// int32 id = 1;
if (this->id() != 0) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->id());
}
int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = cached_size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
return total_size;
}
void RequestMessage::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:echo.RequestMessage)
GOOGLE_DCHECK_NE(&from, this);
const RequestMessage* source =
::google::protobuf::internal::DynamicCastToGenerated<const RequestMessage>(
&from);
if (source == NULL) {
// @@protoc_insertion_point(generalized_merge_from_cast_fail:echo.RequestMessage)
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
// @@protoc_insertion_point(generalized_merge_from_cast_success:echo.RequestMessage)
MergeFrom(*source);
}
}
void RequestMessage::MergeFrom(const RequestMessage& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:echo.RequestMessage)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom(from._internal_metadata_);
::google::protobuf::uint32 cached_has_bits = 0;
(void) cached_has_bits;
if (from.msg().size() > 0) {
msg_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.msg_);
}
if (from.id() != 0) {
set_id(from.id());
}
}
void RequestMessage::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:echo.RequestMessage)
if (&from == this) return;
Clear();
MergeFrom(from);
}
void RequestMessage::CopyFrom(const RequestMessage& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:echo.RequestMessage)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool RequestMessage::IsInitialized() const {
return true;
}
void RequestMessage::Swap(RequestMessage* other) {
if (other == this) return;
InternalSwap(other);
}
void RequestMessage::InternalSwap(RequestMessage* other) {
using std::swap;
msg_.Swap(&other->msg_);
swap(id_, other->id_);
_internal_metadata_.Swap(&other->_internal_metadata_);
swap(_cached_size_, other->_cached_size_);
}
::google::protobuf::Metadata RequestMessage::GetMetadata() const {
protobuf_echo_5ftest_2eproto::protobuf_AssignDescriptorsOnce();
return ::protobuf_echo_5ftest_2eproto::file_level_metadata[kIndexInFileMessages];
}
// ===================================================================
void ResponseMessage::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ResponseMessage::kIdFieldNumber;
const int ResponseMessage::kMsgFieldNumber;
#endif // !defined(_MSC_VER) || _MSC_VER >= 1900
ResponseMessage::ResponseMessage()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
::protobuf_echo_5ftest_2eproto::InitDefaultsResponseMessage();
}
SharedCtor();
// @@protoc_insertion_point(constructor:echo.ResponseMessage)
}
ResponseMessage::ResponseMessage(const ResponseMessage& from)
: ::google::protobuf::Message(),
_internal_metadata_(NULL),
_cached_size_(0) {
_internal_metadata_.MergeFrom(from._internal_metadata_);
msg_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
if (from.msg().size() > 0) {
msg_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.msg_);
}
id_ = from.id_;
// @@protoc_insertion_point(copy_constructor:echo.ResponseMessage)
}
void ResponseMessage::SharedCtor() {
msg_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
id_ = 0;
_cached_size_ = 0;
}
ResponseMessage::~ResponseMessage() {
// @@protoc_insertion_point(destructor:echo.ResponseMessage)
SharedDtor();
}
void ResponseMessage::SharedDtor() {
msg_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void ResponseMessage::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ResponseMessage::descriptor() {
::protobuf_echo_5ftest_2eproto::protobuf_AssignDescriptorsOnce();
return ::protobuf_echo_5ftest_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}
const ResponseMessage& ResponseMessage::default_instance() {
::protobuf_echo_5ftest_2eproto::InitDefaultsResponseMessage();
return *internal_default_instance();
}
ResponseMessage* ResponseMessage::New(::google::protobuf::Arena* arena) const {
ResponseMessage* n = new ResponseMessage;
if (arena != NULL) {
arena->Own(n);
}
return n;
}
void ResponseMessage::Clear() {
// @@protoc_insertion_point(message_clear_start:echo.ResponseMessage)
::google::protobuf::uint32 cached_has_bits = 0;
// Prevent compiler warnings about cached_has_bits being unused
(void) cached_has_bits;
msg_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
id_ = 0;
_internal_metadata_.Clear();
}
bool ResponseMessage::MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
::google::protobuf::uint32 tag;
// @@protoc_insertion_point(parse_start:echo.ResponseMessage)
for (;;) {
::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
tag = p.first;
if (!p.second) goto handle_unusual;
switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
// int32 id = 1;
case 1: {
if (static_cast< ::google::protobuf::uint8>(tag) ==
static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
input, &id_)));
} else {
goto handle_unusual;
}
break;
}
// string msg = 2;
case 2: {
if (static_cast< ::google::protobuf::uint8>(tag) ==
static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
DO_(::google::protobuf::internal::WireFormatLite::ReadString(
input, this->mutable_msg()));
DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
this->msg().data(), static_cast<int>(this->msg().length()),
::google::protobuf::internal::WireFormatLite::PARSE,
"echo.ResponseMessage.msg"));
} else {
goto handle_unusual;
}
break;
}
default: {
handle_unusual:
if (tag == 0) {
goto success;
}
DO_(::google::protobuf::internal::WireFormat::SkipField(
input, tag, _internal_metadata_.mutable_unknown_fields()));
break;
}
}
}
success:
// @@protoc_insertion_point(parse_success:echo.ResponseMessage)
return true;
failure:
// @@protoc_insertion_point(parse_failure:echo.ResponseMessage)
return false;
#undef DO_
}
void ResponseMessage::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:echo.ResponseMessage)
::google::protobuf::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// int32 id = 1;
if (this->id() != 0) {
::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->id(), output);
}
// string msg = 2;
if (this->msg().size() > 0) {
::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
this->msg().data(), static_cast<int>(this->msg().length()),
::google::protobuf::internal::WireFormatLite::SERIALIZE,
"echo.ResponseMessage.msg");
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
2, this->msg(), output);
}
if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
::google::protobuf::internal::WireFormat::SerializeUnknownFields(
(::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output);
}
// @@protoc_insertion_point(serialize_end:echo.ResponseMessage)
}
::google::protobuf::uint8* ResponseMessage::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:echo.ResponseMessage)
::google::protobuf::uint32 cached_has_bits = 0;
(void) cached_has_bits;
// int32 id = 1;
if (this->id() != 0) {
target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->id(), target);
}
// string msg = 2;
if (this->msg().size() > 0) {
::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
this->msg().data(), static_cast<int>(this->msg().length()),
::google::protobuf::internal::WireFormatLite::SERIALIZE,
"echo.ResponseMessage.msg");
target =
::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2, this->msg(), target);
}
if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
(::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target);
}
// @@protoc_insertion_point(serialize_to_array_end:echo.ResponseMessage)
return target;
}
size_t ResponseMessage::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:echo.ResponseMessage)
size_t total_size = 0;
if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
(::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()));
}
// string msg = 2;
if (this->msg().size() > 0) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->msg());
}
// int32 id = 1;
if (this->id() != 0) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->id());
}
int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = cached_size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
return total_size;
}
void ResponseMessage::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:echo.ResponseMessage)
GOOGLE_DCHECK_NE(&from, this);
const ResponseMessage* source =
::google::protobuf::internal::DynamicCastToGenerated<const ResponseMessage>(
&from);
if (source == NULL) {
// @@protoc_insertion_point(generalized_merge_from_cast_fail:echo.ResponseMessage)
::google::protobuf::internal::ReflectionOps::Merge(from, this);
} else {
// @@protoc_insertion_point(generalized_merge_from_cast_success:echo.ResponseMessage)
MergeFrom(*source);
}
}
void ResponseMessage::MergeFrom(const ResponseMessage& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:echo.ResponseMessage)
GOOGLE_DCHECK_NE(&from, this);
_internal_metadata_.MergeFrom(from._internal_metadata_);
::google::protobuf::uint32 cached_has_bits = 0;
(void) cached_has_bits;
if (from.msg().size() > 0) {
msg_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.msg_);
}
if (from.id() != 0) {
set_id(from.id());
}
}
void ResponseMessage::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:echo.ResponseMessage)
if (&from == this) return;
Clear();
MergeFrom(from);
}
void ResponseMessage::CopyFrom(const ResponseMessage& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:echo.ResponseMessage)
if (&from == this) return;
Clear();
MergeFrom(from);
}
bool ResponseMessage::IsInitialized() const {
return true;
}
void ResponseMessage::Swap(ResponseMessage* other) {
if (other == this) return;
InternalSwap(other);
}
void ResponseMessage::InternalSwap(ResponseMessage* other) {
using std::swap;
msg_.Swap(&other->msg_);
swap(id_, other->id_);
_internal_metadata_.Swap(&other->_internal_metadata_);
swap(_cached_size_, other->_cached_size_);
}
::google::protobuf::Metadata ResponseMessage::GetMetadata() const {
protobuf_echo_5ftest_2eproto::protobuf_AssignDescriptorsOnce();
return ::protobuf_echo_5ftest_2eproto::file_level_metadata[kIndexInFileMessages];
}
// ===================================================================
EchoService::~EchoService() {}
const ::google::protobuf::ServiceDescriptor* EchoService::descriptor() {
protobuf_echo_5ftest_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_echo_5ftest_2eproto::file_level_service_descriptors[0];
}
const ::google::protobuf::ServiceDescriptor* EchoService::GetDescriptor() {
return descriptor();
}
void EchoService::echo(::google::protobuf::RpcController* controller,
const ::echo::RequestMessage*,
::echo::ResponseMessage*,
::google::protobuf::Closure* done) {
controller->SetFailed("Method echo() not implemented.");
done->Run();
}
void EchoService::CallMethod(const ::google::protobuf::MethodDescriptor* method,
::google::protobuf::RpcController* controller,
const ::google::protobuf::Message* request,
::google::protobuf::Message* response,
::google::protobuf::Closure* done) {
GOOGLE_DCHECK_EQ(method->service(), protobuf_echo_5ftest_2eproto::file_level_service_descriptors[0]);
switch(method->index()) {
case 0:
echo(controller,
::google::protobuf::down_cast<const ::echo::RequestMessage*>(request),
::google::protobuf::down_cast< ::echo::ResponseMessage*>(response),
done);
break;
default:
GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
break;
}
}
const ::google::protobuf::Message& EchoService::GetRequestPrototype(
const ::google::protobuf::MethodDescriptor* method) const {
GOOGLE_DCHECK_EQ(method->service(), descriptor());
switch(method->index()) {
case 0:
return ::echo::RequestMessage::default_instance();
default:
GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
return *::google::protobuf::MessageFactory::generated_factory()
->GetPrototype(method->input_type());
}
}
const ::google::protobuf::Message& EchoService::GetResponsePrototype(
const ::google::protobuf::MethodDescriptor* method) const {
GOOGLE_DCHECK_EQ(method->service(), descriptor());
switch(method->index()) {
case 0:
return ::echo::ResponseMessage::default_instance();
default:
GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
return *::google::protobuf::MessageFactory::generated_factory()
->GetPrototype(method->output_type());
}
}
EchoService_Stub::EchoService_Stub(::google::protobuf::RpcChannel* channel)
: channel_(channel), owns_channel_(false) {}
EchoService_Stub::EchoService_Stub(
::google::protobuf::RpcChannel* channel,
::google::protobuf::Service::ChannelOwnership ownership)
: channel_(channel),
owns_channel_(ownership == ::google::protobuf::Service::STUB_OWNS_CHANNEL) {}
EchoService_Stub::~EchoService_Stub() {
if (owns_channel_) delete channel_;
}
void EchoService_Stub::echo(::google::protobuf::RpcController* controller,
const ::echo::RequestMessage* request,
::echo::ResponseMessage* response,
::google::protobuf::Closure* done) {
channel_->CallMethod(descriptor()->method(0),
controller, request, response, done);
}
// @@protoc_insertion_point(namespace_scope)
} // namespace echo
// @@protoc_insertion_point(global_scope)
| 36.683894 | 168 | 0.708135 | iwtbabc |
09f1e6a2325353bc86a80ee5418c6718e4dc34e1 | 438,576 | cpp | C++ | MRTK/h/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs60.cpp | DreVinciCode/TEAM-08 | 4f148953a9f492c0fc0db7ee85803212caa1a579 | [
"MIT"
] | null | null | null | MRTK/h/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs60.cpp | DreVinciCode/TEAM-08 | 4f148953a9f492c0fc0db7ee85803212caa1a579 | [
"MIT"
] | null | null | null | MRTK/h/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs60.cpp | DreVinciCode/TEAM-08 | 4f148953a9f492c0fc0db7ee85803212caa1a579 | [
"MIT"
] | null | null | null | #include "pch-cpp.hpp"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include <limits>
#include "vm/CachedCCWBase.h"
#include "utils/New.h"
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,System.UInt32>
struct Dictionary_2_t40AD0E25A9C651DF2D10B7C03EE5D87856C2A72D;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,Microsoft.MixedReality.Toolkit.Input.DefaultPrimaryPointerSelector/PointerInfo>
struct Dictionary_2_tD050BE59829C217DD2B9F4B736D98C20B9D4EE71;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.IMixedRealityService>>
struct Dictionary_2_t4AC71EA65545B632470648515DE39A246064FCDF;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.UI.BoundsControl.IProximityEffectObjectProvider,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.BoundsControl.ProximityEffect/ObjectProximityInfo>>
struct Dictionary_2_t68198EC07801AB75028C8EB074F131B5777857D3;
// System.Collections.Generic.Dictionary`2<UnityEngine.XR.InputDevice,Microsoft.MixedReality.Toolkit.XRSDK.Input.GenericXRSDKController>
struct Dictionary_2_tA0FD2AFAAFE4AEDFD84AEE2B7DA1E4180E174DBF;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Tuple`2<Microsoft.MixedReality.Toolkit.Input.KeyBinding/KeyType,System.Int32>>
struct Dictionary_2_t7F65F6FAB0107F959C0877510BFD8595B311C142;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Boolean>
struct Dictionary_2_t446D8FCE66ED404E00855B46A520AB382A69EFF1;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Char>
struct Dictionary_2_tB8FA8FEFBC38630BF40B59A6B474816F30D29B23;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Globalization.CultureInfo>
struct Dictionary_2_t5B8303F2C9869A39ED3E03C0FBB09F817E479402;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Int32>
struct Dictionary_2_t49CB072CAA9184D326107FA696BB354C43EB5E08;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Int64>
struct Dictionary_2_t9AE0BA863BA88FABCBFC4CA835E0A6E00D948984;
// System.Collections.Generic.Dictionary`2<System.Int32,UnityEngine.Material>
struct Dictionary_2_tE3F17FC57643708975DF2782661AFB9CB1687991;
// System.Collections.Generic.Dictionary`2<System.Int32,UnityEngine.EventSystems.PointerEventData>
struct Dictionary_2_t52ECB6047A9EDAD198D0CC53F331CDEAAA83BED8;
// System.Collections.Generic.Dictionary`2<System.Int32,Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject>
struct Dictionary_2_tBFEF92C709D6CF5C8220E4553DF6064FCB30A49B;
// System.Collections.Generic.Dictionary`2<System.Int32,System.String>
struct Dictionary_2_t0ACB62D0885C7AB376463C70665400A39808C5FB;
// System.Collections.Generic.Dictionary`2<System.Int32,TMPro.TMP_ColorGradient>
struct Dictionary_2_t83EDCEFCBB12C89A61745514957F522FEF34EAE1;
// System.Collections.Generic.Dictionary`2<System.Int32,TMPro.TMP_FontAsset>
struct Dictionary_2_tAB557C4BCEBDF7E2339209187287588CF6C63579;
// System.Collections.Generic.Dictionary`2<System.Int32,TMPro.TMP_SpriteAsset>
struct Dictionary_2_t6A406AC36627118EE2E0E5BBCE5CF76FC9C5CE1F;
// System.Collections.Generic.Dictionary`2<System.Int32,TMPro.TMP_Style>
struct Dictionary_2_tF4EABB89111A0E30158256A3B667C7770E384763;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Threading.Tasks.Task>
struct Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8;
// System.Collections.Generic.Dictionary`2<System.Int32,System.TimeType>
struct Dictionary_2_t5D8E184D8FCD474C100BFB072548D71B5B758D72;
// System.Collections.Generic.Dictionary`2<System.Int32,Microsoft.MixedReality.Toolkit.Input.UnityInput.UnityTouchController>
struct Dictionary_2_tE6AD801A6392CDC6C5B2E0594CCC432F0C21037C;
// System.Collections.Generic.Dictionary`2<System.Int32,UnityEngine.GUILayoutUtility/LayoutCache>
struct Dictionary_2_t3FDB6C5EC702844ACB5B417679E01D7C1DCBA4D4;
// System.Collections.Generic.Dictionary`2<System.Int32,Microsoft.MixedReality.Toolkit.Input.MixedRealityInputModule/PointerData>
struct Dictionary_2_tB7478EF7A1D56D0534BD9AF224099A735CEFB6E6;
// System.Collections.Generic.Dictionary`2<System.Int32,UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap>
struct Dictionary_2_t8BE99204247C1C97B2675C8E9AB2B482BADCD725;
// System.Collections.Generic.Dictionary`2<System.Int64,TMPro.TMP_MaterialManager/FallbackMaterial>
struct Dictionary_2_tF37F71739257A9F8484D38DF8ADAA587B68C88BE;
// System.Collections.Generic.Dictionary`2<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D;
// System.Collections.Generic.Dictionary`2<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40;
// System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739;
// System.Collections.Generic.Dictionary`2<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98;
// System.Collections.Generic.Dictionary`2<System.String,System.Collections.Generic.List`1<System.Int32>>
struct Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929;
// System.Collections.Generic.Dictionary`2<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F;
// System.Collections.Generic.Dictionary`2<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205;
// System.Collections.Generic.Dictionary`2<System.String,System.Globalization.CultureInfo>
struct Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC;
// System.Collections.Generic.ICollection`1<System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct ICollection_1_t404BE5E5AA4139016599832D6E27DF4B5FB8B4A7;
// System.Collections.Generic.ICollection`1<System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.IMixedRealityService>>
struct ICollection_1_t68C8D63DEFC2EA91CFDDA6EF12CCB8B2686B9A67;
// System.Collections.Generic.ICollection`1<System.Collections.Generic.List`1<System.Int32>>
struct ICollection_1_t2E299E163B06823385C10FF80D10F25628F4976A;
// System.Collections.Generic.ICollection`1<System.Collections.Generic.List`1<UnityEngine.Material>>
struct ICollection_1_t476CEAF74BBA987572739B70382B462728A73A5D;
// System.Collections.Generic.ICollection`1<System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.BoundsControl.ProximityEffect/ObjectProximityInfo>>
struct ICollection_1_t01DA940D6840E8B1736C601E181DEB07F7C61B1B;
// System.Collections.Generic.ICollection`1<System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct ICollection_1_t1BBA8FBDBF0ECFD16895F5537608EC08E5C0D839;
// System.Collections.Generic.ICollection`1<System.Tuple`2<Microsoft.MixedReality.Toolkit.Input.KeyBinding/KeyType,System.Int32>>
struct ICollection_1_t074636FC93CA9AF06A5436AE77D1958DAC606449;
// System.Collections.Generic.ICollection`1<System.Reflection.MemberInfo[]>
struct ICollection_1_t6CE0E8E5C74A9387B10346B773221924748B61FE;
// System.Collections.Generic.ICollection`1<Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct ICollection_1_tBCD7CC44086FC9B137CA4EDC5F7F896B16DE42E9;
// System.Collections.Generic.ICollection`1<System.Boolean>
struct ICollection_1_t655D141A762682C0B23DCBB178920F6E16ACDCC1;
// System.Collections.Generic.ICollection`1<System.Char>
struct ICollection_1_t279C84C6E26447FCB987237160562DE753A402FB;
// System.Collections.Generic.ICollection`1<System.Globalization.CultureInfo>
struct ICollection_1_tF0D51A10F099E0CDFCF106C18CBEA5897FB23DA7;
// System.Collections.Generic.ICollection`1<Microsoft.MixedReality.Toolkit.XRSDK.Input.GenericXRSDKController>
struct ICollection_1_tD1F090F4141D05BD8E9C66862CFA0E80465120B2;
// System.Collections.Generic.ICollection`1<System.Int32>
struct ICollection_1_t1C0C51B19916511E9D525272F055515334C93525;
// System.Collections.Generic.ICollection`1<System.Int64>
struct ICollection_1_t8C5F082A91912BD5FF56F069099F2C862A275D47;
// System.Collections.Generic.ICollection`1<UnityEngine.Material>
struct ICollection_1_t82DBD7463454EF1C2A79712ACD1DD0947EC30A0E;
// System.Collections.Generic.ICollection`1<UnityEngine.EventSystems.PointerEventData>
struct ICollection_1_tCEF2F3FE0351562156067618ADB16EDE11613F35;
// System.Collections.Generic.ICollection`1<Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject>
struct ICollection_1_t2F883C1BE240BCF2CFF76DCC9DDC47313B99C384;
// System.Collections.Generic.ICollection`1<System.String>
struct ICollection_1_t286AA3BBFF7FCE401FEFF57AEEC4FDAABA9F95B1;
// System.Collections.Generic.ICollection`1<TMPro.TMP_ColorGradient>
struct ICollection_1_tF5379C2815E0E8F2136BC63FD64435645649D350;
// System.Collections.Generic.ICollection`1<TMPro.TMP_FontAsset>
struct ICollection_1_tF95FC75A0AA66FEB725C072EB65506B7A0CE5A56;
// System.Collections.Generic.ICollection`1<TMPro.TMP_SpriteAsset>
struct ICollection_1_t12BE86AD0CF92F4C49C76CE628675FBC1E6BD564;
// System.Collections.Generic.ICollection`1<TMPro.TMP_Style>
struct ICollection_1_tDE3CD0A877F812B6FA0234CE2B11D90AAB8BF459;
// System.Collections.Generic.ICollection`1<System.Threading.Tasks.Task>
struct ICollection_1_t170EC74C9EBD063821F8431C6A942A9387BC7BAB;
// System.Collections.Generic.ICollection`1<System.TimeType>
struct ICollection_1_t0DAECD968E7904AC3430BC643464715E4475BED5;
// System.Collections.Generic.ICollection`1<System.UInt32>
struct ICollection_1_tE23809439C40C6ABE4868D40BCE1C6E268DEBBD7;
// System.Collections.Generic.ICollection`1<Microsoft.MixedReality.Toolkit.Input.UnityInput.UnityTouchController>
struct ICollection_1_t516FBFF517489BC3F6DE4DED1806E364F64780E0;
// System.Collections.Generic.ICollection`1<Microsoft.MixedReality.Toolkit.Input.DefaultPrimaryPointerSelector/PointerInfo>
struct ICollection_1_t031F795293E3BA995C192E919CE4D0687EB57185;
// System.Collections.Generic.ICollection`1<UnityEngine.GUILayoutUtility/LayoutCache>
struct ICollection_1_t686E05F85D0E6C53858707C8C6BD7D2DDBCA296C;
// System.Collections.Generic.ICollection`1<Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct ICollection_1_tA8CD678A9F004E931DA1DADD342794724BDFE00B;
// System.Collections.Generic.ICollection`1<Microsoft.MixedReality.Toolkit.Input.MixedRealityInputModule/PointerData>
struct ICollection_1_t06AF48EEAA9A77EAFE51AE10F873B9DD584D9FD2;
// System.Collections.Generic.ICollection`1<TMPro.TMP_MaterialManager/FallbackMaterial>
struct ICollection_1_tDC8C7413D5AB756EAEE0C1BAFB6A4E37F06588F3;
// System.Collections.Generic.ICollection`1<UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap>
struct ICollection_1_t27E3D670A7C968F2A776C879EF4D7841B628059A;
// System.Collections.Generic.ICollection`1<System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct ICollection_1_tD00D7894210B94B1703E352E4AF0C6776E3932FD;
struct IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB;
struct IIterator_1_t02E2BD99A6F2FDED0070DCE99953C4927747C248;
struct IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D;
struct IIterator_1_t3FD87DAE4281E0090447733627B3A0BA377B6CEC;
struct IIterator_1_t6407EDB3A3187B31D54D9B4E941F88F529FCE4B3;
struct IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4;
struct IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267;
struct IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF;
struct IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C;
struct IIterator_1_tC3877F062B34DD4C7EA4B4D797B326073FC95B72;
struct IIterator_1_tC66AB251038F529F8EA4926CBFFB3A97C323B58D;
struct IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67;
struct IIterator_1_tE13F884343548B90CBE44A0A597D5A31E29178BF;
struct IIterator_1_tE26006BA89CCCFA23A4E08D14138F4CA88B7902D;
struct IIterator_1_tE49C1648FC94E093BCD82BA18359053328200C9F;
struct IIterator_1_tE84305D19EB46B9DD6D1B86BE7195EBA9B09BF2D;
struct IIterator_1_tF5EE7B485ADAC2DE9A72944EAA6F7C75F52ED6BA;
struct IIterator_1_tF6C570C031F6203C0401C0DC0B69FCE361F7062E;
struct IIterator_1_tFF647CAD19D34FD0606CDD3425C431F82B94589C;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Windows.Foundation.Collections.IIterable`1<System.Collections.Generic.IEnumerable`1<System.Char>>
struct NOVTABLE IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.Generic.IEnumerable`1<System.IDisposable>>
struct NOVTABLE IIterable_1_t65C1CF61727FBB13369E9B777E6EA4756FFD7E3D : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m2B4221348B2704C13FAEA47E445A5266F50F0552(IIterator_1_tE49C1648FC94E093BCD82BA18359053328200C9F** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.Generic.IEnumerable`1<System.Int32>>
struct NOVTABLE IIterable_1_tAC6B6C1A7ECF33EE15C94CDDD30ACC7A9CE98004 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mE0EF757DC8E58BB169C78D378571014C172F6240(IIterator_1_tE26006BA89CCCFA23A4E08D14138F4CA88B7902D** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.Generic.IEnumerable`1<System.Object>>
struct NOVTABLE IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879(IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.Generic.IList`1<System.Int32>>
struct NOVTABLE IIterable_1_t5CB142C4A47D31ACB8B355C41740914CC985F378 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5654F86BC6ACA9944E4840952F197CD3256A1ED8(IIterator_1_tF5EE7B485ADAC2DE9A72944EAA6F7C75F52ED6BA** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.Generic.IReadOnlyList`1<System.IDisposable>>
struct NOVTABLE IIterable_1_tDA7BDBC19E1812C5ACD6E546F60391ADC6E2CE58 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m4F1ECE8DFCABEDF6BA2C0C3ABC35C492F13541E6(IIterator_1_tF6C570C031F6203C0401C0DC0B69FCE361F7062E** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.Generic.IReadOnlyList`1<System.Int32>>
struct NOVTABLE IIterable_1_t2702F7342BF99284890A03EDD178F218B730190E : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m7A9BBDC56E34A2D92A5AB578D200EB1D2E67A77B(IIterator_1_t02E2BD99A6F2FDED0070DCE99953C4927747C248** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.Generic.IReadOnlyList`1<System.Object>>
struct NOVTABLE IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F(IIterator_1_t6407EDB3A3187B31D54D9B4E941F88F529FCE4B3** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Boolean>
struct NOVTABLE IIterable_1_t0F0E81F8630AABFA67939A3C4C7A6448EC21FB24 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m0DF5AB173068D2FBCA182101EF7C9DD4C9135BCB(IIterator_1_tE13F884343548B90CBE44A0A597D5A31E29178BF** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Char>
struct NOVTABLE IIterable_1_t76BB785EC29C8526627DE0ACEA068DB15E5388CE : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mB416B18AB4E9562AAD05C38EB9AD14CC685574CA(IIterator_1_tC3877F062B34DD4C7EA4B4D797B326073FC95B72** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.IDisposable>
struct NOVTABLE IIterable_1_t5F4BD9477DDC56D9428ADFFD61354FCFE2E78588 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mDDCB90F64D3007CB280F2A112BFB11FEDF4CF937(IIterator_1_tE84305D19EB46B9DD6D1B86BE7195EBA9B09BF2D** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.IEnumerable>
struct NOVTABLE IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.IList>
struct NOVTABLE IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Int32>
struct NOVTABLE IIterable_1_t3FD1FB01310262788B2A8868AA7395E023511050 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mC1E90957AD904E68CE3F84D1EF22D5EFACE8C2D5(IIterator_1_tFF647CAD19D34FD0606CDD3425C431F82B94589C** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Int64>
struct NOVTABLE IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579(IIterator_1_t3FD87DAE4281E0090447733627B3A0BA377B6CEC** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Object>
struct NOVTABLE IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.String>
struct NOVTABLE IIterable_1_t94592E586C395F026290ACC676E74C560595CC26 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.UInt32>
struct NOVTABLE IIterable_1_t2765EC2E965992FAB9B7FDB2DB5E7FFA10D61BAB : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m4E590558B8FE1D4FA427F8F876803D1F68F7D100(IIterator_1_tC66AB251038F529F8EA4926CBFFB3A97C323B58D** comReturnValue) = 0;
};
// Windows.UI.Xaml.Interop.IBindableIterable
struct NOVTABLE IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) = 0;
};
// System.Object
// System.Collections.Generic.Dictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,System.UInt32>
struct ValueCollection_t262615E8969959039536C1062446C359A19AB126 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t40AD0E25A9C651DF2D10B7C03EE5D87856C2A72D * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t262615E8969959039536C1062446C359A19AB126, ___dictionary_0)); }
inline Dictionary_2_t40AD0E25A9C651DF2D10B7C03EE5D87856C2A72D * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t40AD0E25A9C651DF2D10B7C03EE5D87856C2A72D ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t40AD0E25A9C651DF2D10B7C03EE5D87856C2A72D * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,System.UInt32>
struct ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,Microsoft.MixedReality.Toolkit.Input.DefaultPrimaryPointerSelector/PointerInfo>
struct ValueCollection_t93BBCE4C284B2C998882FE9B39645E940AF2ACD0 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tD050BE59829C217DD2B9F4B736D98C20B9D4EE71 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t93BBCE4C284B2C998882FE9B39645E940AF2ACD0, ___dictionary_0)); }
inline Dictionary_2_tD050BE59829C217DD2B9F4B736D98C20B9D4EE71 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tD050BE59829C217DD2B9F4B736D98C20B9D4EE71 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tD050BE59829C217DD2B9F4B736D98C20B9D4EE71 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,Microsoft.MixedReality.Toolkit.Input.DefaultPrimaryPointerSelector/PointerInfo>
struct ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.IMixedRealityService>>
struct ValueCollection_t6182E1C54EEAB1FF3F9D23E7264092C56639BE18 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t4AC71EA65545B632470648515DE39A246064FCDF * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t6182E1C54EEAB1FF3F9D23E7264092C56639BE18, ___dictionary_0)); }
inline Dictionary_2_t4AC71EA65545B632470648515DE39A246064FCDF * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t4AC71EA65545B632470648515DE39A246064FCDF ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t4AC71EA65545B632470648515DE39A246064FCDF * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.IMixedRealityService>>
struct ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.UI.BoundsControl.IProximityEffectObjectProvider,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.BoundsControl.ProximityEffect/ObjectProximityInfo>>
struct ValueCollection_t35EEE5F7625928EBEECE80818253291F7DA62F3F : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t68198EC07801AB75028C8EB074F131B5777857D3 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t35EEE5F7625928EBEECE80818253291F7DA62F3F, ___dictionary_0)); }
inline Dictionary_2_t68198EC07801AB75028C8EB074F131B5777857D3 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t68198EC07801AB75028C8EB074F131B5777857D3 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t68198EC07801AB75028C8EB074F131B5777857D3 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.UI.BoundsControl.IProximityEffectObjectProvider,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.BoundsControl.ProximityEffect/ObjectProximityInfo>>
struct ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<UnityEngine.XR.InputDevice,Microsoft.MixedReality.Toolkit.XRSDK.Input.GenericXRSDKController>
struct ValueCollection_tCCE813D240C8630808B5BD3FA1A8FCD4B27AF60F : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tA0FD2AFAAFE4AEDFD84AEE2B7DA1E4180E174DBF * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tCCE813D240C8630808B5BD3FA1A8FCD4B27AF60F, ___dictionary_0)); }
inline Dictionary_2_tA0FD2AFAAFE4AEDFD84AEE2B7DA1E4180E174DBF * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tA0FD2AFAAFE4AEDFD84AEE2B7DA1E4180E174DBF ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tA0FD2AFAAFE4AEDFD84AEE2B7DA1E4180E174DBF * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<UnityEngine.XR.InputDevice,Microsoft.MixedReality.Toolkit.XRSDK.Input.GenericXRSDKController>
struct ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Tuple`2<Microsoft.MixedReality.Toolkit.Input.KeyBinding/KeyType,System.Int32>>
struct ValueCollection_t1F82D536EB8FBE64609987D28E158B8B5A578992 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t7F65F6FAB0107F959C0877510BFD8595B311C142 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t1F82D536EB8FBE64609987D28E158B8B5A578992, ___dictionary_0)); }
inline Dictionary_2_t7F65F6FAB0107F959C0877510BFD8595B311C142 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t7F65F6FAB0107F959C0877510BFD8595B311C142 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t7F65F6FAB0107F959C0877510BFD8595B311C142 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Tuple`2<Microsoft.MixedReality.Toolkit.Input.KeyBinding/KeyType,System.Int32>>
struct ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Boolean>
struct ValueCollection_tAC9371FC72C759652E224BBBE13669CD7F4FC7EC : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t446D8FCE66ED404E00855B46A520AB382A69EFF1 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tAC9371FC72C759652E224BBBE13669CD7F4FC7EC, ___dictionary_0)); }
inline Dictionary_2_t446D8FCE66ED404E00855B46A520AB382A69EFF1 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t446D8FCE66ED404E00855B46A520AB382A69EFF1 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t446D8FCE66ED404E00855B46A520AB382A69EFF1 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Boolean>
struct ValueCollection_tB51F603A239485F05720315028C603D2DC30180E : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tB51F603A239485F05720315028C603D2DC30180E, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tB51F603A239485F05720315028C603D2DC30180E, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Char>
struct ValueCollection_tDEA922C20FE7390F1063807C7F0EAE8B2C022A7B : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tB8FA8FEFBC38630BF40B59A6B474816F30D29B23 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tDEA922C20FE7390F1063807C7F0EAE8B2C022A7B, ___dictionary_0)); }
inline Dictionary_2_tB8FA8FEFBC38630BF40B59A6B474816F30D29B23 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tB8FA8FEFBC38630BF40B59A6B474816F30D29B23 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tB8FA8FEFBC38630BF40B59A6B474816F30D29B23 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Char>
struct ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Globalization.CultureInfo>
struct ValueCollection_tE84BE90A3A9ADA37C09165304138ECF878FE4ED7 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t5B8303F2C9869A39ED3E03C0FBB09F817E479402 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tE84BE90A3A9ADA37C09165304138ECF878FE4ED7, ___dictionary_0)); }
inline Dictionary_2_t5B8303F2C9869A39ED3E03C0FBB09F817E479402 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t5B8303F2C9869A39ED3E03C0FBB09F817E479402 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t5B8303F2C9869A39ED3E03C0FBB09F817E479402 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Globalization.CultureInfo>
struct ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Int32>
struct ValueCollection_t8738745D8513A557A82E6E097DF4D4E70D5253C2 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t49CB072CAA9184D326107FA696BB354C43EB5E08 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t8738745D8513A557A82E6E097DF4D4E70D5253C2, ___dictionary_0)); }
inline Dictionary_2_t49CB072CAA9184D326107FA696BB354C43EB5E08 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t49CB072CAA9184D326107FA696BB354C43EB5E08 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t49CB072CAA9184D326107FA696BB354C43EB5E08 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Int32>
struct ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Int64>
struct ValueCollection_tDD2C80682AF4CF18883668E136B1980110C79D95 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t9AE0BA863BA88FABCBFC4CA835E0A6E00D948984 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tDD2C80682AF4CF18883668E136B1980110C79D95, ___dictionary_0)); }
inline Dictionary_2_t9AE0BA863BA88FABCBFC4CA835E0A6E00D948984 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t9AE0BA863BA88FABCBFC4CA835E0A6E00D948984 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t9AE0BA863BA88FABCBFC4CA835E0A6E00D948984 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Int64>
struct ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,UnityEngine.Material>
struct ValueCollection_t45CC083597229265F7ED085E423FB1A7BF762BA3 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tE3F17FC57643708975DF2782661AFB9CB1687991 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t45CC083597229265F7ED085E423FB1A7BF762BA3, ___dictionary_0)); }
inline Dictionary_2_tE3F17FC57643708975DF2782661AFB9CB1687991 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tE3F17FC57643708975DF2782661AFB9CB1687991 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tE3F17FC57643708975DF2782661AFB9CB1687991 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,UnityEngine.Material>
struct ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,UnityEngine.EventSystems.PointerEventData>
struct ValueCollection_t28C5EADCF5205986726B544E972D81491CD308DA : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t52ECB6047A9EDAD198D0CC53F331CDEAAA83BED8 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t28C5EADCF5205986726B544E972D81491CD308DA, ___dictionary_0)); }
inline Dictionary_2_t52ECB6047A9EDAD198D0CC53F331CDEAAA83BED8 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t52ECB6047A9EDAD198D0CC53F331CDEAAA83BED8 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t52ECB6047A9EDAD198D0CC53F331CDEAAA83BED8 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,UnityEngine.EventSystems.PointerEventData>
struct ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject>
struct ValueCollection_t532B14D24FC92E18A887848D100E3825432ECF59 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tBFEF92C709D6CF5C8220E4553DF6064FCB30A49B * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t532B14D24FC92E18A887848D100E3825432ECF59, ___dictionary_0)); }
inline Dictionary_2_tBFEF92C709D6CF5C8220E4553DF6064FCB30A49B * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tBFEF92C709D6CF5C8220E4553DF6064FCB30A49B ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tBFEF92C709D6CF5C8220E4553DF6064FCB30A49B * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject>
struct ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.String>
struct ValueCollection_t5C221D6474B57B05A1EF91C1C6A7B1FA1CF361BF : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t0ACB62D0885C7AB376463C70665400A39808C5FB * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t5C221D6474B57B05A1EF91C1C6A7B1FA1CF361BF, ___dictionary_0)); }
inline Dictionary_2_t0ACB62D0885C7AB376463C70665400A39808C5FB * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t0ACB62D0885C7AB376463C70665400A39808C5FB ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t0ACB62D0885C7AB376463C70665400A39808C5FB * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.String>
struct ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,TMPro.TMP_ColorGradient>
struct ValueCollection_t0A4E0F9662AF7EF0D0D0E1E70988F30A0717AA41 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t83EDCEFCBB12C89A61745514957F522FEF34EAE1 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t0A4E0F9662AF7EF0D0D0E1E70988F30A0717AA41, ___dictionary_0)); }
inline Dictionary_2_t83EDCEFCBB12C89A61745514957F522FEF34EAE1 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t83EDCEFCBB12C89A61745514957F522FEF34EAE1 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t83EDCEFCBB12C89A61745514957F522FEF34EAE1 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,TMPro.TMP_ColorGradient>
struct ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,TMPro.TMP_FontAsset>
struct ValueCollection_tC8F758677CEA2459E735CF3B2F6408762AAC21B5 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tAB557C4BCEBDF7E2339209187287588CF6C63579 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tC8F758677CEA2459E735CF3B2F6408762AAC21B5, ___dictionary_0)); }
inline Dictionary_2_tAB557C4BCEBDF7E2339209187287588CF6C63579 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tAB557C4BCEBDF7E2339209187287588CF6C63579 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tAB557C4BCEBDF7E2339209187287588CF6C63579 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,TMPro.TMP_FontAsset>
struct ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,TMPro.TMP_SpriteAsset>
struct ValueCollection_t4FAE69882A1111AEC4C2ADABCAA914A58F8CA1A8 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t6A406AC36627118EE2E0E5BBCE5CF76FC9C5CE1F * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t4FAE69882A1111AEC4C2ADABCAA914A58F8CA1A8, ___dictionary_0)); }
inline Dictionary_2_t6A406AC36627118EE2E0E5BBCE5CF76FC9C5CE1F * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t6A406AC36627118EE2E0E5BBCE5CF76FC9C5CE1F ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t6A406AC36627118EE2E0E5BBCE5CF76FC9C5CE1F * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,TMPro.TMP_SpriteAsset>
struct ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,TMPro.TMP_Style>
struct ValueCollection_t625D6831F9B9DDA73FD6EBEC5DF210DF81231030 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tF4EABB89111A0E30158256A3B667C7770E384763 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t625D6831F9B9DDA73FD6EBEC5DF210DF81231030, ___dictionary_0)); }
inline Dictionary_2_tF4EABB89111A0E30158256A3B667C7770E384763 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tF4EABB89111A0E30158256A3B667C7770E384763 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tF4EABB89111A0E30158256A3B667C7770E384763 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,TMPro.TMP_Style>
struct ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Threading.Tasks.Task>
struct ValueCollection_tB61C2016CD14273F2E8ABD6FEEA53372E4A53C73 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tB61C2016CD14273F2E8ABD6FEEA53372E4A53C73, ___dictionary_0)); }
inline Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Threading.Tasks.Task>
struct ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.TimeType>
struct ValueCollection_tAAC32AE618C238632B383B9345C22427B19EA9C5 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t5D8E184D8FCD474C100BFB072548D71B5B758D72 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tAAC32AE618C238632B383B9345C22427B19EA9C5, ___dictionary_0)); }
inline Dictionary_2_t5D8E184D8FCD474C100BFB072548D71B5B758D72 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t5D8E184D8FCD474C100BFB072548D71B5B758D72 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t5D8E184D8FCD474C100BFB072548D71B5B758D72 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.TimeType>
struct ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.Input.UnityInput.UnityTouchController>
struct ValueCollection_tADF78A5BE1F06BCCC05C38BF765907A7638A05B1 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tE6AD801A6392CDC6C5B2E0594CCC432F0C21037C * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tADF78A5BE1F06BCCC05C38BF765907A7638A05B1, ___dictionary_0)); }
inline Dictionary_2_tE6AD801A6392CDC6C5B2E0594CCC432F0C21037C * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tE6AD801A6392CDC6C5B2E0594CCC432F0C21037C ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tE6AD801A6392CDC6C5B2E0594CCC432F0C21037C * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.Input.UnityInput.UnityTouchController>
struct ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,UnityEngine.GUILayoutUtility/LayoutCache>
struct ValueCollection_t8DE7DA329F6A29C185EDFDDA71627FD6C4C725F8 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t3FDB6C5EC702844ACB5B417679E01D7C1DCBA4D4 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t8DE7DA329F6A29C185EDFDDA71627FD6C4C725F8, ___dictionary_0)); }
inline Dictionary_2_t3FDB6C5EC702844ACB5B417679E01D7C1DCBA4D4 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t3FDB6C5EC702844ACB5B417679E01D7C1DCBA4D4 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t3FDB6C5EC702844ACB5B417679E01D7C1DCBA4D4 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,UnityEngine.GUILayoutUtility/LayoutCache>
struct ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.Input.MixedRealityInputModule/PointerData>
struct ValueCollection_t785392F6FCC7542B349A8D0753166B46003CC299 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tB7478EF7A1D56D0534BD9AF224099A735CEFB6E6 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t785392F6FCC7542B349A8D0753166B46003CC299, ___dictionary_0)); }
inline Dictionary_2_tB7478EF7A1D56D0534BD9AF224099A735CEFB6E6 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tB7478EF7A1D56D0534BD9AF224099A735CEFB6E6 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tB7478EF7A1D56D0534BD9AF224099A735CEFB6E6 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.Input.MixedRealityInputModule/PointerData>
struct ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap>
struct ValueCollection_tF5A29AA52483C44A9B166F23F45001565015B4EB : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t8BE99204247C1C97B2675C8E9AB2B482BADCD725 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tF5A29AA52483C44A9B166F23F45001565015B4EB, ___dictionary_0)); }
inline Dictionary_2_t8BE99204247C1C97B2675C8E9AB2B482BADCD725 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t8BE99204247C1C97B2675C8E9AB2B482BADCD725 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t8BE99204247C1C97B2675C8E9AB2B482BADCD725 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap>
struct ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Int64,TMPro.TMP_MaterialManager/FallbackMaterial>
struct ValueCollection_tCCF34CAD9EBEE4C994FB6C0181F8E35516BEA984 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tF37F71739257A9F8484D38DF8ADAA587B68C88BE * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tCCF34CAD9EBEE4C994FB6C0181F8E35516BEA984, ___dictionary_0)); }
inline Dictionary_2_tF37F71739257A9F8484D38DF8ADAA587B68C88BE * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tF37F71739257A9F8484D38DF8ADAA587B68C88BE ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tF37F71739257A9F8484D38DF8ADAA587B68C88BE * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int64,TMPro.TMP_MaterialManager/FallbackMaterial>
struct ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Runtime.Serialization.MemberHolder,System.Reflection.MemberInfo[]>
struct ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct ValueCollection_tBBAEF38FC75ABDFCD1E5E4CAB542714F89988132 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tBBAEF38FC75ABDFCD1E5E4CAB542714F89988132, ___dictionary_0)); }
inline Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct ValueCollection_tDF9F4C17321815AB3E97B0CF08B95643B761CC5F : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tDF9F4C17321815AB3E97B0CF08B95643B761CC5F, ___dictionary_0)); }
inline Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct ValueCollection_tEA48E4B6DFB033F98ED189470457D6134F7C7AA9 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tEA48E4B6DFB033F98ED189470457D6134F7C7AA9, ___dictionary_0)); }
inline Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct ValueCollection_t4B036D0BD949C2E59398E64DE2DC4DE7941F17AF : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t4B036D0BD949C2E59398E64DE2DC4DE7941F17AF, ___dictionary_0)); }
inline Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.String,System.Collections.Generic.List`1<System.Int32>>
struct ValueCollection_t4B66845A360B651377A6E8B046A5C02F4683B57B : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t4B66845A360B651377A6E8B046A5C02F4683B57B, ___dictionary_0)); }
inline Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.String,System.Collections.Generic.List`1<System.Int32>>
struct ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct ValueCollection_t4258B35F0EBB3B6F0E2F80D4F993788844F3D518 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_t4258B35F0EBB3B6F0E2F80D4F993788844F3D518, ___dictionary_0)); }
inline Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct ValueCollection_tE8D07B1FFC8FFAD13CE0BE0A61EC4B5E377A08C3 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tE8D07B1FFC8FFAD13CE0BE0A61EC4B5E377A08C3, ___dictionary_0)); }
inline Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TValue> System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/ValueCollection<System.String,System.Globalization.CultureInfo>
struct ValueCollection_tE359A31BF25A2BECA2FC677EC431DDFE1E481B35 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection::dictionary
Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(ValueCollection_tE359A31BF25A2BECA2FC677EC431DDFE1E481B35, ___dictionary_0)); }
inline Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
il2cpp_hresult_t IIterable_1_First_m4E590558B8FE1D4FA427F8F876803D1F68F7D100_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tC66AB251038F529F8EA4926CBFFB3A97C323B58D** comReturnValue);
il2cpp_hresult_t IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m2B4221348B2704C13FAEA47E445A5266F50F0552_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tE49C1648FC94E093BCD82BA18359053328200C9F** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m4F1ECE8DFCABEDF6BA2C0C3ABC35C492F13541E6_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tF6C570C031F6203C0401C0DC0B69FCE361F7062E** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t6407EDB3A3187B31D54D9B4E941F88F529FCE4B3** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m0DF5AB173068D2FBCA182101EF7C9DD4C9135BCB_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tE13F884343548B90CBE44A0A597D5A31E29178BF** comReturnValue);
il2cpp_hresult_t IIterable_1_First_mB416B18AB4E9562AAD05C38EB9AD14CC685574CA_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tC3877F062B34DD4C7EA4B4D797B326073FC95B72** comReturnValue);
il2cpp_hresult_t IIterable_1_First_mC1E90957AD904E68CE3F84D1EF22D5EFACE8C2D5_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tFF647CAD19D34FD0606CDD3425C431F82B94589C** comReturnValue);
il2cpp_hresult_t IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t3FD87DAE4281E0090447733627B3A0BA377B6CEC** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue);
il2cpp_hresult_t IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue);
il2cpp_hresult_t IIterable_1_First_mDDCB90F64D3007CB280F2A112BFB11FEDF4CF937_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tE84305D19EB46B9DD6D1B86BE7195EBA9B09BF2D** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m5654F86BC6ACA9944E4840952F197CD3256A1ED8_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tF5EE7B485ADAC2DE9A72944EAA6F7C75F52ED6BA** comReturnValue);
il2cpp_hresult_t IIterable_1_First_mE0EF757DC8E58BB169C78D378571014C172F6240_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tE26006BA89CCCFA23A4E08D14138F4CA88B7902D** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m7A9BBDC56E34A2D92A5AB578D200EB1D2E67A77B_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t02E2BD99A6F2FDED0070DCE99953C4927747C248** comReturnValue);
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,System.UInt32>
struct ValueCollection_t262615E8969959039536C1062446C359A19AB126_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t262615E8969959039536C1062446C359A19AB126_ComCallableWrapper>, IIterable_1_t2765EC2E965992FAB9B7FDB2DB5E7FFA10D61BAB, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t262615E8969959039536C1062446C359A19AB126_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t262615E8969959039536C1062446C359A19AB126_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t2765EC2E965992FAB9B7FDB2DB5E7FFA10D61BAB::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t2765EC2E965992FAB9B7FDB2DB5E7FFA10D61BAB*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t2765EC2E965992FAB9B7FDB2DB5E7FFA10D61BAB::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m4E590558B8FE1D4FA427F8F876803D1F68F7D100(IIterator_1_tC66AB251038F529F8EA4926CBFFB3A97C323B58D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m4E590558B8FE1D4FA427F8F876803D1F68F7D100_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t262615E8969959039536C1062446C359A19AB126(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t262615E8969959039536C1062446C359A19AB126_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t262615E8969959039536C1062446C359A19AB126_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,System.UInt32>
struct ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0_ComCallableWrapper>, IIterable_1_t2765EC2E965992FAB9B7FDB2DB5E7FFA10D61BAB, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t2765EC2E965992FAB9B7FDB2DB5E7FFA10D61BAB::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t2765EC2E965992FAB9B7FDB2DB5E7FFA10D61BAB*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t2765EC2E965992FAB9B7FDB2DB5E7FFA10D61BAB::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m4E590558B8FE1D4FA427F8F876803D1F68F7D100(IIterator_1_tC66AB251038F529F8EA4926CBFFB3A97C323B58D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m4E590558B8FE1D4FA427F8F876803D1F68F7D100_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t1E4D1EF76B873007C8DB78EA85A8171F9EF4DCB0_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,Microsoft.MixedReality.Toolkit.Input.DefaultPrimaryPointerSelector/PointerInfo>
struct ValueCollection_t93BBCE4C284B2C998882FE9B39645E940AF2ACD0_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t93BBCE4C284B2C998882FE9B39645E940AF2ACD0_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t93BBCE4C284B2C998882FE9B39645E940AF2ACD0_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t93BBCE4C284B2C998882FE9B39645E940AF2ACD0_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t93BBCE4C284B2C998882FE9B39645E940AF2ACD0(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t93BBCE4C284B2C998882FE9B39645E940AF2ACD0_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t93BBCE4C284B2C998882FE9B39645E940AF2ACD0_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,Microsoft.MixedReality.Toolkit.Input.DefaultPrimaryPointerSelector/PointerInfo>
struct ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tC444032476362E68BB3BB9C95FAD70933A2B58D1_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.IMixedRealityService>>
struct ValueCollection_t6182E1C54EEAB1FF3F9D23E7264092C56639BE18_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t6182E1C54EEAB1FF3F9D23E7264092C56639BE18_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t65C1CF61727FBB13369E9B777E6EA4756FFD7E3D, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD, IIterable_1_tDA7BDBC19E1812C5ACD6E546F60391ADC6E2CE58, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t6182E1C54EEAB1FF3F9D23E7264092C56639BE18_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t6182E1C54EEAB1FF3F9D23E7264092C56639BE18_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t65C1CF61727FBB13369E9B777E6EA4756FFD7E3D::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t65C1CF61727FBB13369E9B777E6EA4756FFD7E3D*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA7BDBC19E1812C5ACD6E546F60391ADC6E2CE58::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA7BDBC19E1812C5ACD6E546F60391ADC6E2CE58*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(6);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_t65C1CF61727FBB13369E9B777E6EA4756FFD7E3D::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID;
interfaceIds[4] = IIterable_1_tDA7BDBC19E1812C5ACD6E546F60391ADC6E2CE58::IID;
interfaceIds[5] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 6;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m2B4221348B2704C13FAEA47E445A5266F50F0552(IIterator_1_tE49C1648FC94E093BCD82BA18359053328200C9F** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m2B4221348B2704C13FAEA47E445A5266F50F0552_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m4F1ECE8DFCABEDF6BA2C0C3ABC35C492F13541E6(IIterator_1_tF6C570C031F6203C0401C0DC0B69FCE361F7062E** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m4F1ECE8DFCABEDF6BA2C0C3ABC35C492F13541E6_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t6182E1C54EEAB1FF3F9D23E7264092C56639BE18(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t6182E1C54EEAB1FF3F9D23E7264092C56639BE18_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t6182E1C54EEAB1FF3F9D23E7264092C56639BE18_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.IMixedRealityService>>
struct ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t65C1CF61727FBB13369E9B777E6EA4756FFD7E3D, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD, IIterable_1_tDA7BDBC19E1812C5ACD6E546F60391ADC6E2CE58, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t65C1CF61727FBB13369E9B777E6EA4756FFD7E3D::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t65C1CF61727FBB13369E9B777E6EA4756FFD7E3D*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA7BDBC19E1812C5ACD6E546F60391ADC6E2CE58::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA7BDBC19E1812C5ACD6E546F60391ADC6E2CE58*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(6);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_t65C1CF61727FBB13369E9B777E6EA4756FFD7E3D::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID;
interfaceIds[4] = IIterable_1_tDA7BDBC19E1812C5ACD6E546F60391ADC6E2CE58::IID;
interfaceIds[5] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 6;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m2B4221348B2704C13FAEA47E445A5266F50F0552(IIterator_1_tE49C1648FC94E093BCD82BA18359053328200C9F** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m2B4221348B2704C13FAEA47E445A5266F50F0552_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m4F1ECE8DFCABEDF6BA2C0C3ABC35C492F13541E6(IIterator_1_tF6C570C031F6203C0401C0DC0B69FCE361F7062E** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m4F1ECE8DFCABEDF6BA2C0C3ABC35C492F13541E6_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tF44BF18D44BA0AE2BDA6463963C8A6C3BB077529_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.UI.BoundsControl.IProximityEffectObjectProvider,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.BoundsControl.ProximityEffect/ObjectProximityInfo>>
struct ValueCollection_t35EEE5F7625928EBEECE80818253291F7DA62F3F_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t35EEE5F7625928EBEECE80818253291F7DA62F3F_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD, IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t35EEE5F7625928EBEECE80818253291F7DA62F3F_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t35EEE5F7625928EBEECE80818253291F7DA62F3F_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(6);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID;
interfaceIds[4] = IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID;
interfaceIds[5] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 6;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879(IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F(IIterator_1_t6407EDB3A3187B31D54D9B4E941F88F529FCE4B3** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t35EEE5F7625928EBEECE80818253291F7DA62F3F(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t35EEE5F7625928EBEECE80818253291F7DA62F3F_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t35EEE5F7625928EBEECE80818253291F7DA62F3F_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<Microsoft.MixedReality.Toolkit.UI.BoundsControl.IProximityEffectObjectProvider,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.UI.BoundsControl.ProximityEffect/ObjectProximityInfo>>
struct ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD, IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(6);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID;
interfaceIds[4] = IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID;
interfaceIds[5] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 6;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879(IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F(IIterator_1_t6407EDB3A3187B31D54D9B4E941F88F529FCE4B3** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t62D026783D1BDEA317AAC3A08FB50A983B717E52_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<UnityEngine.XR.InputDevice,Microsoft.MixedReality.Toolkit.XRSDK.Input.GenericXRSDKController>
struct ValueCollection_tCCE813D240C8630808B5BD3FA1A8FCD4B27AF60F_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tCCE813D240C8630808B5BD3FA1A8FCD4B27AF60F_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tCCE813D240C8630808B5BD3FA1A8FCD4B27AF60F_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tCCE813D240C8630808B5BD3FA1A8FCD4B27AF60F_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tCCE813D240C8630808B5BD3FA1A8FCD4B27AF60F(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tCCE813D240C8630808B5BD3FA1A8FCD4B27AF60F_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tCCE813D240C8630808B5BD3FA1A8FCD4B27AF60F_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<UnityEngine.XR.InputDevice,Microsoft.MixedReality.Toolkit.XRSDK.Input.GenericXRSDKController>
struct ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t2BB87BC48FD0FB932E61C48D019D0F7909C8BFF7_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Tuple`2<Microsoft.MixedReality.Toolkit.Input.KeyBinding/KeyType,System.Int32>>
struct ValueCollection_t1F82D536EB8FBE64609987D28E158B8B5A578992_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t1F82D536EB8FBE64609987D28E158B8B5A578992_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t1F82D536EB8FBE64609987D28E158B8B5A578992_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t1F82D536EB8FBE64609987D28E158B8B5A578992_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t1F82D536EB8FBE64609987D28E158B8B5A578992(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t1F82D536EB8FBE64609987D28E158B8B5A578992_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t1F82D536EB8FBE64609987D28E158B8B5A578992_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Tuple`2<Microsoft.MixedReality.Toolkit.Input.KeyBinding/KeyType,System.Int32>>
struct ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t090E0538F1546987A3F3A3F9B204780DCF28E34A_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Boolean>
struct ValueCollection_tAC9371FC72C759652E224BBBE13669CD7F4FC7EC_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tAC9371FC72C759652E224BBBE13669CD7F4FC7EC_ComCallableWrapper>, IIterable_1_t0F0E81F8630AABFA67939A3C4C7A6448EC21FB24, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tAC9371FC72C759652E224BBBE13669CD7F4FC7EC_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tAC9371FC72C759652E224BBBE13669CD7F4FC7EC_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t0F0E81F8630AABFA67939A3C4C7A6448EC21FB24::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t0F0E81F8630AABFA67939A3C4C7A6448EC21FB24*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t0F0E81F8630AABFA67939A3C4C7A6448EC21FB24::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m0DF5AB173068D2FBCA182101EF7C9DD4C9135BCB(IIterator_1_tE13F884343548B90CBE44A0A597D5A31E29178BF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m0DF5AB173068D2FBCA182101EF7C9DD4C9135BCB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tAC9371FC72C759652E224BBBE13669CD7F4FC7EC(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tAC9371FC72C759652E224BBBE13669CD7F4FC7EC_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tAC9371FC72C759652E224BBBE13669CD7F4FC7EC_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Boolean>
struct ValueCollection_tB51F603A239485F05720315028C603D2DC30180E_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tB51F603A239485F05720315028C603D2DC30180E_ComCallableWrapper>, IIterable_1_t0F0E81F8630AABFA67939A3C4C7A6448EC21FB24, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tB51F603A239485F05720315028C603D2DC30180E_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tB51F603A239485F05720315028C603D2DC30180E_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t0F0E81F8630AABFA67939A3C4C7A6448EC21FB24::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t0F0E81F8630AABFA67939A3C4C7A6448EC21FB24*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t0F0E81F8630AABFA67939A3C4C7A6448EC21FB24::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m0DF5AB173068D2FBCA182101EF7C9DD4C9135BCB(IIterator_1_tE13F884343548B90CBE44A0A597D5A31E29178BF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m0DF5AB173068D2FBCA182101EF7C9DD4C9135BCB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tB51F603A239485F05720315028C603D2DC30180E(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tB51F603A239485F05720315028C603D2DC30180E_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tB51F603A239485F05720315028C603D2DC30180E_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Char>
struct ValueCollection_tDEA922C20FE7390F1063807C7F0EAE8B2C022A7B_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tDEA922C20FE7390F1063807C7F0EAE8B2C022A7B_ComCallableWrapper>, IIterable_1_t76BB785EC29C8526627DE0ACEA068DB15E5388CE, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tDEA922C20FE7390F1063807C7F0EAE8B2C022A7B_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tDEA922C20FE7390F1063807C7F0EAE8B2C022A7B_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t76BB785EC29C8526627DE0ACEA068DB15E5388CE::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t76BB785EC29C8526627DE0ACEA068DB15E5388CE*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t76BB785EC29C8526627DE0ACEA068DB15E5388CE::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mB416B18AB4E9562AAD05C38EB9AD14CC685574CA(IIterator_1_tC3877F062B34DD4C7EA4B4D797B326073FC95B72** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mB416B18AB4E9562AAD05C38EB9AD14CC685574CA_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tDEA922C20FE7390F1063807C7F0EAE8B2C022A7B(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tDEA922C20FE7390F1063807C7F0EAE8B2C022A7B_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tDEA922C20FE7390F1063807C7F0EAE8B2C022A7B_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Char>
struct ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A_ComCallableWrapper>, IIterable_1_t76BB785EC29C8526627DE0ACEA068DB15E5388CE, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t76BB785EC29C8526627DE0ACEA068DB15E5388CE::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t76BB785EC29C8526627DE0ACEA068DB15E5388CE*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t76BB785EC29C8526627DE0ACEA068DB15E5388CE::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mB416B18AB4E9562AAD05C38EB9AD14CC685574CA(IIterator_1_tC3877F062B34DD4C7EA4B4D797B326073FC95B72** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mB416B18AB4E9562AAD05C38EB9AD14CC685574CA_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t65BF5F1537D952260730F9EF31DFBCA90DA7FC5A_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Globalization.CultureInfo>
struct ValueCollection_tE84BE90A3A9ADA37C09165304138ECF878FE4ED7_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tE84BE90A3A9ADA37C09165304138ECF878FE4ED7_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tE84BE90A3A9ADA37C09165304138ECF878FE4ED7_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tE84BE90A3A9ADA37C09165304138ECF878FE4ED7_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tE84BE90A3A9ADA37C09165304138ECF878FE4ED7(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tE84BE90A3A9ADA37C09165304138ECF878FE4ED7_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tE84BE90A3A9ADA37C09165304138ECF878FE4ED7_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Globalization.CultureInfo>
struct ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t76A1D105429D1EF9CA00AED8B612D7F5DEA1A0E1_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Int32>
struct ValueCollection_t8738745D8513A557A82E6E097DF4D4E70D5253C2_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t8738745D8513A557A82E6E097DF4D4E70D5253C2_ComCallableWrapper>, IIterable_1_t3FD1FB01310262788B2A8868AA7395E023511050, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t8738745D8513A557A82E6E097DF4D4E70D5253C2_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t8738745D8513A557A82E6E097DF4D4E70D5253C2_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t3FD1FB01310262788B2A8868AA7395E023511050::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t3FD1FB01310262788B2A8868AA7395E023511050*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t3FD1FB01310262788B2A8868AA7395E023511050::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mC1E90957AD904E68CE3F84D1EF22D5EFACE8C2D5(IIterator_1_tFF647CAD19D34FD0606CDD3425C431F82B94589C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mC1E90957AD904E68CE3F84D1EF22D5EFACE8C2D5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t8738745D8513A557A82E6E097DF4D4E70D5253C2(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t8738745D8513A557A82E6E097DF4D4E70D5253C2_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t8738745D8513A557A82E6E097DF4D4E70D5253C2_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Int32>
struct ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C_ComCallableWrapper>, IIterable_1_t3FD1FB01310262788B2A8868AA7395E023511050, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t3FD1FB01310262788B2A8868AA7395E023511050::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t3FD1FB01310262788B2A8868AA7395E023511050*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t3FD1FB01310262788B2A8868AA7395E023511050::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mC1E90957AD904E68CE3F84D1EF22D5EFACE8C2D5(IIterator_1_tFF647CAD19D34FD0606CDD3425C431F82B94589C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mC1E90957AD904E68CE3F84D1EF22D5EFACE8C2D5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t48B58DEA6F5CF1E9959CC08347044FD1199BB39C_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Int64>
struct ValueCollection_tDD2C80682AF4CF18883668E136B1980110C79D95_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tDD2C80682AF4CF18883668E136B1980110C79D95_ComCallableWrapper>, IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tDD2C80682AF4CF18883668E136B1980110C79D95_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tDD2C80682AF4CF18883668E136B1980110C79D95_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579(IIterator_1_t3FD87DAE4281E0090447733627B3A0BA377B6CEC** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tDD2C80682AF4CF18883668E136B1980110C79D95(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tDD2C80682AF4CF18883668E136B1980110C79D95_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tDD2C80682AF4CF18883668E136B1980110C79D95_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Int64>
struct ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F_ComCallableWrapper>, IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579(IIterator_1_t3FD87DAE4281E0090447733627B3A0BA377B6CEC** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tDD3A2A47F1254D88628C68D87D830A584722012F_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,UnityEngine.Material>
struct ValueCollection_t45CC083597229265F7ED085E423FB1A7BF762BA3_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t45CC083597229265F7ED085E423FB1A7BF762BA3_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t45CC083597229265F7ED085E423FB1A7BF762BA3_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t45CC083597229265F7ED085E423FB1A7BF762BA3_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t45CC083597229265F7ED085E423FB1A7BF762BA3(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t45CC083597229265F7ED085E423FB1A7BF762BA3_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t45CC083597229265F7ED085E423FB1A7BF762BA3_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,UnityEngine.Material>
struct ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tE6DD53C28F18E9D5F05F965551F3C88178BF15B4_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,UnityEngine.EventSystems.PointerEventData>
struct ValueCollection_t28C5EADCF5205986726B544E972D81491CD308DA_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t28C5EADCF5205986726B544E972D81491CD308DA_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t28C5EADCF5205986726B544E972D81491CD308DA_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t28C5EADCF5205986726B544E972D81491CD308DA_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t28C5EADCF5205986726B544E972D81491CD308DA(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t28C5EADCF5205986726B544E972D81491CD308DA_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t28C5EADCF5205986726B544E972D81491CD308DA_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,UnityEngine.EventSystems.PointerEventData>
struct ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t9FEB03EF99A5A4FEC35B8B143F9A805C36347399_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject>
struct ValueCollection_t532B14D24FC92E18A887848D100E3825432ECF59_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t532B14D24FC92E18A887848D100E3825432ECF59_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t532B14D24FC92E18A887848D100E3825432ECF59_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t532B14D24FC92E18A887848D100E3825432ECF59_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t532B14D24FC92E18A887848D100E3825432ECF59(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t532B14D24FC92E18A887848D100E3825432ECF59_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t532B14D24FC92E18A887848D100E3825432ECF59_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject>
struct ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t5A60FE54FE5D98B0A446038207081BD75087CAE3_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.String>
struct ValueCollection_t5C221D6474B57B05A1EF91C1C6A7B1FA1CF361BF_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t5C221D6474B57B05A1EF91C1C6A7B1FA1CF361BF_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t5C221D6474B57B05A1EF91C1C6A7B1FA1CF361BF_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t5C221D6474B57B05A1EF91C1C6A7B1FA1CF361BF_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t5C221D6474B57B05A1EF91C1C6A7B1FA1CF361BF(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t5C221D6474B57B05A1EF91C1C6A7B1FA1CF361BF_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t5C221D6474B57B05A1EF91C1C6A7B1FA1CF361BF_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.String>
struct ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tE8B618071B897471AC32AAF06060B187610CFB43_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,TMPro.TMP_ColorGradient>
struct ValueCollection_t0A4E0F9662AF7EF0D0D0E1E70988F30A0717AA41_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t0A4E0F9662AF7EF0D0D0E1E70988F30A0717AA41_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t0A4E0F9662AF7EF0D0D0E1E70988F30A0717AA41_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t0A4E0F9662AF7EF0D0D0E1E70988F30A0717AA41_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t0A4E0F9662AF7EF0D0D0E1E70988F30A0717AA41(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t0A4E0F9662AF7EF0D0D0E1E70988F30A0717AA41_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t0A4E0F9662AF7EF0D0D0E1E70988F30A0717AA41_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,TMPro.TMP_ColorGradient>
struct ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tF3E06E1B7F3F827575625D735B684EDF94431971_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,TMPro.TMP_FontAsset>
struct ValueCollection_tC8F758677CEA2459E735CF3B2F6408762AAC21B5_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tC8F758677CEA2459E735CF3B2F6408762AAC21B5_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tC8F758677CEA2459E735CF3B2F6408762AAC21B5_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tC8F758677CEA2459E735CF3B2F6408762AAC21B5_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tC8F758677CEA2459E735CF3B2F6408762AAC21B5(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tC8F758677CEA2459E735CF3B2F6408762AAC21B5_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tC8F758677CEA2459E735CF3B2F6408762AAC21B5_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,TMPro.TMP_FontAsset>
struct ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t468EF4114E5E829EEC9AFCCDF8745C4D2E301C88_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,TMPro.TMP_SpriteAsset>
struct ValueCollection_t4FAE69882A1111AEC4C2ADABCAA914A58F8CA1A8_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t4FAE69882A1111AEC4C2ADABCAA914A58F8CA1A8_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t4FAE69882A1111AEC4C2ADABCAA914A58F8CA1A8_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t4FAE69882A1111AEC4C2ADABCAA914A58F8CA1A8_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t4FAE69882A1111AEC4C2ADABCAA914A58F8CA1A8(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t4FAE69882A1111AEC4C2ADABCAA914A58F8CA1A8_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t4FAE69882A1111AEC4C2ADABCAA914A58F8CA1A8_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,TMPro.TMP_SpriteAsset>
struct ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tA7D37A794F6B8768525831C895952CD93ED21510_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,TMPro.TMP_Style>
struct ValueCollection_t625D6831F9B9DDA73FD6EBEC5DF210DF81231030_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t625D6831F9B9DDA73FD6EBEC5DF210DF81231030_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t625D6831F9B9DDA73FD6EBEC5DF210DF81231030_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t625D6831F9B9DDA73FD6EBEC5DF210DF81231030_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t625D6831F9B9DDA73FD6EBEC5DF210DF81231030(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t625D6831F9B9DDA73FD6EBEC5DF210DF81231030_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t625D6831F9B9DDA73FD6EBEC5DF210DF81231030_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,TMPro.TMP_Style>
struct ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tD45AF1B120128FB336471F76D41131B907650C04_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.Threading.Tasks.Task>
struct ValueCollection_tB61C2016CD14273F2E8ABD6FEEA53372E4A53C73_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tB61C2016CD14273F2E8ABD6FEEA53372E4A53C73_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t5F4BD9477DDC56D9428ADFFD61354FCFE2E78588, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tB61C2016CD14273F2E8ABD6FEEA53372E4A53C73_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tB61C2016CD14273F2E8ABD6FEEA53372E4A53C73_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t5F4BD9477DDC56D9428ADFFD61354FCFE2E78588::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t5F4BD9477DDC56D9428ADFFD61354FCFE2E78588*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(3);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_t5F4BD9477DDC56D9428ADFFD61354FCFE2E78588::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 3;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mDDCB90F64D3007CB280F2A112BFB11FEDF4CF937(IIterator_1_tE84305D19EB46B9DD6D1B86BE7195EBA9B09BF2D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mDDCB90F64D3007CB280F2A112BFB11FEDF4CF937_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tB61C2016CD14273F2E8ABD6FEEA53372E4A53C73(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tB61C2016CD14273F2E8ABD6FEEA53372E4A53C73_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tB61C2016CD14273F2E8ABD6FEEA53372E4A53C73_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.Threading.Tasks.Task>
struct ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t5F4BD9477DDC56D9428ADFFD61354FCFE2E78588, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t5F4BD9477DDC56D9428ADFFD61354FCFE2E78588::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t5F4BD9477DDC56D9428ADFFD61354FCFE2E78588*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(3);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_t5F4BD9477DDC56D9428ADFFD61354FCFE2E78588::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 3;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mDDCB90F64D3007CB280F2A112BFB11FEDF4CF937(IIterator_1_tE84305D19EB46B9DD6D1B86BE7195EBA9B09BF2D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mDDCB90F64D3007CB280F2A112BFB11FEDF4CF937_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tC0EF51948EA6CC2782B13B162C154C832EFEC3E1_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,System.TimeType>
struct ValueCollection_tAAC32AE618C238632B383B9345C22427B19EA9C5_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tAAC32AE618C238632B383B9345C22427B19EA9C5_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tAAC32AE618C238632B383B9345C22427B19EA9C5_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tAAC32AE618C238632B383B9345C22427B19EA9C5_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tAAC32AE618C238632B383B9345C22427B19EA9C5(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tAAC32AE618C238632B383B9345C22427B19EA9C5_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tAAC32AE618C238632B383B9345C22427B19EA9C5_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,System.TimeType>
struct ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t06DE7C9B1AF6C21F3D792B24ED702715CB5C9B80_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.Input.UnityInput.UnityTouchController>
struct ValueCollection_tADF78A5BE1F06BCCC05C38BF765907A7638A05B1_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tADF78A5BE1F06BCCC05C38BF765907A7638A05B1_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tADF78A5BE1F06BCCC05C38BF765907A7638A05B1_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tADF78A5BE1F06BCCC05C38BF765907A7638A05B1_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tADF78A5BE1F06BCCC05C38BF765907A7638A05B1(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tADF78A5BE1F06BCCC05C38BF765907A7638A05B1_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tADF78A5BE1F06BCCC05C38BF765907A7638A05B1_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.Input.UnityInput.UnityTouchController>
struct ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t43EB4079728FAFF2194187CFB09ECD1FB4951CB9_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,UnityEngine.GUILayoutUtility/LayoutCache>
struct ValueCollection_t8DE7DA329F6A29C185EDFDDA71627FD6C4C725F8_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t8DE7DA329F6A29C185EDFDDA71627FD6C4C725F8_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t8DE7DA329F6A29C185EDFDDA71627FD6C4C725F8_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t8DE7DA329F6A29C185EDFDDA71627FD6C4C725F8_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t8DE7DA329F6A29C185EDFDDA71627FD6C4C725F8(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t8DE7DA329F6A29C185EDFDDA71627FD6C4C725F8_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t8DE7DA329F6A29C185EDFDDA71627FD6C4C725F8_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,UnityEngine.GUILayoutUtility/LayoutCache>
struct ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t6960BACFC4198CB6FAC694668070119F290F95C4_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.Input.MixedRealityInputModule/PointerData>
struct ValueCollection_t785392F6FCC7542B349A8D0753166B46003CC299_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t785392F6FCC7542B349A8D0753166B46003CC299_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t785392F6FCC7542B349A8D0753166B46003CC299_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t785392F6FCC7542B349A8D0753166B46003CC299_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t785392F6FCC7542B349A8D0753166B46003CC299(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t785392F6FCC7542B349A8D0753166B46003CC299_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t785392F6FCC7542B349A8D0753166B46003CC299_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,Microsoft.MixedReality.Toolkit.Input.MixedRealityInputModule/PointerData>
struct ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tD307F92C22EC1E4D9BCC43E689AC1D8DF8D3148B_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int32,UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap>
struct ValueCollection_tF5A29AA52483C44A9B166F23F45001565015B4EB_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tF5A29AA52483C44A9B166F23F45001565015B4EB_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tF5A29AA52483C44A9B166F23F45001565015B4EB_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tF5A29AA52483C44A9B166F23F45001565015B4EB_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tF5A29AA52483C44A9B166F23F45001565015B4EB(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tF5A29AA52483C44A9B166F23F45001565015B4EB_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tF5A29AA52483C44A9B166F23F45001565015B4EB_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int32,UnityEngine.Experimental.TerrainAPI.TerrainUtility/TerrainMap>
struct ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tBCFE074CC7AF6EDB1B2855274B0F9144C14DF2F2_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Int64,TMPro.TMP_MaterialManager/FallbackMaterial>
struct ValueCollection_tCCF34CAD9EBEE4C994FB6C0181F8E35516BEA984_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tCCF34CAD9EBEE4C994FB6C0181F8E35516BEA984_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tCCF34CAD9EBEE4C994FB6C0181F8E35516BEA984_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tCCF34CAD9EBEE4C994FB6C0181F8E35516BEA984_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tCCF34CAD9EBEE4C994FB6C0181F8E35516BEA984(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tCCF34CAD9EBEE4C994FB6C0181F8E35516BEA984_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tCCF34CAD9EBEE4C994FB6C0181F8E35516BEA984_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Int64,TMPro.TMP_MaterialManager/FallbackMaterial>
struct ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t5CB442B521BF4716EBDDA2D9D43953DAFA6D6217_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Runtime.Serialization.MemberHolder,System.Reflection.MemberInfo[]>
struct ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8_ComCallableWrapper>, IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(6);
interfaceIds[0] = IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID;
interfaceIds[1] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[2] = IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID;
interfaceIds[3] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[4] = IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID;
interfaceIds[5] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 6;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879(IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F(IIterator_1_t6407EDB3A3187B31D54D9B4E941F88F529FCE4B3** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t490C46E2C988D497F9D983A3839F5BADF2242BF8_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct ValueCollection_tBBAEF38FC75ABDFCD1E5E4CAB542714F89988132_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tBBAEF38FC75ABDFCD1E5E4CAB542714F89988132_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tBBAEF38FC75ABDFCD1E5E4CAB542714F89988132_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tBBAEF38FC75ABDFCD1E5E4CAB542714F89988132_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tBBAEF38FC75ABDFCD1E5E4CAB542714F89988132(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tBBAEF38FC75ABDFCD1E5E4CAB542714F89988132_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tBBAEF38FC75ABDFCD1E5E4CAB542714F89988132_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tD82FC4CB2CA66DF8752A12E5E17B9AA66CCF0FF5_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct ValueCollection_tDF9F4C17321815AB3E97B0CF08B95643B761CC5F_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tDF9F4C17321815AB3E97B0CF08B95643B761CC5F_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tDF9F4C17321815AB3E97B0CF08B95643B761CC5F_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tDF9F4C17321815AB3E97B0CF08B95643B761CC5F_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(3);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 3;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tDF9F4C17321815AB3E97B0CF08B95643B761CC5F(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tDF9F4C17321815AB3E97B0CF08B95643B761CC5F_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tDF9F4C17321815AB3E97B0CF08B95643B761CC5F_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(3);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 3;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t64D5CC96C01CD1964AB4E4552466209BB5010168_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct ValueCollection_tEA48E4B6DFB033F98ED189470457D6134F7C7AA9_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tEA48E4B6DFB033F98ED189470457D6134F7C7AA9_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tEA48E4B6DFB033F98ED189470457D6134F7C7AA9_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tEA48E4B6DFB033F98ED189470457D6134F7C7AA9_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tEA48E4B6DFB033F98ED189470457D6134F7C7AA9(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tEA48E4B6DFB033F98ED189470457D6134F7C7AA9_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tEA48E4B6DFB033F98ED189470457D6134F7C7AA9_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t67C7AC4BD5E770742C8C63745C34310883D9BC0E_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct ValueCollection_t4B036D0BD949C2E59398E64DE2DC4DE7941F17AF_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t4B036D0BD949C2E59398E64DE2DC4DE7941F17AF_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD, IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t4B036D0BD949C2E59398E64DE2DC4DE7941F17AF_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t4B036D0BD949C2E59398E64DE2DC4DE7941F17AF_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(6);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID;
interfaceIds[4] = IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID;
interfaceIds[5] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 6;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879(IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F(IIterator_1_t6407EDB3A3187B31D54D9B4E941F88F529FCE4B3** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t4B036D0BD949C2E59398E64DE2DC4DE7941F17AF(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t4B036D0BD949C2E59398E64DE2DC4DE7941F17AF_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t4B036D0BD949C2E59398E64DE2DC4DE7941F17AF_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD, IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(6);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID;
interfaceIds[4] = IIterable_1_t1FE40219CF2EA9D14D69F038AAD3EC908A8FE771::IID;
interfaceIds[5] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 6;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879(IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F(IIterator_1_t6407EDB3A3187B31D54D9B4E941F88F529FCE4B3** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m9A24DB3CFEE6B2D8C04AD194AC25CEA2597B8D3F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tFE378173D0A06206C85E08D334CE9A6EB45F21A7_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.String,System.Collections.Generic.List`1<System.Int32>>
struct ValueCollection_t4B66845A360B651377A6E8B046A5C02F4683B57B_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t4B66845A360B651377A6E8B046A5C02F4683B57B_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t5CB142C4A47D31ACB8B355C41740914CC985F378, IIterable_1_tAC6B6C1A7ECF33EE15C94CDDD30ACC7A9CE98004, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD, IIterable_1_t2702F7342BF99284890A03EDD178F218B730190E, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t4B66845A360B651377A6E8B046A5C02F4683B57B_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t4B66845A360B651377A6E8B046A5C02F4683B57B_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t5CB142C4A47D31ACB8B355C41740914CC985F378::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t5CB142C4A47D31ACB8B355C41740914CC985F378*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tAC6B6C1A7ECF33EE15C94CDDD30ACC7A9CE98004::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tAC6B6C1A7ECF33EE15C94CDDD30ACC7A9CE98004*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t2702F7342BF99284890A03EDD178F218B730190E::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t2702F7342BF99284890A03EDD178F218B730190E*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(7);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_t5CB142C4A47D31ACB8B355C41740914CC985F378::IID;
interfaceIds[2] = IIterable_1_tAC6B6C1A7ECF33EE15C94CDDD30ACC7A9CE98004::IID;
interfaceIds[3] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[4] = IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID;
interfaceIds[5] = IIterable_1_t2702F7342BF99284890A03EDD178F218B730190E::IID;
interfaceIds[6] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 7;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5654F86BC6ACA9944E4840952F197CD3256A1ED8(IIterator_1_tF5EE7B485ADAC2DE9A72944EAA6F7C75F52ED6BA** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5654F86BC6ACA9944E4840952F197CD3256A1ED8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mE0EF757DC8E58BB169C78D378571014C172F6240(IIterator_1_tE26006BA89CCCFA23A4E08D14138F4CA88B7902D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mE0EF757DC8E58BB169C78D378571014C172F6240_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m7A9BBDC56E34A2D92A5AB578D200EB1D2E67A77B(IIterator_1_t02E2BD99A6F2FDED0070DCE99953C4927747C248** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m7A9BBDC56E34A2D92A5AB578D200EB1D2E67A77B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t4B66845A360B651377A6E8B046A5C02F4683B57B(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t4B66845A360B651377A6E8B046A5C02F4683B57B_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t4B66845A360B651377A6E8B046A5C02F4683B57B_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.String,System.Collections.Generic.List`1<System.Int32>>
struct ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t5CB142C4A47D31ACB8B355C41740914CC985F378, IIterable_1_tAC6B6C1A7ECF33EE15C94CDDD30ACC7A9CE98004, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD, IIterable_1_t2702F7342BF99284890A03EDD178F218B730190E, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t5CB142C4A47D31ACB8B355C41740914CC985F378::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t5CB142C4A47D31ACB8B355C41740914CC985F378*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tAC6B6C1A7ECF33EE15C94CDDD30ACC7A9CE98004::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tAC6B6C1A7ECF33EE15C94CDDD30ACC7A9CE98004*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t2702F7342BF99284890A03EDD178F218B730190E::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t2702F7342BF99284890A03EDD178F218B730190E*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(7);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_t5CB142C4A47D31ACB8B355C41740914CC985F378::IID;
interfaceIds[2] = IIterable_1_tAC6B6C1A7ECF33EE15C94CDDD30ACC7A9CE98004::IID;
interfaceIds[3] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[4] = IIterable_1_tDA0D1077EFCD7389A5AD5BF4D598F22A450175CD::IID;
interfaceIds[5] = IIterable_1_t2702F7342BF99284890A03EDD178F218B730190E::IID;
interfaceIds[6] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 7;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5654F86BC6ACA9944E4840952F197CD3256A1ED8(IIterator_1_tF5EE7B485ADAC2DE9A72944EAA6F7C75F52ED6BA** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5654F86BC6ACA9944E4840952F197CD3256A1ED8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mE0EF757DC8E58BB169C78D378571014C172F6240(IIterator_1_tE26006BA89CCCFA23A4E08D14138F4CA88B7902D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mE0EF757DC8E58BB169C78D378571014C172F6240_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB(IIterator_1_t76B4F2A2B99659B935148C20E12CDDF5018A3267** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m5AA74545514CBE1B8F27A3AD8AB35879FA66F2BB_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m7A9BBDC56E34A2D92A5AB578D200EB1D2E67A77B(IIterator_1_t02E2BD99A6F2FDED0070DCE99953C4927747C248** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m7A9BBDC56E34A2D92A5AB578D200EB1D2E67A77B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tFE2A555095D6B906BBD4E2E1136B107CD200EBDF_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct ValueCollection_t4258B35F0EBB3B6F0E2F80D4F993788844F3D518_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t4258B35F0EBB3B6F0E2F80D4F993788844F3D518_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t4258B35F0EBB3B6F0E2F80D4F993788844F3D518_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t4258B35F0EBB3B6F0E2F80D4F993788844F3D518_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879(IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t4258B35F0EBB3B6F0E2F80D4F993788844F3D518(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t4258B35F0EBB3B6F0E2F80D4F993788844F3D518_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t4258B35F0EBB3B6F0E2F80D4F993788844F3D518_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IIterable_1_tB7611E3565ADF2561FF7521E03A1E3B93F7BD113::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879(IIterator_1_tD5C5DE60C4A835F60D32B19C44430B59B26BFA67** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m1E9A9F6DA2EC9A3A751A6E85F67C9BB40798A879_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t43F83E081841BC11EE8141994AEF3BB2B7A83AB8_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct ValueCollection_tE8D07B1FFC8FFAD13CE0BE0A61EC4B5E377A08C3_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tE8D07B1FFC8FFAD13CE0BE0A61EC4B5E377A08C3_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tE8D07B1FFC8FFAD13CE0BE0A61EC4B5E377A08C3_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tE8D07B1FFC8FFAD13CE0BE0A61EC4B5E377A08C3_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tE8D07B1FFC8FFAD13CE0BE0A61EC4B5E377A08C3(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tE8D07B1FFC8FFAD13CE0BE0A61EC4B5E377A08C3_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tE8D07B1FFC8FFAD13CE0BE0A61EC4B5E377A08C3_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/ValueCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_t1CE523D0BD0FED5CB8E608B16912D83537F66B19_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/ValueCollection<System.String,System.Globalization.CultureInfo>
struct ValueCollection_tE359A31BF25A2BECA2FC677EC431DDFE1E481B35_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ValueCollection_tE359A31BF25A2BECA2FC677EC431DDFE1E481B35_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ValueCollection_tE359A31BF25A2BECA2FC677EC431DDFE1E481B35_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ValueCollection_tE359A31BF25A2BECA2FC677EC431DDFE1E481B35_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ValueCollection_tE359A31BF25A2BECA2FC677EC431DDFE1E481B35(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ValueCollection_tE359A31BF25A2BECA2FC677EC431DDFE1E481B35_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ValueCollection_tE359A31BF25A2BECA2FC677EC431DDFE1E481B35_ComCallableWrapper(obj));
}
| 43.923485 | 593 | 0.824824 | DreVinciCode |
09f394326c41452e3b3348422e9a06929717e413 | 2,279 | cpp | C++ | 2020/day12/main.cpp | bielskij/AOC-2019 | e98d660412037b3fdac4a6b49adcb9230f518c99 | [
"MIT"
] | null | null | null | 2020/day12/main.cpp | bielskij/AOC-2019 | e98d660412037b3fdac4a6b49adcb9230f518c99 | [
"MIT"
] | null | null | null | 2020/day12/main.cpp | bielskij/AOC-2019 | e98d660412037b3fdac4a6b49adcb9230f518c99 | [
"MIT"
] | null | null | null | #include "common/types.h"
#include "utils/file.h"
#include "utils/utils.h"
#define DEBUG_LEVEL 5
#include "common/debug.h"
int main(int argc, char *argv[]) {
auto lines = File::readAllLines(argv[1]);
{
Point<int> position;
int angle = 90;
for (auto &l : lines) {
int distance = utils::toInt(l.substr(1));
int turnAngle = -1;
switch (l[0]) {
case 'N': turnAngle = 0; break;
case 'E': turnAngle = 90; break;
case 'S': turnAngle = 180; break;
case 'W': turnAngle = 270; break;
case 'F':
break;
case 'L':
{
angle = (angle + 360 - distance) % 360;
distance = 0;
}
break;
case 'R':
{
angle = (angle + distance) % 360;
distance = 0;
}
break;
default:
break;
}
{
int modX = 0;
int modY = 0;
switch (turnAngle >= 0 ? turnAngle : angle) {
case 0: modY = 1; break;
case 90: modX = 1; break;
case 180: modY = -1; break;
case 270: modX = -1; break;
default:
break;
}
position.x(position.x() + modX * distance);
position.y(position.y() + modY * distance);
}
}
PRINTF(("PART_A: %d", std::abs(position.x()) + std::abs(position.y())));
}
{
Point<int> shipPosition;
Point<int> waypoint(10, 1);
for (auto &l : lines) {
int distance = utils::toInt(l.substr(1));
switch (l[0]) {
case 'N': waypoint.y(waypoint.y() + distance); break;
case 'E': waypoint.x(waypoint.x() + distance); break;
case 'S': waypoint.y(waypoint.y() - distance); break;
case 'W': waypoint.x(waypoint.x() - distance); break;
case 'F':
{
shipPosition.x(shipPosition.x() + waypoint.x() * distance);
shipPosition.y(shipPosition.y() + waypoint.y() * distance);
}
break;
case 'R':
{
int num = distance / 90;
while (num--) {
int tmp = waypoint.x();
waypoint.x(waypoint.y());
waypoint.y(-tmp);
}
}
break;
case 'L':
{
int num = distance / 90;
while (num--) {
int tmp = waypoint.x();
waypoint.x(-waypoint.y());
waypoint.y(tmp);
}
}
break;
}
}
PRINTF(("PART_B: %d", std::abs(shipPosition.x()) + std::abs(shipPosition.y())));
}
return 0;
}
| 18.834711 | 82 | 0.523475 | bielskij |
09f547590222a1fc0b109f21a33c9c7a91386b5a | 526 | cpp | C++ | ProjectEuler/66/code.cpp | sjj118/OI-Code | 964ea6e799d14010f305c7e4aee269d860a781f7 | [
"MIT"
] | null | null | null | ProjectEuler/66/code.cpp | sjj118/OI-Code | 964ea6e799d14010f305c7e4aee269d860a781f7 | [
"MIT"
] | null | null | null | ProjectEuler/66/code.cpp | sjj118/OI-Code | 964ea6e799d14010f305c7e4aee269d860a781f7 | [
"MIT"
] | null | null | null | #include<bits/stdc++.h>
#define rg register
#define rep(i,x,y) for(rg int i=(x);i<=(y);++i)
#define per(i,x,y) for(rg int i=(x);i>=(y);--i)
using namespace std;
typedef long long LL;
inline LL sqr(LL x){return x*x;}
LL ansd,ansx;
int main(){
int n;scanf("%d",&n);
rep(d,1,n)if(sqr(LL(sqrt(d)))!=d){
for(LL y=1;;++y){
if(y>100000000){cerr<<d<<" "<<y<<endl;break;}
LL x=1+d*sqr(y);
if(sqr(LL(sqrt(x)))==x){
x=LL(sqrt(x));
if(x>ansx)ansx=x,ansd=d;
break;
}
}
}
cout<<ansd<<" "<<ansx;
return 0;
}
| 21.04 | 48 | 0.553232 | sjj118 |
09f5622660315bdacee42b4d1a8e844860ac2a21 | 7,123 | cpp | C++ | openEAR-0.1.0/src/smileComponent.cpp | trimlab/Voice-Emotion-Detection | c7272dd2f70e2d4b8eee304e68578494d7ef624c | [
"MIT"
] | null | null | null | openEAR-0.1.0/src/smileComponent.cpp | trimlab/Voice-Emotion-Detection | c7272dd2f70e2d4b8eee304e68578494d7ef624c | [
"MIT"
] | null | null | null | openEAR-0.1.0/src/smileComponent.cpp | trimlab/Voice-Emotion-Detection | c7272dd2f70e2d4b8eee304e68578494d7ef624c | [
"MIT"
] | null | null | null | /*F******************************************************************************
*
* openSMILE - open Speech and Music Interpretation by Large-space Extraction
* the open-source Munich Audio Feature Extraction Toolkit
* Copyright (C) 2008-2009 Florian Eyben, Martin Woellmer, Bjoern Schuller
*
*
* Institute for Human-Machine Communication
* Technische Universitaet Muenchen (TUM)
* D-80333 Munich, Germany
*
*
* If you use openSMILE or any code from openSMILE in your research work,
* you are kindly asked to acknowledge the use of openSMILE in your publications.
* See the file CITING.txt for details.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
******************************************************************************E*/
/*
openSMILE component hierarchy:
cSmileComponent (basic cmdline and config functionality)
|
v
cProcessorComponent - contains: Reader, Writer, ref to data mem, one or more compute components, plus interconnection logic
cComputeComponent - implements a specific algo, clearly defined io interface
I: vector, O: vector
I: matrix, O: vector
(O: matrix ?? )
cReaderComponent - reads data from dataMemory and provides frame or matrix (also registers read request)
cWriterComponent - writes data to dataMemory (takes vector, (or matrix??)), also registers Level (data memory at the end will check, if all dependencies are fullfilled..?)
*/
/*
component base class,
with register and config functionality
//
*/
/* good practice for dynamic component library compatibility (will be added soon..):
define a global register method:
sComponentInfo * registerMe(cConfigManager *_confman) {
sMyComponent::registerComponent(_confman);
}
also: add a pointer to this method to global component list...
*/
#include <smileComponent.hpp>
#include <componentManager.hpp>
#define MODULE "cSmileComponent"
SMILECOMPONENT_STATICS(cSmileComponent)
// static, must be overriden by derived component class, these are only examples...!!!!
// register component will return NULL, if the component could not be registered (fatal error..)
// it will return a valid struct, with rA=1, if some information, e.g. sub-configTypes are still missing
SMILECOMPONENT_REGCOMP(cSmileComponent)
{
SMILECOMPONENT_REGCOMP_INIT
scname = COMPONENT_NAME_XXXX;
sdescription = COMPONENT_DESCRIPTION_XXXX;
// configure your component's configType:
SMILECOMPONENT_CREATE_CONFIGTYPE
//ConfigType *ct = new ConfigType(scname); if (ct == NULL) OUT_OF_MEMORY;
ct->setField("f1", "this is an example int", 0);
if (ct->setField("subconf", "this is config of sub-component",
sconfman->getTypeObj("nameOfSubCompType"), NO_ARRAY, DONT_FREE) == -1) {
rA=1; // if subtype not yet found, request , re-register in the next iteration
}
// ...
SMILECOMPONENT_IFNOTREGAGAIN( {} )
// change cSmileComponent to cMyComponent !
SMILECOMPONENT_MAKEINFO(cSmileComponent);
//return makeInfo(sconfman, scname, sdescription, cSmileComponent::create, rA);
}
SMILECOMPONENT_CREATE_ABSTRACT(cSmileComponent)
// staic, internal....
sComponentInfo * cSmileComponent::makeInfo(cConfigManager *_confman, const char *_name, const char *_description, cSmileComponent * (*create) (const char *_instname), int regAgain, int _abstract, int _nodmem)
{
sComponentInfo *info = new sComponentInfo;
if (info == NULL) OUT_OF_MEMORY;
info->componentName = _name;
info->description = _description;
info->create = create;
info->registerAgain = regAgain;
info->abstract = _abstract;
info->noDmem = _nodmem;
info->next = NULL;
return info;
}
//--------------------- dynamic:
cSmileComponent * cSmileComponent::getComponentInstance(const char * name) {
if (compman != NULL)
return compman->getComponentInstance(name);
else
return NULL;
}
const char * cSmileComponent::getComponentInstanceType(const char * name) {
if (compman != NULL)
return compman->getComponentInstanceType(name);
else
return NULL;
}
cSmileComponent * cSmileComponent::createComponent(const char*_name, const char*_type)
{
if (compman != NULL)
return compman->createComponent(_name,_type);
else
return NULL;
}
cSmileComponent::cSmileComponent(const char *instname) :
iname(NULL),
id(-1),
compman(NULL),
parent(NULL),
cfname(NULL),
_isRegistered(0),
_isConfigured(0),
_isFinalised(0),
_isReady(0),
confman(NULL),
override(0),
manualConfig(0),
cname(NULL),
EOI(0),
_runMe(1)
{
smileMutexCreate(messageMtx);
if (instname == NULL) COMP_ERR("cannot create cSmileComponent with instanceName == NULL!");
iname = strdup(instname);
cfname = iname;
//fetchConfig(); // must be called by the components themselves, after the component was created!
}
void cSmileComponent::setComponentEnvironment(cComponentManager *_compman, int _id, cSmileComponent *_parent)
{
if (_compman != NULL) {
compman = _compman;
id = _id;
} else {
SMILE_ERR(3,"setting NULL componentManager in cSmileComponent::setComponentEnvironment !");
}
parent=_parent;
mySetEnvironment();
}
int cSmileComponent::sendComponentMessage( const char *recepient, cComponentMessage *_msg )
{
int ret=0;
if (compman != NULL) {
if (_msg != NULL) _msg->sender = getInstName();
ret = compman->sendComponentMessage( recepient, _msg );
}
return ret;
}
double cSmileComponent::getSmileTime() {
if (compman != NULL) {
return compman->getSmileTime();
}
return 0.0;
}
int cSmileComponent::finaliseInstance()
{
if (!_isConfigured) {
SMILE_DBG(7,"finaliseInstance called on a not yet successfully configured instance '%s'",getInstName());
return 0;
}
if (_isFinalised) return 1;
_isFinalised = myFinaliseInstance();
_isReady = _isFinalised;
return _isFinalised;
}
cSmileComponent::~cSmileComponent()
{
if ((iname != cfname)&&(cfname!=NULL)) free (cfname);
if (iname != NULL) free(iname);
smileMutexDestroy(messageMtx);
}
// signal EOI to componentManager (theoretically only useful for dataSource components, however we make it accessible to all smile components)
// NOTE: you do not need to do this explicitely.. if all components fail, EOI is assumed, then a new tickLoop is started by the component manager
void cSmileComponent::signalEOI()
{
if (compman != NULL)
compman->setEOI();
}
| 29.928571 | 208 | 0.701249 | trimlab |
09f802dec9f0bc3b642bc1181631a48567eac0e3 | 1,939 | hpp | C++ | include/uvx/method.hpp | keeword/uvx | 7e924d29c8e8d44a49447de0bf93bd60f680311f | [
"MIT"
] | null | null | null | include/uvx/method.hpp | keeword/uvx | 7e924d29c8e8d44a49447de0bf93bd60f680311f | [
"MIT"
] | null | null | null | include/uvx/method.hpp | keeword/uvx | 7e924d29c8e8d44a49447de0bf93bd60f680311f | [
"MIT"
] | null | null | null | #pragma once
#include <any>
#include <unordered_map>
#include <type_traits>
#include "functype.hpp"
namespace utils {
class methods {
private:
using method_type = std::function<std::any(std::any)>;
template <typename R, typename F>
struct invoker {
static R invoke(const F& f, std::any any) {
using argument_tuple = typename functype::traits<F>::argument_tuple;
return std::apply(f, std::any_cast<argument_tuple>(std::move(any)));
}
};
template <typename F>
struct invoker<void, F> {
static std::any invoke(const F& f, std::any any) {
using argument_tuple = typename functype::traits<F>::argument_tuple;
std::apply(f, std::any_cast<argument_tuple>(std::move(any)));
return std::any();
}
};
public:
template <typename Func>
void store(std::size_t id, Func func) {
static_assert(std::is_copy_constructible<Func>::value, "method must be CopyConstructible");
static_assert(std::is_move_constructible<Func>::value, "method must be MoveConstructible");
if (map_.count(id)) { // delete the already exist one
map_.erase(id);
}
map_.emplace(id, [func = std::move(func)](std::any any)->std::any {
using result_type = typename functype::traits<Func>::result_type;
return invoker<result_type, Func>::invoke(func, std::move(any)); }
);
}
// exception:
// bad_any_cast: argument type not match the method
// out_of_range: method not exist
template <typename... Args>
decltype(auto) invoke(std::size_t id, Args&&... args) {
return map_.at(id)(std::tuple<typename std::remove_reference<Args>::type...>(std::forward<Args>(args)...));
}
bool exist(std::size_t id) {
return !!map_.count(id);
}
private:
std::unordered_map<std::size_t, method_type> map_;
};
} // namespace utils
| 30.296875 | 115 | 0.621454 | keeword |
09f8408031c24c372dc91a3cdaccaff97849463c | 5,210 | inl | C++ | include/Utopia/Render/details/RenderState_AutoRefl.inl | Justin-sky/Utopia | 71912290155a469ad578234a1f5e1695804e04a3 | [
"MIT"
] | null | null | null | include/Utopia/Render/details/RenderState_AutoRefl.inl | Justin-sky/Utopia | 71912290155a469ad578234a1f5e1695804e04a3 | [
"MIT"
] | null | null | null | include/Utopia/Render/details/RenderState_AutoRefl.inl | Justin-sky/Utopia | 71912290155a469ad578234a1f5e1695804e04a3 | [
"MIT"
] | 1 | 2021-04-24T23:26:09.000Z | 2021-04-24T23:26:09.000Z | // This file is generated by Ubpa::USRefl::AutoRefl
#pragma once
#include <USRefl/USRefl.h>
template<>
struct Ubpa::USRefl::TypeInfo<Ubpa::Utopia::CullMode>
: Ubpa::USRefl::TypeInfoBase<Ubpa::Utopia::CullMode>
{
static constexpr AttrList attrs = {};
static constexpr FieldList fields = {
Field{"NONE", Ubpa::Utopia::CullMode::NONE},
Field{"FRONT", Ubpa::Utopia::CullMode::FRONT},
Field{"BACK", Ubpa::Utopia::CullMode::BACK},
};
};
template<>
struct Ubpa::USRefl::TypeInfo<Ubpa::Utopia::CompareFunc>
: Ubpa::USRefl::TypeInfoBase<Ubpa::Utopia::CompareFunc>
{
static constexpr AttrList attrs = {};
static constexpr FieldList fields = {
Field{"NEVER", Ubpa::Utopia::CompareFunc::NEVER},
Field{"LESS", Ubpa::Utopia::CompareFunc::LESS},
Field{"EQUAL", Ubpa::Utopia::CompareFunc::EQUAL},
Field{"LESS_EQUAL", Ubpa::Utopia::CompareFunc::LESS_EQUAL},
Field{"GREATER", Ubpa::Utopia::CompareFunc::GREATER},
Field{"NOT_EQUAL", Ubpa::Utopia::CompareFunc::NOT_EQUAL},
Field{"GREATER_EQUAL", Ubpa::Utopia::CompareFunc::GREATER_EQUAL},
Field{"ALWAYS", Ubpa::Utopia::CompareFunc::ALWAYS},
};
};
template<>
struct Ubpa::USRefl::TypeInfo<Ubpa::Utopia::Blend>
: Ubpa::USRefl::TypeInfoBase<Ubpa::Utopia::Blend>
{
static constexpr AttrList attrs = {};
static constexpr FieldList fields = {
Field{"ZERO", Ubpa::Utopia::Blend::ZERO},
Field{"ONE", Ubpa::Utopia::Blend::ONE},
Field{"SRC_COLOR", Ubpa::Utopia::Blend::SRC_COLOR},
Field{"INV_SRC_COLOR", Ubpa::Utopia::Blend::INV_SRC_COLOR},
Field{"SRC_ALPHA", Ubpa::Utopia::Blend::SRC_ALPHA},
Field{"INV_SRC_ALPHA", Ubpa::Utopia::Blend::INV_SRC_ALPHA},
Field{"DEST_ALPHA", Ubpa::Utopia::Blend::DEST_ALPHA},
Field{"INV_DEST_ALPHA", Ubpa::Utopia::Blend::INV_DEST_ALPHA},
Field{"DEST_COLOR", Ubpa::Utopia::Blend::DEST_COLOR},
Field{"INV_DEST_COLOR", Ubpa::Utopia::Blend::INV_DEST_COLOR},
Field{"SRC_ALPHA_SAT", Ubpa::Utopia::Blend::SRC_ALPHA_SAT},
Field{"BLEND_FACTOR", Ubpa::Utopia::Blend::BLEND_FACTOR},
Field{"INV_BLEND_FACTOR", Ubpa::Utopia::Blend::INV_BLEND_FACTOR},
Field{"SRC1_COLOR", Ubpa::Utopia::Blend::SRC1_COLOR},
Field{"INV_SRC1_COLOR", Ubpa::Utopia::Blend::INV_SRC1_COLOR},
Field{"SRC1_ALPHA", Ubpa::Utopia::Blend::SRC1_ALPHA},
Field{"INV_SRC1_ALPHA", Ubpa::Utopia::Blend::INV_SRC1_ALPHA},
};
};
template<>
struct Ubpa::USRefl::TypeInfo<Ubpa::Utopia::BlendOp>
: Ubpa::USRefl::TypeInfoBase<Ubpa::Utopia::BlendOp>
{
static constexpr AttrList attrs = {};
static constexpr FieldList fields = {
Field{"ADD", Ubpa::Utopia::BlendOp::ADD},
Field{"SUBTRACT", Ubpa::Utopia::BlendOp::SUBTRACT},
Field{"REV_SUBTRACT", Ubpa::Utopia::BlendOp::REV_SUBTRACT},
Field{"MIN", Ubpa::Utopia::BlendOp::MIN},
Field{"MAX", Ubpa::Utopia::BlendOp::MAX},
};
};
template<>
struct Ubpa::USRefl::TypeInfo<Ubpa::Utopia::BlendState>
: Ubpa::USRefl::TypeInfoBase<Ubpa::Utopia::BlendState>
{
static constexpr AttrList attrs = {};
static constexpr FieldList fields = {
Field{"enable", &Ubpa::Utopia::BlendState::enable},
Field{"src", &Ubpa::Utopia::BlendState::src},
Field{"dest", &Ubpa::Utopia::BlendState::dest},
Field{"op", &Ubpa::Utopia::BlendState::op},
Field{"srcAlpha", &Ubpa::Utopia::BlendState::srcAlpha},
Field{"destAlpha", &Ubpa::Utopia::BlendState::destAlpha},
Field{"opAlpha", &Ubpa::Utopia::BlendState::opAlpha},
};
};
template<>
struct Ubpa::USRefl::TypeInfo<Ubpa::Utopia::StencilOp>
: Ubpa::USRefl::TypeInfoBase<Ubpa::Utopia::StencilOp>
{
static constexpr AttrList attrs = {};
static constexpr FieldList fields = {
Field{"KEEP", Ubpa::Utopia::StencilOp::KEEP},
Field{"ZERO", Ubpa::Utopia::StencilOp::ZERO},
Field{"REPLACE", Ubpa::Utopia::StencilOp::REPLACE},
Field{"INCR_SAT", Ubpa::Utopia::StencilOp::INCR_SAT},
Field{"DECR_SAT", Ubpa::Utopia::StencilOp::DECR_SAT},
Field{"INVERT", Ubpa::Utopia::StencilOp::INVERT},
Field{"INCR", Ubpa::Utopia::StencilOp::INCR},
Field{"DECR", Ubpa::Utopia::StencilOp::DECR},
};
};
template<>
struct Ubpa::USRefl::TypeInfo<Ubpa::Utopia::StencilState>
: Ubpa::USRefl::TypeInfoBase<Ubpa::Utopia::StencilState>
{
static constexpr AttrList attrs = {};
static constexpr FieldList fields = {
Field{"enable", &Ubpa::Utopia::StencilState::enable},
Field{"ref", &Ubpa::Utopia::StencilState::ref},
Field{"readMask", &Ubpa::Utopia::StencilState::readMask},
Field{"writeMask", &Ubpa::Utopia::StencilState::writeMask},
Field{"failOp", &Ubpa::Utopia::StencilState::failOp},
Field{"depthFailOp", &Ubpa::Utopia::StencilState::depthFailOp},
Field{"passOp", &Ubpa::Utopia::StencilState::passOp},
Field{"func", &Ubpa::Utopia::StencilState::func},
};
};
template<>
struct Ubpa::USRefl::TypeInfo<Ubpa::Utopia::RenderState>
: Ubpa::USRefl::TypeInfoBase<Ubpa::Utopia::RenderState>
{
static constexpr AttrList attrs = {};
static constexpr FieldList fields = {
Field{"cullMode", &Ubpa::Utopia::RenderState::cullMode},
Field{"zTest", &Ubpa::Utopia::RenderState::zTest},
Field{"zWrite", &Ubpa::Utopia::RenderState::zWrite},
Field{"stencilState", &Ubpa::Utopia::RenderState::stencilState},
Field{"blendStates", &Ubpa::Utopia::RenderState::blendStates},
Field{"colorMask", &Ubpa::Utopia::RenderState::colorMask},
};
};
| 34.966443 | 67 | 0.708445 | Justin-sky |
67006f9854b9893fb7ac37adb20133822135a87e | 1,225 | cpp | C++ | WirelessThermometer/TimerSwitchWithServo/DataStore.cpp | anders-liu/arduino-gallery | 8c65701a33358891b7105b50f831d7f5797288ad | [
"MIT"
] | 1 | 2019-11-07T22:44:27.000Z | 2019-11-07T22:44:27.000Z | WirelessThermometer/TimerSwitchWithServo/DataStore.cpp | anders-liu/arduino-gallery | 8c65701a33358891b7105b50f831d7f5797288ad | [
"MIT"
] | null | null | null | WirelessThermometer/TimerSwitchWithServo/DataStore.cpp | anders-liu/arduino-gallery | 8c65701a33358891b7105b50f831d7f5797288ad | [
"MIT"
] | null | null | null | #include <EEPROM.h>
#include "DataStore.h"
DataStore ds;
#define DS_ADDR_SERVO_OFF 0
#define DS_ADDR_SERVO_ON 1
#define DS_ADDR_SERVO_CUR 2
#define DS_ADDR_POWER_ON 3
void DataStore::setup() {
this->setUiStage(UI_STAGE_RUNNING);
uint8_t value;
value = EEPROM.read(DS_ADDR_SERVO_OFF);
this->setServoOffValue(value);
this->setCalibrationOffValue(value);
value = EEPROM.read(DS_ADDR_SERVO_ON);
this->setServoOnValue(value);
this->setCalibrationOnValue(value);
value = EEPROM.read(DS_ADDR_SERVO_CUR);
this->setCurrentServoValue(value);
value = EEPROM.read(DS_ADDR_POWER_ON);
this->setIsPowerOn(value);
}
void DataStore::loop() {
if (ds.getServoOffValueReadyToSave()) {
EEPROM.update(DS_ADDR_SERVO_OFF, ds.getServoOffValue());
ds.clearServoOffValueReadyToSave();
}
else if (ds.getServoOnValueReadyToSave()) {
EEPROM.update(DS_ADDR_SERVO_ON, ds.getServoOnValue());
ds.clearServoOnValueReadyToSave();
}
else if (ds.getCurrentServoValueReadyToSave()) {
EEPROM.update(DS_ADDR_SERVO_CUR, ds.getCurrentServoValue());
ds.clearCurrentServoValueReadyToSave();
}
else if (ds.getIsPowerOnReadyToSave()) {
EEPROM.update(DS_ADDR_POWER_ON, ds.getIsPowerOn());
ds.clearIsPowerOnReadyToSave();
}
}
| 24.5 | 62 | 0.76898 | anders-liu |
67059c9fa758079550b6625591ddb4b1ce48a904 | 2,376 | cpp | C++ | 7DRL 2017/Player.cpp | marukrap/woozoolike | ca16b67bce61828dded707f1c529558646daf0b3 | [
"MIT"
] | 37 | 2017-03-26T00:20:49.000Z | 2021-02-11T18:23:22.000Z | 7DRL 2017/Player.cpp | marukrap/woozoolike | ca16b67bce61828dded707f1c529558646daf0b3 | [
"MIT"
] | null | null | null | 7DRL 2017/Player.cpp | marukrap/woozoolike | ca16b67bce61828dded707f1c529558646daf0b3 | [
"MIT"
] | 9 | 2017-03-24T04:38:35.000Z | 2021-08-22T00:02:43.000Z | #include "Player.hpp"
Player::Player()
{
// arrow keys and Home, End, PageUp, PageDn
keyBinding[sf::Keyboard::Left] = Action::MoveLeft;
keyBinding[sf::Keyboard::Right] = Action::MoveRight;
keyBinding[sf::Keyboard::Up] = Action::MoveUp;
keyBinding[sf::Keyboard::Down] = Action::MoveDown;
keyBinding[sf::Keyboard::Home] = Action::MoveLeftUp;
keyBinding[sf::Keyboard::End] = Action::MoveLeftDown;
keyBinding[sf::Keyboard::PageUp] = Action::MoveRightUp;
keyBinding[sf::Keyboard::PageDown] = Action::MoveRightDown;
// numpad keys
keyBinding[sf::Keyboard::Numpad4] = Action::MoveLeft;
keyBinding[sf::Keyboard::Numpad6] = Action::MoveRight;
keyBinding[sf::Keyboard::Numpad8] = Action::MoveUp;
keyBinding[sf::Keyboard::Numpad2] = Action::MoveDown;
keyBinding[sf::Keyboard::Numpad7] = Action::MoveLeftUp;
keyBinding[sf::Keyboard::Numpad1] = Action::MoveLeftDown;
keyBinding[sf::Keyboard::Numpad9] = Action::MoveRightUp;
keyBinding[sf::Keyboard::Numpad3] = Action::MoveRightDown;
// vi keys
keyBinding[sf::Keyboard::H] = Action::MoveLeft;
keyBinding[sf::Keyboard::L] = Action::MoveRight;
keyBinding[sf::Keyboard::K] = Action::MoveUp;
keyBinding[sf::Keyboard::J] = Action::MoveDown;
keyBinding[sf::Keyboard::Y] = Action::MoveLeftUp;
keyBinding[sf::Keyboard::B] = Action::MoveLeftDown;
keyBinding[sf::Keyboard::U] = Action::MoveRightUp;
keyBinding[sf::Keyboard::N] = Action::MoveRightDown;
//
keyBinding[sf::Keyboard::Space] = Action::Interact;
keyBinding[sf::Keyboard::Return] = Action::Interact;
keyBinding[sf::Keyboard::G] = Action::PickUp;
keyBinding[sf::Keyboard::Comma] = Action::PickUp;
keyBinding[sf::Keyboard::Numpad5] = Action::Wait;
keyBinding[sf::Keyboard::Delete] = Action::Wait;
keyBinding[sf::Keyboard::Period] = Action::Wait;
keyBinding[sf::Keyboard::F] = Action::Fire;
keyBinding[sf::Keyboard::Tab] = Action::CancelFire;
keyBinding[sf::Keyboard::Escape] = Action::CancelFire;
keyBinding[sf::Keyboard::Q] = Action::PreviousWeapon;
keyBinding[sf::Keyboard::W] = Action::NextWeapon;
keyBinding[sf::Keyboard::D] = Action::DropWeapon;
keyBinding[sf::Keyboard::E] = Action::EnterOrExit;
}
Action Player::getAction(sf::Keyboard::Key key)
{
auto found = keyBinding.find(key);
if (found != keyBinding.end())
return found->second;
return Action::Unknown;
} | 36 | 61 | 0.703704 | marukrap |
6707c0e5e449744b2f81657569421bf1c1b21b86 | 1,716 | cpp | C++ | DevGame/Motor2D/Settings.cpp | MAtaur00/Development-Game | 3c8ef10d9a42abc2d4547b1a67c45e98b9e29f07 | [
"MIT"
] | null | null | null | DevGame/Motor2D/Settings.cpp | MAtaur00/Development-Game | 3c8ef10d9a42abc2d4547b1a67c45e98b9e29f07 | [
"MIT"
] | null | null | null | DevGame/Motor2D/Settings.cpp | MAtaur00/Development-Game | 3c8ef10d9a42abc2d4547b1a67c45e98b9e29f07 | [
"MIT"
] | 5 | 2018-11-07T16:04:35.000Z | 2018-11-12T11:01:05.000Z | #include "Settings.h"
#include "j1Gui.h"
#include "j1Textures.h"
#include "j1Render.h"
#include "p2Log.h"
#include "j1Window.h"
#include "j1App.h"
#include "Menu.h"
#include "Brofiler/Brofiler.h"
Settings::Settings()
{
name.create("credits");
}
Settings::~Settings() {}
bool Settings::Awake(pugi::xml_node& conf)
{
bool ret = true;
return ret;
}
bool Settings::Start()
{
bg_image = (Image*)App->gui->AddImage(0, 0, { 0, 0, 1024, 640 }, NULL, this);
vsync_checkbox = (CheckBox*)App->gui->AddCheckbox(200, 200, { 1419, 562, 26, 27 }, { 1452, 562, 26, 27 }, "VSYNC", NULL, this);
button_back = (Button*)App->gui->AddButton(550, 300, { 1595, 71, 246, 59 }, { 1595, 327, 246, 59 }, { 1595, 190, 246, 59 }, "Back", NULL, this);
return true;
}
bool Settings::PreUpdate()
{
return true;
}
bool Settings::Update(float dt)
{
return true;
}
void Settings::CallBack(UI_Element* element)
{
if (element == button_back)
{
active = false;
App->menu->active = true;
CleanUp();
App->menu->Start();
}
}
bool Settings::PostUpdate()
{
return true;
}
bool Settings::CleanUp()
{
if (has_started)
{
App->gui->UI_elements.del(App->gui->UI_elements.At(App->gui->UI_elements.find(bg_image)));
App->gui->UI_elements.del(App->gui->UI_elements.At(App->gui->UI_elements.find(button_back->text)));
App->gui->UI_elements.del(App->gui->UI_elements.At(App->gui->UI_elements.find(button_back)));
App->gui->UI_elements.del(App->gui->UI_elements.At(App->gui->UI_elements.find(vsync_checkbox->text)));
App->gui->UI_elements.del(App->gui->UI_elements.At(App->gui->UI_elements.find(vsync_checkbox)));
delete bg_image;
delete button_back;
delete vsync_checkbox;
has_started = false;
}
return true;
} | 21.721519 | 145 | 0.674825 | MAtaur00 |
671045c2f8eee9555dee45635c71459d9957f643 | 11,909 | cpp | C++ | tools/tool_load_prediction/src/tool.cpp | jusch196/chameleon-apps | b63a6b20a62c450565403b0768551cca9c288156 | [
"BSD-3-Clause"
] | null | null | null | tools/tool_load_prediction/src/tool.cpp | jusch196/chameleon-apps | b63a6b20a62c450565403b0768551cca9c288156 | [
"BSD-3-Clause"
] | null | null | null | tools/tool_load_prediction/src/tool.cpp | jusch196/chameleon-apps | b63a6b20a62c450565403b0768551cca9c288156 | [
"BSD-3-Clause"
] | 2 | 2020-03-30T08:08:53.000Z | 2021-04-16T10:24:50.000Z | #include "tool.h"
//================================================================
// Variables
//================================================================
static cham_t_set_callback_t cham_t_set_callback;
static cham_t_get_rank_data_t cham_t_get_rank_data;
static cham_t_get_thread_data_t cham_t_get_thread_data;
static cham_t_get_rank_info_t cham_t_get_rank_info;
//================================================================
// Additional functions
//================================================================
int compare( const void *pa, const void *pb ){
const int *a = (int *) pa;
const int *b = (int *) pb;
if(a[0] == b[0])
return a[0] - b[0];
else
return a[1] - b[1];
}
//================================================================
// Callback Functions
//================================================================
/**
* Callback task create.
*
* @param task: a pointer to the migration task object at Chameleon-side.
* @param arg_sizes: list of argument sizes
* @param queue_time: could be measured at the time a task is added to the queue
* @param codeptr_ra: the code pointer of the task-entry (function)
* @param taskwait_counter: id of the current iteration (cycle)
*/
static void
on_cham_t_callback_task_create(cham_migratable_task_t * task, std::vector<int64_t> arg_sizes,
double queued_time, intptr_t codeptr_ra, int taskwait_counter)
{
int rank_id = cham_t_get_rank_info()->comm_rank;
TYPE_TASK_ID cham_task_id = chameleon_get_task_id(task);
// get num of args per task
const int num_args = arg_sizes.size();
int num_cycle = taskwait_counter;
// create custom data structure and use task_data as pointer
prof_task_info_t *cur_task = new prof_task_info_t;
if (rank_id != 0){
int shift_rank_id = rank_id << NBITS_SHIFT;
cur_task->tool_tid = (profiled_task_list.ntasks_per_rank * num_cycle) + (cham_task_id - shift_rank_id - 1);
} else {
cur_task->tool_tid = (profiled_task_list.ntasks_per_rank * num_cycle) + (cham_task_id - 1);
}
cur_task->cham_tid = cham_task_id;
cur_task->rank_belong = rank_id;
cur_task->num_args = num_args;
cur_task->que_time = queued_time;
cur_task->code_ptr = codeptr_ra;
// try to get cpu-core frequency here
int core_id = sched_getcpu();
double freq = get_core_freq(core_id);
cur_task->core_freq = freq;
// get arg_sizes
cur_task->args_list.resize(num_args);
for (int i = 0; i < num_args; i++){
cur_task->args_list[i] = arg_sizes[i];
}
// add task to the list
// int thread_id = omp_get_thread_num();
// printf("[TOOL] R%d T%d: callback create task cham_tid=%d, tool_tid=%d, tw_counter=%d\n",
// rank_id, thread_id, cur_task->cham_tid, cur_task->tool_tid, num_cycle);
profiled_task_list.push_back(cur_task);
// increase tool_tasks_counter
tool_tasks_count++;
}
/**
* Callback get stats_load info after a cycle (iteration) is done.
*
* @param taskwait_counter: id of the current iteration (cycle).
* @param thread_id: the last thread calls this callback.
* @param taskwait_load: the loac value per this cycle.
*/
static void
on_cham_t_callback_get_load_stats_per_taskwait(int32_t taskwait_counter,
int32_t thread_id, double taskwait_load)
{
int rank = cham_t_get_rank_info()->comm_rank;
int iter = taskwait_counter;
profiled_task_list.add_avgload(taskwait_load, iter);
// get the wallclock execution time per iteration
avg_load_per_iter_list[iter] = taskwait_load;
}
/**
* Callback get stats_load info after a cycle (iteration) is done.
*
* @param taskwait_counter: id of the current iteration (cycle).
* @param thread_id: the last thread calls this callback.
* @param taskwait_load: the loac value per this cycle.
*/
static void
on_cham_t_callback_get_task_wallclock_time(int32_t taskwait_counter,
int32_t thread_id, int task_id, double wallclock_time)
{
int idx;
int num_cycle = taskwait_counter;
int rank_id = cham_t_get_rank_info()->comm_rank;
if (rank_id != 0){
int shift_rank_id = rank_id << NBITS_SHIFT;
idx = (profiled_task_list.ntasks_per_rank * num_cycle) + (task_id - shift_rank_id - 1);
} else {
idx = (profiled_task_list.ntasks_per_rank * num_cycle) + (task_id - 1);
}
// add the wallclock time per task
profiled_task_list.add_wallclock_time(wallclock_time, task_id, num_cycle, thread_id, idx);
// printf("[CHAMTOOL] T%d: passed add_wallclock_time(), task_id=%d, tool_idx=%d\n", thread_id, task_id, idx);
}
/**
* Callback get the trigger from comm_thread, then training the pred-model.
*
* @param taskwait_counter: id of the current iteration (cycle), now trigger this
* callback by the num of passed iters.
* @return is_trained: a bool flag to notice the prediction model that has been trained.
*/
static bool
on_cham_t_callback_train_prediction_model(int32_t taskwait_counter, int prediction_mode)
{
bool is_trained = false;
int rank = cham_t_get_rank_info()->comm_rank;
/* Mode 1&2: prediction by time-series load as the patterns */
if (prediction_mode == 1 || prediction_mode == 2){
printf("[CHAM_TOOL] R%d: starts training pred_model at iter-%d\n", rank, taskwait_counter);
int num_points = 6;
int num_finished_iters = taskwait_counter-1;
is_trained = online_mlpack_training_iterative_load(profiled_task_list, num_points, num_finished_iters);
}
/* Mode 3: prediction by task-characterization as the patterns */
else if (prediction_mode == 3){
printf("[CHAM_TOOL] R%d: starts training pred_model at iter-%d\n", rank, taskwait_counter);
is_trained = online_mlpack_training_task_features(profiled_task_list, taskwait_counter);
}
return is_trained;
}
/**
* Callback get the trigger from comm_thread, then calling the trained pred-model.
*
* This callback is used to validate or get the predicted values when cham_lib requests.
* @param taskwait_counter: id of the current iteration (cycle).
* @return predicted_value: for the load of the corresponding iter.
*/
static std::vector<double>
on_cham_t_callback_load_prediction_model(int32_t taskwait_counter, int prediction_mode)
{
// prepare the input
int rank = cham_t_get_rank_info()->comm_rank;
int num_features = 6;
int s_point = taskwait_counter - num_features;
int e_point = taskwait_counter;
std::vector<double> pred_load_vec(1, 0.0);
/* Mode 1: predict iter-by-iter, by time-series patterns */
if (prediction_mode == 1) {
get_iter_by_iter_prediction(s_point, e_point, pred_load_vec);
}
/* Mode 2: predict the whole future, by time-series patterns and predicted values */
else if (prediction_mode == 2) {
pred_load_vec.resize(pre_load_per_iter_list.size(), 0.0);
get_whole_future_prediction(rank, s_point, e_point, pred_load_vec);
}
/* Mode 3: predict iter-by-iter, by task-characterization */
else if (prediction_mode == 3) {
pred_load_vec.resize(profiled_task_list.ntasks_per_rank, 0.0);
get_iter_by_iter_prediction_by_task_characs(taskwait_counter, pred_load_vec);
}
// TODO: consider the size of vector
return pred_load_vec;
}
//================================================================
// Start Tool & Register Callbacks
//================================================================
#define register_callback_t(name, type) \
do{ \
type f_##name = &on_##name; \
if (cham_t_set_callback(name, (cham_t_callback_t)f_##name) == cham_t_set_never) \
printf("0: Could not register callback '" #name "'\n"); \
} while(0)
#define register_callback(name) register_callback_t(name, name##_t)
/**
* Initializing the cham-tool callbacks.
*
* @param lookup: search the name of activated callbacks.
* @param tool_data: return the profile data of the tool. But temporarily have
* not used this param, just return directly the profile data or use
* directly in memory.
*/
int cham_t_initialize(
cham_t_function_lookup_t lookup,
cham_t_data_t *tool_data)
{
printf("Calling register_callback...\n");
cham_t_set_callback = (cham_t_set_callback_t) lookup("cham_t_set_callback");
cham_t_get_rank_data = (cham_t_get_rank_data_t) lookup("cham_t_get_rank_data");
cham_t_get_thread_data = (cham_t_get_thread_data_t) lookup("cham_t_get_thread_data");
cham_t_get_rank_info = (cham_t_get_rank_info_t) lookup("cham_t_get_rank_info");
register_callback(cham_t_callback_task_create);
register_callback(cham_t_callback_get_load_stats_per_taskwait);
register_callback(cham_t_callback_get_task_wallclock_time);
register_callback(cham_t_callback_train_prediction_model);
register_callback(cham_t_callback_load_prediction_model);
// get info about the number of iterations
int max_num_iters = DEFAULT_NUM_ITERS;
int max_num_tasks_per_rank = DEFAULT_NUM_TASKS_PER_RANK;
char *program_num_iters = std::getenv("EST_NUM_ITERS");
char *program_num_tasks = std::getenv("TASKS_PER_RANK");
// parse numtasks per rank
std::string str_numtasks(program_num_tasks);
std::list<std::string> split_numtasks = split(str_numtasks, ',');
std::list<std::string>::iterator it = split_numtasks.begin();
int rank = cham_t_get_rank_info()->comm_rank;
if (program_num_iters != NULL){
max_num_iters = atoi(program_num_iters);
}
if (program_num_tasks != NULL){
advance(it, rank);
max_num_tasks_per_rank = std::atoi((*it).c_str());
printf("[CHAMTOOL] check num_tasks per Rank %d: %d\n", rank, max_num_tasks_per_rank);
}
// resize vectors inside profiled_task_list
profiled_task_list.ntasks_per_rank = max_num_tasks_per_rank;
profiled_task_list.avg_load_list.resize(max_num_iters, 0.0);
profiled_task_list.task_list.resize(max_num_iters * max_num_tasks_per_rank);
// resize the arma::vectors
tool_tasks_count = 0;
avg_load_per_iter_list.resize(max_num_iters);
pre_load_per_iter_list.resize(max_num_iters);
return 1;
}
/**
* Finalizing the cham-tool.
*
* This callback is to finalize the whole callback tool, after the
* chameleon finished. This is called from chameleon-lib side.
* @param tool_data
*/
void cham_t_finalize(cham_t_data_t *tool_data)
{
// writing per rank
int rank = cham_t_get_rank_info()->comm_rank;
// write tool-logs
chameleon_t_write_logs(profiled_task_list, rank);
// clear profiled-data task list
clear_prof_tasklist();
}
/**
* Starting the cham-tool.
*
* This is to start the chameleon tool, then the functions, i.e.,
* cham_t_initialize() and cham_t_finalize() would be pointed to call.
* @param cham_version.
* @return as a main function of the callback took, would init
* cham_t_initialize and cham_t_finalize.
*/
#ifdef __cplusplus
extern "C" {
#endif
cham_t_start_tool_result_t* cham_t_start_tool(unsigned int cham_version)
{
printf("Starting tool with Chameleon Version: %d\n", cham_version);
static cham_t_start_tool_result_t cham_t_start_tool_result = {&cham_t_initialize, &cham_t_finalize, 0};
return &cham_t_start_tool_result;
}
#ifdef __cplusplus
}
#endif | 38.169872 | 121 | 0.653287 | jusch196 |
e24d1e8b8a9be0041d7790e11dbee71d320af3e1 | 1,438 | cpp | C++ | src/start.cpp | eostitan/eosio-wps | 02be171c267b35e9be3ef250da706e2e6c972752 | [
"MIT"
] | null | null | null | src/start.cpp | eostitan/eosio-wps | 02be171c267b35e9be3ef250da706e2e6c972752 | [
"MIT"
] | null | null | null | src/start.cpp | eostitan/eosio-wps | 02be171c267b35e9be3ef250da706e2e6c972752 | [
"MIT"
] | null | null | null | [[eosio::action]]
void wps::init()
{
require_auth( get_self() );
const name ram_payer = get_self();
check( !_state.exists(), "already initialized" );
auto state = _state.get_or_default();
auto settings = _settings.get_or_default();
_state.set( state, ram_payer );
_settings.set( settings, ram_payer );
// must manually execute the `start` action to begin voting period
}
[[eosio::action]]
void wps::start()
{
require_auth( get_self() );
const name ram_payer = get_self();
check( _state.exists(), "contract not yet initialized" );
check( _settings.exists(), "settings are missing" );
// TO-DO add checks
auto state = _state.get();
auto settings = _settings.get();
// start of voting period will start at the nearest 00:00UTC
const uint64_t now = current_time_point().sec_since_epoch();
const time_point_sec current_voting_period = time_point_sec(now - now % DAY);
// validation
check( state.next_voting_period <= current_time_point(), "[next_voting_period] must be in the past");
check( state.current_voting_period != current_voting_period, "[current_voting_period] was not modified");
state.current_voting_period = current_voting_period;
state.next_voting_period = state.current_voting_period + settings.voting_interval;
_state.set( state, ram_payer );
// must manually execute the `complete` action to finish voting period
} | 31.26087 | 109 | 0.700974 | eostitan |
e24f9319dc8e4e15a01678d1bc16795557e21cec | 4,057 | hpp | C++ | iRODS/lib/api/include/procStat.hpp | PlantandFoodResearch/irods | 9dfe7ffe5aa0760b7493bd9392ea1270df9335d4 | [
"BSD-3-Clause"
] | null | null | null | iRODS/lib/api/include/procStat.hpp | PlantandFoodResearch/irods | 9dfe7ffe5aa0760b7493bd9392ea1270df9335d4 | [
"BSD-3-Clause"
] | null | null | null | iRODS/lib/api/include/procStat.hpp | PlantandFoodResearch/irods | 9dfe7ffe5aa0760b7493bd9392ea1270df9335d4 | [
"BSD-3-Clause"
] | null | null | null | /*** Copyright (c), The Regents of the University of California ***
*** For more information please refer to files in the COPYRIGHT directory ***/
/* procStat.h - This dataObj may be generated by a program or script
*/
#ifndef PROC_STAT_HPP
#define PROC_STAT_HPP
/* This is a Object File I/O API call */
#include "rods.hpp"
#include "procApiRequest.hpp"
#include "apiNumber.hpp"
#include "initServer.hpp"
/* fake attri index for procStatOut */
#define PID_INX 1000001
#define STARTTIME_INX 1000002
#define CLIENT_NAME_INX 1000003
#define CLIENT_ZONE_INX 1000004
#define PROXY_NAME_INX 1000005
#define PROXY_ZONE_INX 1000006
#define REMOTE_ADDR_INX 1000007
#define PROG_NAME_INX 1000008
#define SERVER_ADDR_INX 1000009
typedef struct {
char addr[LONG_NAME_LEN]; /* if non empty, stat at this addr */
char rodsZone[NAME_LEN]; /* the zone */
keyValPair_t condInput;
} procStatInp_t;
#define ProcStatInp_PI "str addr[LONG_NAME_LEN];str rodsZone[NAME_LEN];struct KeyValPair_PI;"
#define MAX_PROC_STAT_CNT 2000
#if defined(RODS_SERVER)
#define RS_PROC_STAT rsProcStat
/* prototype for the server handler */
int
rsProcStat( rsComm_t *rsComm, procStatInp_t *procStatInp,
genQueryOut_t **procStatOut );
int
_rsProcStat( rsComm_t *rsComm, procStatInp_t *procStatInp,
genQueryOut_t **procStatOut );
int
_rsProcStatAll( rsComm_t *rsComm, procStatInp_t *procStatInp,
genQueryOut_t **procStatOut );
int
localProcStat( rsComm_t *rsComm, procStatInp_t *procStatInp,
genQueryOut_t **procStatOut );
int
remoteProcStat( rsComm_t *rsComm, procStatInp_t *procStatInp,
genQueryOut_t **procStatOut, rodsServerHost_t *rodsServerHost );
int
initProcStatOut( genQueryOut_t **procStatOut, int numProc );
int
addProcToProcStatOut( procLog_t *procLog, genQueryOut_t *procStatOut );
#else
#define RS_PROC_STAT NULL
#endif
extern "C" {
/* prototype for the client call */
/* rcProcStat - Get the connection stat of irods agents running in the
* iRods federation. By default, the stat of the irods agents on the icat
* enabled server (IES) is listed. Other servers can be specified using
* the "addr" field of procStatInp or using the RESC_NAME_KW keyword.
*
* Input -
* rcComm_t *conn - The client connection handle.
* procStatInp_t *procStatInp :
* addr - the IP address of the server where the stat should be done.
* A zero len addr means no input.
* rodsZone - the zone name for this stat. A zero len rodsZone means
* the stat is to be done in the local zone.
* condInput - conditional Input
* RESC_NAME_KW - "value" - do the stat on the server where the
* Resource is located.
* ALL_KW (and zero len value) - stat for all servers in the
* fedration.
* Output -
* genQueryOut_t **procStatOut
* The procStatOut contains 9 attributes and value arrays with the
* attriInx defined above. i.e.:
* PID_INX - pid of the agent process
* STARTTIME_INX - The connection start time in secs since Epoch.
* CLIENT_NAME_INX - client user name
* CLIENT_ZONE_INX - client user zone
* PROXY_NAME_INX - proxy user name
* PROXY_ZONE_INX - proxy user zone
* REMOTE_ADDR_INX - the from address of the connection
* SERVER_ADDR_INX - the server address of the connection
* PROG_NAME_INX - the client program name
*
* A row will be given for each running irods agent. If a server is
* completely idle, one row will still be given with all the attribute
* vaules empty (zero length string) except for the value associated
* with the SERVER_ADDR_INX.
* return value - The status of the operation.
*/
int
rcProcStat( rcComm_t *conn, procStatInp_t *procStatInp,
genQueryOut_t **procStatOut );
}
#endif /* PROC_STAT_H */
| 36.881818 | 93 | 0.681538 | PlantandFoodResearch |
e250f6db4f581914b7d9947082dd2dfd43c27541 | 2,116 | cpp | C++ | Leetcode/res/Remove Invalid Parentheses/1.cpp | AllanNozomu/CompetitiveProgramming | ac560ab5784d2e2861016434a97e6dcc44e26dc8 | [
"MIT"
] | 1 | 2022-03-04T16:06:41.000Z | 2022-03-04T16:06:41.000Z | Leetcode/res/Remove Invalid Parentheses/1.cpp | AllanNozomu/CompetitiveProgramming | ac560ab5784d2e2861016434a97e6dcc44e26dc8 | [
"MIT"
] | null | null | null | Leetcode/res/Remove Invalid Parentheses/1.cpp | AllanNozomu/CompetitiveProgramming | ac560ab5784d2e2861016434a97e6dcc44e26dc8 | [
"MIT"
] | null | null | null | \*
Author: allannozomu
Runtime: 24 ms
Memory: 11.5 MB*\
class Solution {
private:
int minimun_removed;
public:
string buildFromMask(string& s, vector<int>& mask){
string res = "";
for (int i = 0 ; i < mask.size(); ++i){
if (mask[i]){
res += s[i];
}
}
return res;
}
void removeInvalidParenthesesAux(string& s, int level, vector<int>& mask, int open_count, int removed_count, set<string>& substrings){
if (open_count < 0 || removed_count > minimun_removed) return;
if (level >= s.size()){
if (open_count == 0){
if (removed_count == minimun_removed){
substrings.insert(buildFromMask(s, mask));
} else if (removed_count < minimun_removed){
minimun_removed = removed_count;
substrings = {buildFromMask(s, mask)};
}
}
return;
}
char curr_c = s[level];
if (curr_c == '('){
mask[level] = 1;
removeInvalidParenthesesAux(s, level + 1, mask, open_count + 1, removed_count, substrings);
mask[level] = 0;
removeInvalidParenthesesAux(s, level + 1, mask, open_count, removed_count + 1, substrings);
}else if (curr_c == ')'){
mask[level] = 1;
removeInvalidParenthesesAux(s, level + 1, mask, open_count - 1, removed_count, substrings);
mask[level] = 0;
removeInvalidParenthesesAux(s, level + 1, mask, open_count, removed_count + 1, substrings);
}else{
mask[level] = 1;
removeInvalidParenthesesAux(s, level + 1, mask, open_count, removed_count, substrings);
}
}
vector<string> removeInvalidParentheses(string s) {
minimun_removed = s.size();
set<string> substrings;
vector<int> mask = vector<int>(s.size());
removeInvalidParenthesesAux(s, 0, mask, 0, 0, substrings);
return vector<string>(substrings.begin(), substrings.end());
}
}; | 35.266667 | 138 | 0.547259 | AllanNozomu |
e25489f1fbef7a0c2bb34822f8e953e95351f9e6 | 2,110 | cpp | C++ | samples/Hello/third-party/fuzzylite/examples/takagi-sugeno/matlab/sltbu_fl.cpp | okocsis/ios-cmake | ca61d83725bc5b1a755928f4592badbd9a8b37f4 | [
"BSD-3-Clause"
] | null | null | null | samples/Hello/third-party/fuzzylite/examples/takagi-sugeno/matlab/sltbu_fl.cpp | okocsis/ios-cmake | ca61d83725bc5b1a755928f4592badbd9a8b37f4 | [
"BSD-3-Clause"
] | null | null | null | samples/Hello/third-party/fuzzylite/examples/takagi-sugeno/matlab/sltbu_fl.cpp | okocsis/ios-cmake | ca61d83725bc5b1a755928f4592badbd9a8b37f4 | [
"BSD-3-Clause"
] | null | null | null | #include <fl/Headers.h>
int main(int argc, char** argv){
//Code automatically generated with fuzzylite 6.0.
using namespace fl;
Engine* engine = new Engine;
engine->setName("sltbu_fl");
engine->setDescription("");
InputVariable* distance = new InputVariable;
distance->setName("distance");
distance->setDescription("");
distance->setEnabled(true);
distance->setRange(0.000, 25.000);
distance->setLockValueInRange(false);
distance->addTerm(new ZShape("near", 1.000, 2.000));
distance->addTerm(new SShape("far", 1.000, 2.000));
engine->addInputVariable(distance);
InputVariable* control1 = new InputVariable;
control1->setName("control1");
control1->setDescription("");
control1->setEnabled(true);
control1->setRange(-0.785, 0.785);
control1->setLockValueInRange(false);
engine->addInputVariable(control1);
InputVariable* control2 = new InputVariable;
control2->setName("control2");
control2->setDescription("");
control2->setEnabled(true);
control2->setRange(-0.785, 0.785);
control2->setLockValueInRange(false);
engine->addInputVariable(control2);
OutputVariable* control = new OutputVariable;
control->setName("control");
control->setDescription("");
control->setEnabled(true);
control->setRange(-0.785, 0.785);
control->setLockValueInRange(false);
control->setAggregation(fl::null);
control->setDefuzzifier(new WeightedAverage("TakagiSugeno"));
control->setDefaultValue(fl::nan);
control->setLockPreviousValue(false);
control->addTerm(Linear::create("out1mf1", engine, 0.000, 0.000, 1.000, 0.000));
control->addTerm(Linear::create("out1mf2", engine, 0.000, 1.000, 0.000, 0.000));
engine->addOutputVariable(control);
RuleBlock* ruleBlock = new RuleBlock;
ruleBlock->setName("");
ruleBlock->setDescription("");
ruleBlock->setEnabled(true);
ruleBlock->setConjunction(fl::null);
ruleBlock->setDisjunction(fl::null);
ruleBlock->setImplication(fl::null);
ruleBlock->setActivation(new General);
ruleBlock->addRule(Rule::parse("if distance is near then control is out1mf1", engine));
ruleBlock->addRule(Rule::parse("if distance is far then control is out1mf2", engine));
engine->addRuleBlock(ruleBlock);
}
| 31.969697 | 87 | 0.759716 | okocsis |
e256b0f147945b96164c23b7a8e0484d18ca5441 | 603 | cpp | C++ | src/TextsHelper.cpp | TB989/Game | 9cf6e1267f1bc08b2e7f5f9a8278914f930c7c51 | [
"MIT"
] | null | null | null | src/TextsHelper.cpp | TB989/Game | 9cf6e1267f1bc08b2e7f5f9a8278914f930c7c51 | [
"MIT"
] | null | null | null | src/TextsHelper.cpp | TB989/Game | 9cf6e1267f1bc08b2e7f5f9a8278914f930c7c51 | [
"MIT"
] | null | null | null | #include <iostream>
#include <fstream>
#include <string>
#include "TextsHelper.h"
std::string getNextToken(std::ifstream &file,char delim){
std::string token;
while(true){
char ch;
file.get(ch);
if(ch==delim){
break;
}
else{
token+=ch;
}
}
return token;
}
void readTexts(){
std::ifstream texts;
texts.open("Texts.txt",std::ios::in);
Text text;
std::string temp;
temp=getNextToken(texts,'#');
std::cout << temp << "\n";
temp=getNextToken(texts,'#');
std::cout << temp << "\n";
}
| 17.735294 | 57 | 0.532338 | TB989 |
e25d6b3ec6918c719b9450c0d4cb211513cf0d56 | 8,221 | cpp | C++ | test/TestUnicode.cpp | m5knt/Pits | 7f7f9ab3013f446ffc8faee3b832a7b8043d4bed | [
"MIT"
] | null | null | null | test/TestUnicode.cpp | m5knt/Pits | 7f7f9ab3013f446ffc8faee3b832a7b8043d4bed | [
"MIT"
] | null | null | null | test/TestUnicode.cpp | m5knt/Pits | 7f7f9ab3013f446ffc8faee3b832a7b8043d4bed | [
"MIT"
] | null | null | null | #include "Pits/Unicode.hpp"
#include "Pits/Timer.hpp"
#include <uchar.h>
#include <cassert>
#include <string_view>
#include <iostream>
#include <codecvt>
#include <vector>
using namespace std::literals;
#if __cplusplus <= 201703L
namespace std {
using u8string = basic_string<char>;
}
#endif
template <class Job>
void Bench(Job job) {
Pits::Timer begin;
job();
std::cout << begin.GetElapsed() <<std::endl;
}
constexpr auto DefinedNDEBUG =
#ifdef NDEBUG
true;
#else
false;
#endif
constexpr auto BenchTimes = (DefinedNDEBUG ? 1000 : 1);
int main() {
#if defined(__STDC_UTF_16__) && defined(__STDC_UTF_32__)
static_assert(Pits::Unicode::IsSurrogate(u"𐐷"[0]));
static_assert(Pits::Unicode::IsSurrogate(u"𐐷"[1]));
static_assert(Pits::Unicode::IsHighSurrogate(u"𐐷"[0]));
static_assert(Pits::Unicode::IsLowSurrogate(u"𐐷"[1]));
static_assert(Pits::Unicode::IsNotCharacter(U'\U0000fffe'));
static_assert(Pits::Unicode::IsNotCharacter(U'\U0000ffff'));
static_assert(Pits::Unicode::IsNotCharacter(U'\U0001ffff'));
static_assert(Pits::Unicode::IsUnsafeCharacter(char32_t(0x0000d800)));
static_assert(Pits::Unicode::IsUnsafeCharacter(char32_t(0x0000ffff)));
static_assert(Pits::Unicode::IsUnsafeCharacter(char32_t(0x00110000)));
static_assert(Pits::Unicode::IsLeadUnit(char8_t(0x00)));
static_assert(Pits::Unicode::IsLeadUnit(char8_t(0xc0)));
static_assert(Pits::Unicode::IsLeadUnit(char8_t(0xe0)));
static_assert(Pits::Unicode::IsLeadUnit(char8_t(0xf0)));
static_assert(Pits::Unicode::IsLeadUnit(char16_t(0xd800)));
static_assert(Pits::Unicode::IsLeadUnit(char32_t(0x0000)));
static_assert(Pits::Unicode::LeadToUnits(char8_t(0x00)) == 1);
static_assert(Pits::Unicode::LeadToUnits(char8_t(0xc0)) == 2);
static_assert(Pits::Unicode::LeadToUnits(char8_t(0xe0)) == 3);
static_assert(Pits::Unicode::LeadToUnits(char8_t(0xf0)) == 4);
static_assert(Pits::Unicode::LeadToUnits(char16_t(0x0000)) == 1);
static_assert(Pits::Unicode::LeadToUnits(char16_t(0xd800)) == 2);
static_assert(Pits::Unicode::LeadToUnits(char32_t(0x0000)) == 1);
std::cout << "Bench Unicode Convert (0 ～ 10ffff) x " << BenchTimes << std::endl;
{
#if 0
auto from = U"𐐷漢字😀";
char8_t to[100] = {};
auto f = from;
auto t = to;
std::tie(f, t) = Pits::Unicode::ConvertUTF32ToUTF8(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF32ToUTF8(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF32ToUTF8(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF32ToUTF8(f, t);
assert(to == u8"𐐷漢字😀"sv);
#endif
std::vector<char8_t[Pits::Unicode::UTF32UnitsToUTF8Units()]> utf8(Pits::Unicode::CharacterMax + 1);
std::vector<char32_t[Pits::Unicode::UTF8UnitsToUTF32Units()]> utf32(Pits::Unicode::CharacterMax + 1);
std::cout << "ConvertUTF32ToUTF8: ";
Bench([&] {
for (int j = 0; j < BenchTimes; ++j) {
for (char32_t c = 0; c < Pits::Unicode::CharacterMax; ++c) {
if (Pits::Unicode::IsSurrogate(c)) continue;
Pits::Unicode::ConvertUTF32ToUTF8(&c, &utf8[c][0]);
}
}
});
std::cout << "ConvertUTF8ToUTF32: ";
Bench([&] {
for (int j = 0; j < BenchTimes; ++j) {
for (char32_t c = 0; c < Pits::Unicode::CharacterMax; ++c) {
if (Pits::Unicode::IsSurrogate(c)) continue;
Pits::Unicode::ConvertUTF8ToUTF32(&utf8[c][0], &utf32[c][0]);
}
}
});
for (char32_t c = 0; c < Pits::Unicode::CharacterMax; ++c) {
if (Pits::Unicode::IsSurrogate(c)) continue;
assert(utf32[c][0] == c);
}
}
{
auto from = U"𐐷漢字😀";
char16_t to[100] = {};
auto f = from;
auto t = to;
std::tie(f, t) = Pits::Unicode::ConvertUTF32ToUTF16(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF32ToUTF16(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF32ToUTF16(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF32ToUTF16(f, t);
assert(to == u"𐐷漢字😀"sv);
std::vector<char16_t[Pits::Unicode::UTF32UnitsToUTF16Units()]> utf16(Pits::Unicode::CharacterMax + 1);
std::vector<char8_t[Pits::Unicode::UTF16UnitsToUTF8Units()]> utf8(Pits::Unicode::CharacterMax + 1);
std::vector<char32_t[Pits::Unicode::UTF16UnitsToUTF32Units()]> utf32(Pits::Unicode::CharacterMax + 1);
std::cout << "ConvertUTF32ToUTF16: ";
Bench([&] {
for (int j = 0; j < BenchTimes; ++j) {
for (char32_t c = 0; c < Pits::Unicode::CharacterMax; ++c) {
if (Pits::Unicode::IsSurrogate(c)) continue;
Pits::Unicode::ConvertUTF32ToUTF16(&c, &utf16[c][0]);
}
}
});
std::cout << "ConvertUTF16ToUTF32: ";
Bench([&] {
for (int j = 0; j < BenchTimes; ++j) {
for (char32_t c = 0; c < Pits::Unicode::CharacterMax; ++c) {
if (Pits::Unicode::IsSurrogate(c)) continue;
Pits::Unicode::ConvertUTF16ToUTF32(&utf16[c][0], &utf32[c][0]);
}
}
});
for (char32_t c = 0; c < Pits::Unicode::CharacterMax; ++c) {
if (Pits::Unicode::IsSurrogate(c)) continue;
assert(utf32[c][0] == c);
}
std::cout << "ConvertUTF16ToUTF8: ";
Bench([&] {
for (int j = 0; j < BenchTimes; ++j) {
for (char32_t c = 0; c < Pits::Unicode::CharacterMax; ++c) {
if (Pits::Unicode::IsSurrogate(c)) continue;
Pits::Unicode::ConvertUTF16ToUTF8(&utf16[c][0], &utf8[c][0]);
}
}
});
std::cout << "ConvertUTF8ToUTF16: ";
Bench([&] {
for (int j = 0; j < BenchTimes; ++j) {
for (char32_t c = 0; c < Pits::Unicode::CharacterMax; ++c) {
if (Pits::Unicode::IsSurrogate(c)) continue;
Pits::Unicode::ConvertUTF8ToUTF16(&utf8[c][0], &utf16[c][0]);
}
}
});
for (char32_t c = 0; c < Pits::Unicode::CharacterMax; ++c) {
if (Pits::Unicode::IsSurrogate(c)) continue;
auto cc = char32_t{};
Pits::Unicode::ConvertUTF16ToUTF32(&utf16[c][0], &cc);
assert(cc == c);
}
}
#if 0
{
auto from = u8"𐐷漢字😀";
char32_t to[100] = {};
auto f = from;
auto t = to;
std::tie(f, t) = Pits::Unicode::ConvertUTF8ToUTF32(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF8ToUTF32(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF8ToUTF32(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF8ToUTF32(f, t);
assert(to == U"𐐷漢字😀"sv);
}
{
auto from = u"𐐷漢字😀";
char32_t to[13] = {};
auto f = from;
auto t = to;
std::tie(f, t) = Pits::Unicode::ConvertUTF16ToUTF32(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF16ToUTF32(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF16ToUTF32(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF16ToUTF32(f, t);
assert(to == U"𐐷漢字😀"sv);
}
{
auto from = u8"𐐷漢字😀";
char16_t to[100] = {};
auto f = from;
auto t = to;
std::tie(f, t) = Pits::Unicode::ConvertUTF8ToUTF16(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF8ToUTF16(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF8ToUTF16(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF8ToUTF16(f, t);
assert(to == u"𐐷漢字😀"sv);
}
{
auto from = u"𐐷漢字😀";
char8_t to[100] = {};
auto f = from;
auto t = to;
std::tie(f, t) = Pits::Unicode::ConvertUTF16ToUTF8(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF16ToUTF8(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF16ToUTF8(f, t);
std::tie(f, t) = Pits::Unicode::ConvertUTF16ToUTF8(f, t);
assert(to == u8"𐐷漢字😀"sv);
}
#endif
#endif
return 0;
}
| 36.537778 | 110 | 0.554069 | m5knt |
e25fb5a1c1f4767600c624b4ed6b0508e58b11f3 | 187 | hh | C++ | macos/cc/WindowDelegate.hh | rgkirch/JWM | 390fc92398758171e402529f8a6da4cce2a3efc6 | [
"Apache-2.0"
] | 177 | 2021-05-13T01:03:45.000Z | 2021-08-30T18:45:58.000Z | macos/cc/WindowDelegate.hh | rgkirch/JWM | 390fc92398758171e402529f8a6da4cce2a3efc6 | [
"Apache-2.0"
] | 130 | 2021-05-18T13:43:08.000Z | 2021-08-30T18:16:01.000Z | macos/cc/WindowDelegate.hh | rgkirch/JWM | 390fc92398758171e402529f8a6da4cce2a3efc6 | [
"Apache-2.0"
] | 13 | 2021-09-16T14:12:08.000Z | 2022-03-21T00:58:01.000Z | #pragma once
#import <Cocoa/Cocoa.h>
#include "WindowMac.hh"
@interface WindowDelegate : NSObject<NSWindowDelegate>
- (WindowDelegate*)initWithWindow:(jwm::WindowMac*)initWindow;
@end
| 18.7 | 62 | 0.775401 | rgkirch |
e26277d11b08f7820dc2270d8b1ab03dc700694a | 5,138 | cpp | C++ | Code/CmLib/Segmentation/PlanarCut/code/CutGrid.cpp | JessicaGiven/SalBenchmark_Analysis_Given | 0b0d8c3373be9105e9e94bc20b0eeb0bd7c06198 | [
"MIT"
] | 1 | 2018-10-07T00:56:57.000Z | 2018-10-07T00:56:57.000Z | Code/CmLib/Segmentation/PlanarCut/code/CutGrid.cpp | JessicaGiven/SalBenchmark_Analysis_Given | 0b0d8c3373be9105e9e94bc20b0eeb0bd7c06198 | [
"MIT"
] | null | null | null | Code/CmLib/Segmentation/PlanarCut/code/CutGrid.cpp | JessicaGiven/SalBenchmark_Analysis_Given | 0b0d8c3373be9105e9e94bc20b0eeb0bd7c06198 | [
"MIT"
] | null | null | null | /*****************************************************************************
* PlanarCut - software to compute MinCut / MaxFlow in a planar graph *
* Version 1.0.2 *
* *
* Copyright 2011 - 2013 Eno Töppe <toeppe@in.tum.de> *
* Frank R. Schmidt <info@frank-r-schmidt.de> *
******************************************************************************
If you use this software for research purposes, YOU MUST CITE the following
paper in any resulting publication:
[1] Efficient Planar Graph Cuts with Applications in Computer Vision.
F. R. Schmidt, E. Töppe, D. Cremers,
IEEE CVPR, Miami, Florida, June 2009
******************************************************************************
This software is released under the LGPL license. Details are explained
in the files 'COPYING' and 'COPYING.LESSER'.
*****************************************************************************/
#include "CutGrid.h"
CapType CutGrid::edgeCostNull(int row, int col, EDir dir) {
return 0.0;
}
CutGrid::CutGrid(int nRows, int nCols) : idxSource(0), idxSink(0) {
//set standard edge cost function so edgeCostFunc is always non-null
edgeCostFunc = &edgeCostNull;
if (nCols > 0 && nRows > 0) {
this->nCols = nCols;
this->nRows = nRows;
} else {
this->nCols = nCols = 5;
this->nRows = nRows = 5;
}
//compute metrics of the planar graph and reserve memory
nFacesPerRow = nCols - 1;
nFacesPerCol = nRows - 1;
nFaces = nFacesPerRow * nFacesPerCol + 1; //inner faces + one outside face
nHorzEdgesPerRow = nCols - 1;
nVertEdgesPerRow = nCols;
nHorzEdges = nHorzEdgesPerRow * nRows;
nVertEdges = nVertEdgesPerRow * (nRows-1);
nEdges = nHorzEdges + nVertEdges; //horizontal edges and vertical edges
nVerts = nCols * nRows;
verts = new PlanarVertex[nVerts];
edges = new PlanarEdge[nEdges];
faces = new PlanarFace[nFaces];
//determine embedding for vertices
PlanarEdge *edgesCCW[4];
int i, j; //column and row counter
int v, e; //vertex and edge counter
for (j=0, v=0; j<nRows; j++) {
for (i=0; i<nCols; i++, v++) {
e = 0;
if (i<nCols-1)
edgesCCW[e++] = &edges[j*nHorzEdgesPerRow + i];
if (j>0)
edgesCCW[e++] = &edges[nHorzEdges + (j-1)*nVertEdgesPerRow + i];
if (i>0)
edgesCCW[e++] = &edges[j*nHorzEdgesPerRow + i - 1];
if (j<nRows-1)
edgesCCW[e++] = &edges[nHorzEdges + j*nVertEdgesPerRow + i];
verts[v].setEdgesCCW(edgesCCW, e);
}
}
}
CutGrid::~CutGrid() {
if (verts)
delete [] verts;
if (edges)
delete [] edges;
if (faces)
delete [] faces;
}
void CutGrid::setSource(int row, int col) {
if (row >= 0 && row < nRows &&
col >= 0 && col < nCols)
idxSource = row * nCols + col;
}
void CutGrid::setSink(int row, int col) {
if (row >= 0 && row < nRows &&
col >= 0 && col < nCols)
idxSink = row * nCols + col;
}
void CutGrid::getSource(int &row, int &col) {
row = idxSource / nCols;
col = idxSource % nCols;
}
void CutGrid::getSink(int &row, int &col) {
row = idxSink / nCols;
col = idxSink % nCols;
}
void CutGrid::setEdgeCostFunction(EdgeCostFunc edgeCostFunc) {
if (edgeCostFunc)
this->edgeCostFunc = edgeCostFunc;
else
this->edgeCostFunc = edgeCostNull;
}
double CutGrid::edgeCost(int row, int col, EDir dir) {
//this call is safe, since we made sure that edgeCostFunc is always non-null
return edgeCostFunc(row, col, dir);
}
double CutGrid::getMaxFlow() {
int i, j; //column and row counter
int e; //vertex and edge counter
//add horizontal edges
for (j=0, e=0; j<nRows; j++)
for (i=0; i<nHorzEdgesPerRow; i++, e++)
edges[e].setEdge(&verts[j*nCols + i],
&verts[j*nCols + i + 1],
&faces[(e-nFacesPerRow<0) ? (nFaces-1) : e-nFacesPerRow],
&faces[(e>nFaces-1) ? (nFaces-1) : e],
edgeCost(j, i, DIR_EAST),
edgeCost(j, i+1, DIR_WEST)
);
//add vertical edges
for (j=0, e=nHorzEdges; j<nRows-1; j++)
for (i=0; i<nVertEdgesPerRow; i++, e++)
edges[e].setEdge(&verts[j*nCols + i],
&verts[(j+1)*nCols + i],
&faces[(i>=nFacesPerRow) ? (nFaces-1) : (j*nFacesPerRow + i)],
&faces[(i==0) ? (nFaces-1) : (j*nFacesPerRow + i-1)],
edgeCost(j, i, DIR_SOUTH),
edgeCost(j+1, i, DIR_NORTH)
);
pc.initialize(nVerts, verts, nEdges, edges, nFaces, faces,
idxSource, idxSink, CutPlanar::CHECK_NONE);
return pc.getMaxFlow();
}
CutPlanar::ELabel CutGrid::getLabel(int row, int col) {
if ((row >= 0) && (row < nRows) &&
(col >= 0) && (col < nCols))
return pc.getLabel(row*nCols + col);
throw ExceptionUnexpectedError();
}
void CutGrid::getLabels(CutPlanar::ELabel *lmask) {
for (int row=0; row<nRows; row++) {
for (int col=0; col<nCols; col++) {
lmask[row*nCols + col] = pc.getLabel(row*nCols + col);
}
}
}
| 24.122066 | 78 | 0.550603 | JessicaGiven |
e267a48b8e237d9e45bb5b4214c264315dabdd82 | 1,771 | hpp | C++ | src/projects/error_correction/edit_distance.hpp | AntonBankevich/LJA | 979d7929bf0b39fd142ec6465dc0c17814465ef9 | [
"BSD-3-Clause"
] | 53 | 2021-10-10T22:16:27.000Z | 2022-03-23T06:21:06.000Z | src/projects/error_correction/edit_distance.hpp | AntonBankevich/LJA | 979d7929bf0b39fd142ec6465dc0c17814465ef9 | [
"BSD-3-Clause"
] | 20 | 2021-05-10T07:44:24.000Z | 2022-03-24T13:23:58.000Z | src/projects/error_correction/edit_distance.hpp | AntonBankevich/DR | 73450ad3b25f90a3c7747aaf17fe60d13d9692d3 | [
"BSD-3-Clause"
] | 6 | 2022-01-27T01:45:56.000Z | 2022-03-18T04:23:33.000Z | #pragma once
#include "sequences/sequence.hpp"
inline size_t edit_distance(Sequence s1, Sequence s2) {
size_t left_skip = 0;
while(left_skip < s1.size() && left_skip < s2.size() && s1[left_skip] == s2[left_skip]) {
left_skip++;
}
s1 = s1.Subseq(left_skip, s1.size());
s2 = s2.Subseq(left_skip, s2.size());
size_t right_skip = 0;
while(right_skip < s1.size() && right_skip < s2.size() && s1[s1.size() - 1 - right_skip] == s2[s2.size() - 1 - right_skip]) {
right_skip++;
}
s1 = s1.Subseq(0, s1.size() - right_skip);
s2 = s2.Subseq(0, s2.size() - right_skip);
std::vector<std::vector<size_t>> d(s1.size() + 1, std::vector<size_t>(s2.size() + 1));
d[0][0] = 0;
for(unsigned int i = 1; i <= s1.size(); ++i) d[i][0] = i;
for(unsigned int i = 1; i <= s2.size(); ++i) d[0][i] = i;
for(unsigned int i = 1; i <= s1.size(); ++i)
for(unsigned int j = 1; j <= s2.size(); ++j)
d[i][j] = std::min({ d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (s1[i - 1] == s2[j - 1] ? 0 : 1) });
return d[s1.size()][s2.size()];
}
inline std::pair<size_t, size_t> bestPrefix(const Sequence &s1, const Sequence &s2) {
std::vector<size_t> prev(s2.size() + 1);
std::vector<size_t> cur(s2.size() + 1);
for(unsigned int j = 0; j <= s2.size(); ++j) cur[j] = j;
for(unsigned int i = 1; i <= s1.size(); ++i) {
std::swap(prev, cur);
cur[0] = i;
for(unsigned int j = 1; j <= s2.size(); ++j)
cur[j] = std::min({ prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (s1[i - 1] == s2[j - 1] ? 0 : 1) });
}
size_t res = s2.size();
for(size_t j = 0; j <= s2.size(); j++)
if(cur[j] < cur[res])
res = j;
return {res, cur[res]};
}
| 39.355556 | 129 | 0.508187 | AntonBankevich |
e268f822976e0bb32f98f0c35cab8c0813aef33c | 1,629 | cpp | C++ | src/vpp/bufferOps.cpp | nyorain/vpp | ccffafa0b59baa633df779274d7743f169d61c06 | [
"BSL-1.0"
] | 308 | 2016-02-23T11:59:20.000Z | 2022-03-14T18:40:24.000Z | src/vpp/bufferOps.cpp | nyorain/vpp | ccffafa0b59baa633df779274d7743f169d61c06 | [
"BSL-1.0"
] | 11 | 2017-01-21T17:33:13.000Z | 2020-08-17T10:33:42.000Z | src/vpp/bufferOps.cpp | nyorain/vpp | ccffafa0b59baa633df779274d7743f169d61c06 | [
"BSL-1.0"
] | 11 | 2016-02-23T10:35:08.000Z | 2021-12-18T16:15:39.000Z | // Copyright (c) 2016-2020 Jan Kelling
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt
#include <vpp/bufferOps.hpp>
#include <vpp/queue.hpp>
#include <vpp/vk.hpp>
#include <dlg/dlg.hpp>
#include <cstring>
namespace vpp {
vpp::SubBuffer fillStaging(vk::CommandBuffer cb, const BufferSpan& span,
nytl::Span<const std::byte> data) {
dlg_assert(vk::DeviceSize(data.size()) <= span.size());
auto& dev = span.device();
vpp::SubBuffer stage = {dev.bufferAllocator(), vk::DeviceSize(data.size()),
vk::BufferUsageBits::transferSrc, dev.hostMemoryTypes()};
auto map = stage.memoryMap(0, data.size());
std::memcpy(map.ptr(), data.data(), data.size());
vk::BufferCopy copy;
copy.dstOffset = span.offset();
copy.srcOffset = stage.offset();
copy.size = data.size();
vk::cmdCopyBuffer(cb, stage.buffer(), span.buffer(), {{copy}});
return stage;
}
void fillDirect(vk::CommandBuffer cb, const BufferSpan& span,
nytl::Span<const std::byte> data) {
dlg_assert(vk::DeviceSize(data.size()) <= span.size());
vk::cmdUpdateBuffer(cb, span.buffer(), span.offset(), data.size(),
data.data());
}
vpp::SubBuffer readStaging(vk::CommandBuffer cb, const BufferSpan& src) {
auto& dev = src.device();
vpp::SubBuffer stage = {dev.bufferAllocator(), src.size(),
vk::BufferUsageBits::transferSrc, dev.hostMemoryTypes()};
vk::BufferCopy copy;
copy.dstOffset = stage.offset();
copy.srcOffset = src.offset();
copy.size = src.size();
vk::cmdCopyBuffer(cb, src.buffer(), stage.buffer(), {{copy}});
return stage;
}
} // namespace vpp
| 30.735849 | 80 | 0.698588 | nyorain |
e26c8c4ebcd6d2f696a66d9958ef8a978cbcaa48 | 2,142 | hh | C++ | src/HomologyInference/BlockedProperty.hh | jsb/HomologyInference | a8b6f9ecad375072bd45e96e08c906c8332c3e4f | [
"MIT"
] | 3 | 2021-12-08T06:53:40.000Z | 2022-03-23T09:41:01.000Z | src/HomologyInference/BlockedProperty.hh | jsb/HomologyInference | a8b6f9ecad375072bd45e96e08c906c8332c3e4f | [
"MIT"
] | null | null | null | src/HomologyInference/BlockedProperty.hh | jsb/HomologyInference | a8b6f9ecad375072bd45e96e08c906c8332c3e4f | [
"MIT"
] | null | null | null | /*
* Author: Janis Born
*/
#pragma once
#include <HomologyInference/Types.hh>
#include <HomologyInference/Utils/ExternalProperty.hh>
#include <set>
namespace HomologyInference
{
using BlockedEdgeProperty = ExternalProperty<EH, bool>;
using BlockedVertexProperty = ExternalProperty<VH, bool>;
template<typename Mesh>
bool is_blocked(
const Mesh& _mesh,
const BlockedEdgeProperty& _blocked_ehs,
const EH _eh);
template<typename Mesh>
bool is_blocked(
const Mesh& _mesh,
const BlockedEdgeProperty& _blocked_ehs,
const HEH _heh);
template<typename Mesh>
bool is_blocked(
const Mesh& _mesh,
const BlockedEdgeProperty& _blocked_ehs,
const VH _vh);
template<typename Mesh>
bool is_blocked(
const Mesh& _mesh,
const BlockedVertexProperty& _blocked_vhs,
const VH _vh);
template<typename Mesh>
bool is_blocked(
const Mesh& _mesh,
const BlockedEdgeProperty& _blocked_ehs,
const BlockedVertexProperty& _blocked_vhs,
const VH _vh);
template<typename Mesh>
HEH sector_start(
const Mesh& _mesh,
const BlockedEdgeProperty& _blocked_ehs,
const HEH _sector_heh);
template<typename Mesh>
HEH sector_start(
const Mesh& _mesh,
const BlockedEdgeProperty& _blocked_ehs,
const VH _vh,
const FH _sector_fh);
template<typename Mesh>
std::set<FH> faces_in_sector(
const Mesh& _mesh,
const BlockedEdgeProperty& _blocked_ehs,
const HEH _sector_heh);
/// Returns cw-most outgoing halfedge in each sector.
/// Returns any halfedge if there are no sectors.
template<typename Mesh>
std::vector<SHEH> sectors(
const Mesh& _mesh,
const BlockedEdgeProperty& _blocked_ehs,
const VH _vh);
/// Returns cw-most outgoing halfedge in each sector of from-vertex.
/// Returns any halfedge if there are no sectors.
/// Starts enumeration at the provided halfedge.
template<typename Mesh>
std::vector<SHEH> sectors_starting_at(
const Mesh& _mesh,
const BlockedEdgeProperty& _blocked_ehs,
const HEH _heh_start);
}
| 25.2 | 68 | 0.699813 | jsb |
e270f0db65b1608430b2b40a9805bc0d265eece6 | 328 | cpp | C++ | src/14000/14915.cpp14.cpp | upple/BOJ | e6dbf9fd17fa2b458c6a781d803123b14c18e6f1 | [
"MIT"
] | 8 | 2018-04-12T15:54:09.000Z | 2020-06-05T07:41:15.000Z | src/14000/14915.cpp14.cpp | upple/BOJ | e6dbf9fd17fa2b458c6a781d803123b14c18e6f1 | [
"MIT"
] | null | null | null | src/14000/14915.cpp14.cpp | upple/BOJ | e6dbf9fd17fa2b458c6a781d803123b14c18e6f1 | [
"MIT"
] | null | null | null | #include <iostream>
#include <string>
using namespace std;
char arr[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
int main()
{
int m, n;
string ans, a;
cin >> m >> n;
while (m)
{
a = ans;
ans = arr[m%n];
ans += a;
m /= n;
}
if (ans == "")
ans = "0";
cout << ans;
} | 14.26087 | 96 | 0.411585 | upple |
e272fe434103717fe92a4b9f83d0e9a1808a036c | 3,775 | hpp | C++ | Engine/Core/Headers/Molten/Renderer/Vulkan/Utility/VulkanPhysicalDevice.hpp | jimmiebergmann/CurseEngine | 74a0502e36327f893c8e4f3e7cbe5b9d38fbe194 | [
"MIT"
] | 2 | 2019-11-11T21:17:14.000Z | 2019-11-11T22:07:26.000Z | Engine/Core/Headers/Molten/Renderer/Vulkan/Utility/VulkanPhysicalDevice.hpp | jimmiebergmann/CurseEngine | 74a0502e36327f893c8e4f3e7cbe5b9d38fbe194 | [
"MIT"
] | null | null | null | Engine/Core/Headers/Molten/Renderer/Vulkan/Utility/VulkanPhysicalDevice.hpp | jimmiebergmann/CurseEngine | 74a0502e36327f893c8e4f3e7cbe5b9d38fbe194 | [
"MIT"
] | 1 | 2020-04-05T03:50:57.000Z | 2020-04-05T03:50:57.000Z | /*
* MIT License
*
* Copyright (c) 2021 Jimmie Bergmann
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files(the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions :
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#ifndef MOLTEN_CORE_RENDERER_VULKAN_UTILITY_VULKANPHYSICALDEVICE_HPP
#define MOLTEN_CORE_RENDERER_VULKAN_UTILITY_VULKANPHYSICALDEVICE_HPP
#if defined(MOLTEN_ENABLE_VULKAN)
#include "Molten/Renderer/Vulkan/Utility/VulkanResult.hpp"
#include "Molten/Renderer/Vulkan/Utility/VulkanPhysicalDeviceCapabilities.hpp"
#include "Molten/Renderer/Vulkan/Utility/VulkanDeviceQueues.hpp"
#include <vector>
#include <functional>
MOLTEN_UNSCOPED_ENUM_BEGIN
namespace Molten::Vulkan
{
class Instance;
class Surface;
/** Vulkan physical device.*/
class MOLTEN_API PhysicalDevice
{
public:
PhysicalDevice();
Result<> Create(
VkPhysicalDevice physicalDeviceHandle,
Surface& surface);
Result<> ReloadCapabilities();
bool IsCreated() const;
VkPhysicalDevice& GetHandle();
const VkPhysicalDevice& GetHandle() const;
PhysicalDeviceCapabilities& GetCapabilities();
const PhysicalDeviceCapabilities& GetCapabilities() const;
DeviceQueueIndices& GetDeviceQueueIndices();
const DeviceQueueIndices& GetDeviceQueueIndices() const;
Surface& GetSurface();
const Surface& GetSurface() const;
bool HasSurface() const;
private:
VkPhysicalDevice m_handle;
PhysicalDeviceCapabilities m_capabilities;
DeviceQueueIndices m_deviceQueueIndices;
Surface* m_surface;
};
using PhysicalDevices = std::vector<PhysicalDevice>;
/** Filter for fetching and creating physical devices. */
using PhysicalDeviceFilter = std::function<bool(const Vulkan::PhysicalDevice&)>;
using PhysicalDeviceFilters = std::vector<PhysicalDeviceFilter>;
/** Fetch and create physical devices from vulkan instance.
* Provide filters to ignore certain physical devices.
*/
MOLTEN_API Result<> FetchAndCreatePhysicalDevices(
PhysicalDevices& physicalDevices,
Instance& instance,
Surface& surface,
PhysicalDeviceFilters filters = {});
/** Filter for scoring physical devices. */
using ScoringCallback = std::function<int32_t(const PhysicalDevice&)>;
/** Score physical devices by iterating a list of physical devices and returns the device with highest score.
* Callback function should return a positive interger if the device is considered as suitable.
*
* @return true if any device with positive score is found, else false.
*/
MOLTEN_API bool ScorePhysicalDevices(
PhysicalDevice& winningPhysicalDevice,
const PhysicalDevices& physicalDevices,
const ScoringCallback& scoringCallback);
}
MOLTEN_UNSCOPED_ENUM_END
#endif
#endif | 31.458333 | 112 | 0.744901 | jimmiebergmann |
e275ff5046336033409b67fd70dbc06aea8ec7a1 | 822 | cpp | C++ | hwlib/demo/native/native-#0020-string/main.cpp | TheBlindMick/MPU6050 | 66880369fa7a73755846e60568137dfc07da1b5c | [
"BSL-1.0"
] | 46 | 2017-02-15T14:24:14.000Z | 2021-10-01T14:25:57.000Z | hwlib/demo/native/native-#0020-string/main.cpp | TheBlindMick/MPU6050 | 66880369fa7a73755846e60568137dfc07da1b5c | [
"BSL-1.0"
] | 27 | 2017-02-15T15:13:42.000Z | 2021-08-28T15:29:01.000Z | hwlib/demo/native/native-#0020-string/main.cpp | TheBlindMick/MPU6050 | 66880369fa7a73755846e60568137dfc07da1b5c | [
"BSL-1.0"
] | 39 | 2017-05-18T11:51:03.000Z | 2021-09-14T09:07:01.000Z | // ==========================================================================
//
// hwlib::string demo
//
// (c) Wouter van Ooijen (wouter@voti.nl) 2017
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// ==========================================================================
#include "hwlib.hpp"
#include <iostream>
int main( void ){
hwlib::string< 100 > t( "Hello brave new world!\n" );
t[ 3 ] = t[ 4 ];
std::cout << t;
constexpr auto x = hwlib::string<0>::range( "hello\n" );
std::cout << x;
//auto r = t.range_start_end( 2, 5 );
//hwlib::string< 100 > rr = r;
//std::cout << "[" << rr << "]\n";
//std::cout << "[" << t.range_start_length( 3, 9 ) << "]\n";
}
| 27.4 | 77 | 0.457421 | TheBlindMick |
e27a9e517fca9ca546376a68178b0fd26256f754 | 4,145 | cpp | C++ | lib/glimac/src/Controls.cpp | elisacia/World-Imaker | c168521c168336a4be7835a2adeee9cc7a672681 | [
"MIT"
] | null | null | null | lib/glimac/src/Controls.cpp | elisacia/World-Imaker | c168521c168336a4be7835a2adeee9cc7a672681 | [
"MIT"
] | null | null | null | lib/glimac/src/Controls.cpp | elisacia/World-Imaker | c168521c168336a4be7835a2adeee9cc7a672681 | [
"MIT"
] | null | null | null | #include <glimac/Controls.hpp>
namespace glimac {
const void moveCamera(const SDL_Event &e, FreeFlyCamera &camera)
{
switch(e.key.keysym.sym)
{
case SDLK_z:
camera.moveFront(1);
break;
case SDLK_s:
camera.moveFront(-1);
break;
case SDLK_q:
camera.moveLeft(1);
break;
case SDLK_d:
camera.moveLeft(-1);
break;
case SDLK_i:
camera.rotateUp(2);
break;
case SDLK_k:
camera.rotateUp(-2);
break;
case SDLK_j:
camera.rotateLeft(2);
break;
case SDLK_l:
camera.rotateLeft(-2);
break;
case SDLK_a:
camera.moveUp(1);
break;
case SDLK_e:
camera.moveUp(-1);
break;
}
}
const void moveCursor(const SDL_Event &e, Cursor &cursor)
{
if(e.type==SDL_KEYDOWN){
switch(e.key.keysym.scancode)
{
case SDL_SCANCODE_LEFT:
cursor.updatePosX(-1.0f);
break;
case SDL_SCANCODE_RIGHT:
cursor.updatePosX(1.0f);
break;
case SDL_SCANCODE_UP:
cursor.updatePosY(1.0f);
break;
case SDL_SCANCODE_DOWN:
cursor.updatePosY(-1.0f);
break;
}
switch(e.key.keysym.sym)
{
case SDLK_n:
cursor.updatePosZ(-1.0f);
break;
case SDLK_b:
cursor.updatePosZ(1.0f);
break;
}
}
}
void sculptCubes(SDL_Event &e, std::vector <Cube> &list_cubes, Cursor &cursor, glm::vec3 &cursorPos, const int volume, const int action, const float epsilon)
{
float index= cursorPos.z*volume+cursorPos.x+cursorPos.y*volume*volume;
float indexCol= cursorPos.z*volume+cursorPos.x;
//REMOVE
if ((e.type==SDL_KEYDOWN && e.key.keysym.sym==SDLK_w ) || action == 5){
list_cubes[index].removeCube();
}
if (action == 50){
float value;
for(Cube &c: list_cubes){
value = getRBF(FunctionType::Gaussian, c.getPosition(), cursorPos, epsilon);
if (value >= 0.5f ) c.removeCube();
}
}
//ADD
if ((e.type==SDL_KEYDOWN && e.key.keysym.sym==SDLK_x ) || action == 6){
list_cubes[index].addCube();
}
if (action == 60){
float value;
for(Cube &c: list_cubes){
value = getRBF(FunctionType::Gaussian, c.getPosition(), cursorPos, epsilon);
if (value >= 0.5f ) c.addCube();
}
}
//EXTRUDE
if ((e.type==SDL_KEYDOWN && e.key.keysym.sym==SDLK_c ) || action == 7){
while (list_cubes[indexCol].isVisible()==true){
indexCol = indexCol+(volume*volume);
}
list_cubes[indexCol].addCube();
}
//DIG
if ((e.type==SDL_KEYDOWN && e.key.keysym.sym==SDLK_v ) || action == 8){
while (list_cubes[indexCol+(volume*volume)].isVisible()==true){
indexCol = indexCol+(volume*volume);
}
list_cubes[indexCol].removeCube();
}
}
void paintCubes(std::vector <Cube> &list_cubes, Cursor &cursor, glm::vec3 &cursorPos, const int volume, const int action, const float epsilon)
{
float index= cursorPos.z*volume+cursorPos.x+cursorPos.y*volume*volume;
if (action%10 == 0){
// float epsilon=0.1f;
float value;
for(Cube &c: list_cubes){
value = getRBF(FunctionType::Gaussian, c.getPosition(), cursorPos, epsilon);
if (value >= 0.5f ) c.setType(action/10);
}
}
else list_cubes[index].setType(action);
}
void cleanScene(std::vector <Cube> &list_cubes, const int volume)
{
for(Cube &c: list_cubes){
c.removeCube();
c.setType(1);
}
}
void saveControl(const FilePath &applicationPath,std::string filename,std::vector <Cube> &list_cubes,const int action){
if(action== 12) saveFile(applicationPath,filename,list_cubes);
if(action== 13) loadFile(applicationPath,filename,list_cubes);
}
};
| 24.96988 | 157 | 0.55006 | elisacia |
e27b3021b3d243450a0c23ecbe6fd92f225f1569 | 14,240 | cpp | C++ | Atomic/AtMimeReadWrite.cpp | denisbider/Atomic | 8e8e979a6ef24d217a77f17fa81a4129f3506952 | [
"MIT"
] | 4 | 2019-11-10T21:56:40.000Z | 2021-12-11T20:10:55.000Z | Atomic/AtMimeReadWrite.cpp | denisbider/Atomic | 8e8e979a6ef24d217a77f17fa81a4129f3506952 | [
"MIT"
] | null | null | null | Atomic/AtMimeReadWrite.cpp | denisbider/Atomic | 8e8e979a6ef24d217a77f17fa81a4129f3506952 | [
"MIT"
] | 1 | 2019-11-11T08:38:59.000Z | 2019-11-11T08:38:59.000Z | #include "AtIncludes.h"
#include "AtMimeReadWrite.h"
#include "AtImfReadWrite.h"
#include "AtMimeGrammar.h"
#include "AtMimeQuotedPrintable.h"
namespace At
{
namespace Mime
{
// FieldWithParams
void FieldWithParams::ReadParam(ParseNode const& paramNode, PinStore& store)
{
// Name
ParseNode const& nameTextNode = paramNode.FirstChild().DeepFindRef(id_token_text);
Seq name = nameTextNode.SrcText();
Seq value;
// Value
ParseNode const* valueQsNode = paramNode.LastChild().DeepFind(Imf::id_quoted_string);
if (valueQsNode != nullptr)
value = Imf::ReadQuotedString(*valueQsNode, store);
else
{
ParseNode const& valueTextNode = paramNode.LastChild().DeepFindRef(id_token_text);
value = valueTextNode.SrcText();
}
m_params.Add(name, value);
}
void FieldWithParams::WriteParams(MsgWriter& writer) const
{
if (m_params.Any())
{
Seq name, value;
bool first { true };
for (NameValuePair const& pair : m_params)
{
if (first)
first = false;
else
{
writer.Add(name);
writer.Add("=");
Imf::WriteQuotedString(writer, value, "; ");
}
name = pair.m_name;
value = pair.m_value;
}
writer.Add(name);
writer.Add("=");
Imf::WriteQuotedString(writer, value);
}
}
// ContentType
void ContentType::Read(ParseNode const& fieldNode, PinStore& store)
{
for (ParseNode const& c : fieldNode)
{
if (c.IsType(id_ct_type) ||
c.IsType(id_ct_subtype))
{
ParseNode const& tokenTextNode = c.DeepFindRef(id_token_text);
if (c.IsType(id_ct_type))
m_type = tokenTextNode.SrcText();
else
m_subType = tokenTextNode.SrcText();
}
else if (c.IsType(id_parameter))
ReadParam(c, store);
}
}
void ContentType::Write(MsgWriter& writer) const
{
writer.Add("Content-Type: ");
WriteContent(writer);
writer.Add("\r\n");
}
void ContentType::WriteContent(MsgWriter& writer) const
{
{
MsgSectionScope section { writer };
writer.Add(m_type).Add("/").Add(m_subType);
if (m_params.Any())
writer.Add("; ");
}
WriteParams(writer);
}
bool ContentType::IsSafeAsUntrustedInlineContent(Seq content) const
{
// To determine if a type is likely safe, we follow the MIME Sniffing Standard as implemented by browsers:
// https://mimesniff.spec.whatwg.org/#no-sniff-flag
// May want to expand this with other content types besides images (e.g. audio, video) if it becomes necessary.
// At the time of this writing, audio/video seems unlikely (and poor form) to be embedded in email, where this is currently used.
if (EqualType("image"))
{
if (m_subType.EqualInsensitive("bmp" )) { return content.StartsWithExact("BM"); }
if (m_subType.EqualInsensitive("gif" )) { return content.StartsWithExact("GIF87a") || content.StartsWithExact("GIF89a"); }
if (m_subType.EqualInsensitive("webp" )) { return content.StripPrefixExact("RIFF") && content.n>=10 && content.DropBytes(4).StartsWithExact("WEBPVP"); }
if (m_subType.EqualInsensitive("png" )) { return content.StartsWithExact("PNG\r\n\x1A\n"); }
if (m_subType.EqualInsensitive("jpeg" )) { return content.StartsWithExact("\xFF\xD8\xFF"); }
}
return false;
}
// ContentEnc
void ContentEnc::Read(ParseNode const& fieldNode, PinStore&)
{
ParseNode const& tokenTextNode = fieldNode.FlatFindRef(id_token_text);
m_value = tokenTextNode.SrcText();
}
void ContentEnc::Write(MsgWriter& writer) const
{
writer.Add("Content-Transfer-Encoding: ").Add(m_value).Add("\r\n");
}
// ContentId
void ContentId::Read(ParseNode const& fieldNode, PinStore&)
{
// Obsolete syntax allows for quoted strings and CFWS within msg-id,
// but this is troublesome to remove in-depth, and the benefits are unconvincing.
m_id = fieldNode.FlatFindRef(Imf::id_msg_id).SrcText();
}
void ContentId::Write(MsgWriter& writer) const
{
writer.Add("Content-ID: ");
MsgSectionScope { writer };
writer.Add("<").Add(m_id).Add(">\r\n");
}
// ContentDesc
void ContentDesc::Read(ParseNode const& fieldNode, PinStore&)
{
ParseNode const& unstructuredNode = fieldNode.FlatFindRef(Imf::id_unstructured);
m_desc = unstructuredNode.SrcText();
}
void ContentDesc::Write(MsgWriter& writer) const
{
writer.Add("Content-Description: ");
Imf::WriteUnstructured(writer, m_desc);
writer.Add("\r\n");
}
// ContentDisp
void ContentDisp::Read(ParseNode const& fieldNode, PinStore& store)
{
for (ParseNode const& c : fieldNode)
{
if (c.IsType(id_disposition_type))
{
ParseNode const& tokenTextNode = c.DeepFindRef(id_token_text);
m_type = tokenTextNode.SrcText();
}
else if (c.IsType(id_parameter))
ReadParam(c, store);
}
}
void ContentDisp::Write(MsgWriter& writer) const
{
writer.Add("Content-Disposition: ");
WriteContent(writer);
writer.Add("\r\n");
}
void ContentDisp::WriteContent(MsgWriter& writer) const
{
{
MsgSectionScope section { writer };
writer.Add(m_type);
if (m_params.Any())
writer.Add("; ");
}
WriteParams(writer);
}
// ExtensionField
void ExtensionField::Read(ParseNode const& fieldNode, PinStore&)
{
EnsureThrow(fieldNode.FirstChild().IsType(id_extension_field_name));
m_name = fieldNode.FirstChild().SrcText();
ParseNode const* valueNode = fieldNode.FlatFind(Imf::id_unstructured);
if (!valueNode)
m_value = Seq();
else
m_value = valueNode->SrcText();
}
void ExtensionField::Write(MsgWriter& writer) const
{
writer.Add(m_name).Add(": ");
Imf::WriteUnstructured(writer, m_value);
writer.Add("\r\n");
}
// MimeVersion
void MimeVersion::Read(ParseNode const& fieldNode, PinStore&)
{
ParseNode const& majorNode = fieldNode.FlatFindRef(id_version_major);
m_major = majorNode.SrcText().ReadNrUInt16Dec();
ParseNode const& minorNode = fieldNode.FlatFindRef(id_version_minor);
m_minor = minorNode.SrcText().ReadNrUInt16Dec();
}
void MimeVersion::Write(MsgWriter& writer) const
{
AuxStr version { writer };
version.ReserveAtLeast(10);
version.UInt(m_major).Ch('.').UInt(m_minor).Add("\r\n");
writer.Add("MIME-Version: ").Add(version);
}
// PartReadErr
void PartReadErr::EncObj(Enc& enc) const
{
enc.Add("MIME part ");
bool first {};
for (sizet n : m_errPartPath)
{
if (first) first = false; else enc.Ch('.');
enc.UInt(n);
}
enc.Add(": ").Add(m_errDesc);
}
// PartReadCx
void PartReadCx::EncObj(Enc& enc) const
{
for (PartReadErr const& err : m_errs)
enc.Obj(err).Add("\r\n");
}
// Part
void Part::EncLoc(Enc& e, Slice<sizet> loc)
{
e.Ch('/');
if (loc.Any())
{
while (true)
{
e.UInt(loc.First());
loc.PopFirst();
if (!loc.Any()) break;
e.Ch('/');
}
}
}
bool Part::ReadLoc(Vec<sizet>& loc, Seq& reader)
{
if (!reader.StripPrefixExact("/"))
return false;
if (reader.n)
{
do
{
uint c = reader.FirstByte();
if (UINT_MAX == c) return false;
if (!Ascii::IsDecDigit(c)) return false;
uint64 n = reader.ReadNrUInt64Dec();
if (UINT64_MAX == n) return false;
if (SIZE_MAX < n) return false;
loc.Add((sizet) n);
}
while (reader.StripPrefixExact("/"));
}
return true;
}
Part const* Part::GetPartByLoc(Slice<sizet> loc) const
{
Part const* p = this;
while (loc.Any())
{
sizet i = loc.First();
if (p->m_parts.Len() <= i)
return nullptr;
p = &(p->m_parts[i]);
loc.PopFirst();
}
return p;
}
bool Part::TryReadMimeField(ParseNode const& fieldNode, PinStore& store)
{
if (fieldNode.IsType(id_content_type)) { m_contentType .ReInit().Read(fieldNode, store); return true; }
if (fieldNode.IsType(id_content_enc)) { m_contentEnc .ReInit().Read(fieldNode, store); return true; }
if (fieldNode.IsType(id_content_id)) { m_contentId .ReInit().Read(fieldNode, store); return true; }
if (fieldNode.IsType(id_content_desc)) { m_contentDesc .ReInit().Read(fieldNode, store); return true; }
if (fieldNode.IsType(id_content_disp)) { m_contentDisp .ReInit().Read(fieldNode, store); return true; }
if (fieldNode.IsType(id_mime_version)) { m_mimeVersion .ReInit().Read(fieldNode, store); return true; }
if (fieldNode.IsType(id_extension_field)) { m_extensionFields .Add().Read(fieldNode, store); return true; }
return false;
}
void Part::WriteMimeFields(MsgWriter& writer) const
{
if (IsMultipart()) // Implies m_contentType.Any()
{
Seq boundary { m_contentType->m_params.Get("boundary") };
if (!boundary.n)
{
// RFC 2045: "A good strategy is to choose a boundary that includes a character
// sequence such as "=_" which can never appear in a quoted-printable body"
m_boundaryStorage.ReserveExact(2 + Token::Len);
m_boundaryStorage.Set("=_");
Token::Generate(m_boundaryStorage);
m_contentType->m_params.Add("boundary", m_boundaryStorage);
}
}
if (m_mimeVersion.Any()) m_mimeVersion->Write(writer);
if (m_contentType.Any()) m_contentType->Write(writer);
if (m_contentEnc .Any()) m_contentEnc ->Write(writer);
if (m_contentId .Any()) m_contentId ->Write(writer);
if (m_contentDesc.Any()) m_contentDesc->Write(writer);
if (m_contentDisp.Any()) m_contentDisp->Write(writer);
for (ExtensionField const& xf : m_extensionFields)
xf.Write(writer);
}
void Part::ReadPartHeader(ParseNode const& partHeaderNode, PinStore& store)
{
for (ParseNode const& fieldNode : partHeaderNode)
TryReadMimeField(fieldNode, store);
}
bool Part::ReadMultipartBody(Seq& encoded, PinStore& store, PartReadCx& prcx)
{
ParseTree pt { encoded };
if (prcx.m_verboseParseErrs)
pt.RecordBestToStack();
if (!pt.Parse(Mime::C_multipart_body))
return prcx.AddParseErr(pt);
prcx.m_curPartPath.Add(0U);
OnExit popPartPath = [&prcx] { prcx.m_curPartPath.PopLast(); };
for (ParseNode const& c : pt.Root().FlatFindRef(Mime::id_multipart_body))
if (c.IsType(Mime::id_body_part))
{
++prcx.m_curPartPath.Last();
if (!AddChildPart().ReadPart(c, store, prcx))
if (prcx.m_stopOnNestedErr)
return false;
}
return true;
}
void Part::WriteMultipartBody(MsgWriter& writer, Seq boundary) const
{
EnsureThrow(m_parts.Any());
for (Part const& part : m_parts)
{
// Part boundary
{
MsgSectionScope section { writer };
writer.Add("--").Add(boundary).Add("\r\n");
}
part.WritePart(writer);
}
// End boundary
{
MsgSectionScope section { writer };
writer.Add("--").Add(boundary).Add("--\r\n");
}
}
bool Part::ReadPart(ParseNode const& partNode, PinStore& store, PartReadCx& prcx)
{
m_srcText = partNode.SrcText();
for (ParseNode const& c : partNode)
if (c.IsType(Mime::id_part_header))
ReadPartHeader(c, store);
else if (c.IsType(Mime::id_part_content))
m_contentEncoded = c.SrcText();
if (IsMultipart())
{
if (prcx.m_curPartPath.Len() >= prcx.m_decodeDepth)
return prcx.AddDecodeDepthErr();
if (!ReadMultipartBody(m_contentEncoded, store, prcx))
return false;
}
return true;
}
void Part::WritePart(MsgWriter& writer) const
{
WriteMimeFields(writer);
writer.Add("\r\n");
if (!IsMultipart())
writer.AddVerbatim(m_contentEncoded).AddVerbatim("\r\n");
else
{
// If not set previously by caller, boundary is set in WriteMimeFields()
Seq boundary { m_contentType->m_params.Get("boundary") };
EnsureThrow(boundary.n);
WriteMultipartBody(writer, boundary);
}
}
bool Part::DecodeContent(Seq& decoded, PinStore& store) const
{
// Parts of type "multipart" must use an identity encoding ("7bit", "8bit" or "binary")
EnsureThrow(!IsMultipart());
if (!m_contentEnc.Any())
{ decoded = m_contentEncoded; return true; }
Seq encType = m_contentEnc->m_value;
if (encType.EqualInsensitive("7bit") ||
encType.EqualInsensitive("8bit") ||
encType.EqualInsensitive("binary"))
{ decoded = m_contentEncoded; return true; }
if (encType.EqualInsensitive("quoted-printable")) { decoded = DecodeContent_QP (store); return true; }
if (encType.EqualInsensitive("base64")) { decoded = DecodeContent_Base64 (store); return true; }
return false;
}
Seq Part::DecodeContent_QP(PinStore& store) const
{
Seq reader = m_contentEncoded;
Enc& enc = store.GetEnc(QuotedPrintableDecode_MaxLen(reader.n));
return QuotedPrintableDecode(reader, enc);
}
Seq Part::DecodeContent_Base64(PinStore& store) const
{
Seq reader = m_contentEncoded;
Enc& enc = store.GetEnc(Base64::DecodeMaxLen(reader.n));
return Base64::MimeDecode(reader, enc);
}
void Part::EncodeContent_Base64(Seq content, PinStore& store)
{
m_contentEnc.ReInit().m_value = "base64";
if (!content.n)
m_contentEncoded = Seq();
else
{
Base64::NewLines nl = Base64::NewLines::Mime();
Enc& enc = store.GetEnc(Base64::EncodeMaxOutLen(content.n, nl));
m_contentEncoded = Base64::MimeEncode(content, enc, Base64::Padding::Yes, nl);
}
}
void Part::EncodeContent_QP(Seq content, PinStore& store)
{
m_contentEnc.ReInit().m_value = "quoted-printable";
if (!content.n)
m_contentEncoded = Seq();
else
{
Enc& enc = store.GetEnc(QuotedPrintableEncode_MaxLen(content.n));
m_contentEncoded = QuotedPrintableEncode(content, enc);
}
}
}
}
| 25.293073 | 157 | 0.630969 | denisbider |
e283e756b3c4851cbdfe690b435ffdf1fa24f275 | 5,504 | cpp | C++ | reporters/html_benchmark_reporter.cpp | Kristian-Popov/opencl-benchmark-and-fractals | b88fe08ea540c5743e9b590b160a995ead272a6e | [
"MIT"
] | null | null | null | reporters/html_benchmark_reporter.cpp | Kristian-Popov/opencl-benchmark-and-fractals | b88fe08ea540c5743e9b590b160a995ead272a6e | [
"MIT"
] | null | null | null | reporters/html_benchmark_reporter.cpp | Kristian-Popov/opencl-benchmark-and-fractals | b88fe08ea540c5743e9b590b160a995ead272a6e | [
"MIT"
] | null | null | null | #include "html_benchmark_reporter.h"
#include <chrono>
#include <unordered_map>
#include <algorithm>
#include <iterator>
#include "html_document.h"
#include "utils.h"
#include "devices/device_interface.h"
#include "devices/platform_interface.h"
#include "fixtures/fixture_id.h"
#include "indicators/duration_indicator.h"
const std::unordered_map<long double, std::string> HtmlBenchmarkReporter::avgDurationsUnits =
{
{ 1e-9, "nanoseconds" },
{ 1e-6, "microseconds" },
{ 1e-3, "milliseconds" },
{ 1, "seconds" },
{ 60, "minutes" },
{ 3600, "hours" }
};
const std::unordered_map<long double, std::string> HtmlBenchmarkReporter::durationPerElementUnits =
{
{1e-9, "nanoseconds/elem."},
{1e-6, "microseconds/elem."},
{1e-3, "milliseconds/elem."},
{1, "seconds/elem."},
{60, "minutes/elem."},
{3600, "hours/elem."}
};
const std::unordered_map<long double, std::string> HtmlBenchmarkReporter::elementsPerSecUnits =
{
{ 1, "elem./second" },
{ 1e+3, "thousands elem./second"},
{ 1e+6, "millions elem./second"},
{ 1e+9, "billions elem./second"}
};
HtmlBenchmarkReporter::HtmlBenchmarkReporter( const std::string& file_name )
: document_( std::make_shared<HtmlDocument>( file_name ) )
{}
void HtmlBenchmarkReporter::AddFixtureFamilyResults( const BenchmarkResultForFixtureFamily& results )
{
document_->AddHeader( results.fixture_family->name );
DurationIndicator duration_indicator( results );
std::vector<std::vector<HtmlDocument::CellDescription>> rows = {
{ // First row
HtmlDocument::CellDescription { "Platform name", true, 2 },
HtmlDocument::CellDescription { "Device name", true, 2 },
HtmlDocument::CellDescription{ "Algorithm", true, 2 },
},
{} // Second row
};
const std::vector<OperationStep>& steps = results.fixture_family->operation_steps;
int step_count = static_cast<int>( steps.size() ); // TODO make sure it fits
if( step_count > 1 )
{
step_count++; // Add a separate column for total duration
}
rows.at( 0 ).push_back( HtmlDocument::CellDescription { "Duration, seconds", true, 1, step_count } ); // TODO select unit
for( OperationStep step: steps )
{
rows.at( 1 ).push_back( OperationStepDescriptionRepository::Get( step ) );
}
if( step_count > 1 )
{
rows.at( 1 ).push_back( HtmlDocument::CellDescription{ "Total duration" } );
}
std::unordered_map<FixtureId, DurationIndicator::FixtureCalculatedData> data = duration_indicator.GetCalculatedData();
std::vector<FixtureId> ids;
std::transform( data.cbegin(), data.cend(), std::back_inserter( ids ),
[] ( const auto& p ) { return p.first; }
);
std::sort( ids.begin(), ids.end(), [] ( const FixtureId& lhs, const FixtureId& rhs ) {
{
std::string lhs_platform_name = std::shared_ptr<PlatformInterface>( lhs.device()->platform() )->Name();
std::string rhs_platform_name = std::shared_ptr<PlatformInterface>( rhs.device()->platform() )->Name();
if( lhs_platform_name < rhs_platform_name )
{
return true;
}
else if( rhs_platform_name < lhs_platform_name )
{
return false;
}
}
{
const std::string& lhs_device_name = lhs.device()->Name();
const std::string& rhs_device_name = rhs.device()->Name();
if( lhs_device_name < rhs_device_name )
{
return true;
}
else if( rhs_device_name < lhs_device_name )
{
return false;
}
}
{
if( lhs.algorithm() < rhs.algorithm() )
{
return true;
}
}
return false;
} );
for( FixtureId& id: ids )
{
const DurationIndicator::FixtureCalculatedData& measurements = data.at( id );
std::shared_ptr<PlatformInterface> platform{ id.device()->platform() };
EXCEPTION_ASSERT( platform->GetDevices().size() < std::numeric_limits<int>::max() );
int device_count = static_cast<int>( platform->GetDevices().size() );
std::vector<HtmlDocument::CellDescription> row = {
HtmlDocument::CellDescription{ platform->Name() },
HtmlDocument::CellDescription{ id.device()->Name() },
HtmlDocument::CellDescription{ id.algorithm() }
};
if( measurements.failure_reason )
{
row.push_back( HtmlDocument::CellDescription{ measurements.failure_reason.value(), false, 1, step_count } );
}
else
{
for( OperationStep step : steps )
{
double val{ 0.0 };
auto iter = measurements.step_durations.find( step );
if( iter != measurements.step_durations.end() )
{
val = iter->second.AsSeconds();
}
row.push_back( HtmlDocument::CellDescription { Utils::SerializeNumber( val ) } );
}
if( step_count > 1 )
{
row.push_back( HtmlDocument::CellDescription { Utils::SerializeNumber( measurements.total_duration.AsSeconds() ) } );
}
}
rows.push_back( row );
}
document_->AddTable( rows );
}
void HtmlBenchmarkReporter::Flush()
{
document_->BuildAndWriteToDisk();
}
| 33.560976 | 133 | 0.593932 | Kristian-Popov |
e2857683f842c1b798db84e767486d2327318212 | 9,589 | cpp | C++ | src/qt/qtbase/src/plugins/platforms/winrt/qwinrttheme.cpp | chihlee/phantomjs | 644e0b3a6c9c16bcc6f7ce2c24274bf7d764f53c | [
"BSD-3-Clause"
] | null | null | null | src/qt/qtbase/src/plugins/platforms/winrt/qwinrttheme.cpp | chihlee/phantomjs | 644e0b3a6c9c16bcc6f7ce2c24274bf7d764f53c | [
"BSD-3-Clause"
] | null | null | null | src/qt/qtbase/src/plugins/platforms/winrt/qwinrttheme.cpp | chihlee/phantomjs | 644e0b3a6c9c16bcc6f7ce2c24274bf7d764f53c | [
"BSD-3-Clause"
] | null | null | null | /****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the plugins of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qwinrttheme.h"
#include "qwinrtmessagedialoghelper.h"
#include "qwinrtfiledialoghelper.h"
#include <QtCore/qfunctions_winrt.h>
#include <QtGui/QPalette>
#include <wrl.h>
#include <windows.ui.h>
#include <windows.ui.viewmanagement.h>
using namespace Microsoft::WRL;
using namespace ABI::Windows::UI;
using namespace ABI::Windows::UI::ViewManagement;
QT_BEGIN_NAMESPACE
static IUISettings *uiSettings()
{
static ComPtr<IUISettings> settings;
if (!settings) {
HRESULT hr;
hr = RoActivateInstance(Wrappers::HString::MakeReference(RuntimeClass_Windows_UI_ViewManagement_UISettings).Get(),
&settings);
Q_ASSERT_SUCCEEDED(hr);
}
return settings.Get();
}
class QWinRTThemePrivate
{
public:
QPalette palette;
};
static inline QColor fromColor(const Color &color)
{
return QColor(color.R, color.G, color.B, color.A);
}
QWinRTTheme::QWinRTTheme()
: d_ptr(new QWinRTThemePrivate)
{
Q_D(QWinRTTheme);
HRESULT hr;
Color color;
#ifdef Q_OS_WINPHONE
hr = uiSettings()->UIElementColor(UIElementType_PopupBackground, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::ToolTipBase, fromColor(color));
d->palette.setColor(QPalette::AlternateBase, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_NonTextMedium, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Button, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_NonTextMediumHigh, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Midlight, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_NonTextHigh, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Light, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_NonTextMediumLow, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Mid, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_NonTextLow, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Dark, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_TextHigh, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::ButtonText, fromColor(color));
d->palette.setColor(QPalette::Text, fromColor(color));
d->palette.setColor(QPalette::WindowText, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_TextMedium, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::ToolTipText, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_AccentColor, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Highlight, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_PageBackground, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Window, fromColor(color));
d->palette.setColor(QPalette::Base, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_TextContrastWithHigh, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::BrightText, fromColor(color));
#else
hr = uiSettings()->UIElementColor(UIElementType_ActiveCaption, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::ToolTipBase, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_Background, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::AlternateBase, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_ButtonFace, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Button, fromColor(color));
d->palette.setColor(QPalette::Midlight, fromColor(color).lighter(110));
d->palette.setColor(QPalette::Light, fromColor(color).lighter(150));
d->palette.setColor(QPalette::Mid, fromColor(color).dark(130));
d->palette.setColor(QPalette::Dark, fromColor(color).dark(150));
hr = uiSettings()->UIElementColor(UIElementType_ButtonText, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::ButtonText, fromColor(color));
d->palette.setColor(QPalette::Text, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_CaptionText, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::ToolTipText, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_Highlight, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Highlight, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_HighlightText, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::HighlightedText, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_Window, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::Window, fromColor(color));
d->palette.setColor(QPalette::Base, fromColor(color));
hr = uiSettings()->UIElementColor(UIElementType_Hotlight, &color);
Q_ASSERT_SUCCEEDED(hr);
d->palette.setColor(QPalette::BrightText, fromColor(color));
#endif
}
bool QWinRTTheme::usePlatformNativeDialog(DialogType type) const
{
static bool useNativeDialogs = qEnvironmentVariableIsSet("QT_USE_WINRT_NATIVE_DIALOGS")
? qgetenv("QT_USE_WINRT_NATIVE_DIALOGS").toInt() : true;
if (type == FileDialog || type == MessageDialog)
return useNativeDialogs;
return false;
}
QPlatformDialogHelper *QWinRTTheme::createPlatformDialogHelper(DialogType type) const
{
switch (type) {
case FileDialog:
return new QWinRTFileDialogHelper;
case MessageDialog:
return new QWinRTMessageDialogHelper(this);
default:
break;
}
return QPlatformTheme::createPlatformDialogHelper(type);
}
QVariant QWinRTTheme::styleHint(QPlatformIntegration::StyleHint hint)
{
HRESULT hr;
switch (hint) {
case QPlatformIntegration::CursorFlashTime: {
quint32 blinkRate;
hr = uiSettings()->get_CaretBlinkRate(&blinkRate);
RETURN_IF_FAILED("Failed to get caret blink rate", return defaultThemeHint(CursorFlashTime));
return blinkRate;
}
case QPlatformIntegration::KeyboardInputInterval:
return defaultThemeHint(KeyboardInputInterval);
case QPlatformIntegration::MouseDoubleClickInterval: {
quint32 doubleClickTime;
hr = uiSettings()->get_DoubleClickTime(&doubleClickTime);
RETURN_IF_FAILED("Failed to get double click time", return defaultThemeHint(MouseDoubleClickInterval));
return doubleClickTime;
}
case QPlatformIntegration::StartDragDistance:
return defaultThemeHint(StartDragDistance);
case QPlatformIntegration::StartDragTime:
return defaultThemeHint(StartDragTime);
case QPlatformIntegration::KeyboardAutoRepeatRate:
return defaultThemeHint(KeyboardAutoRepeatRate);
case QPlatformIntegration::ShowIsFullScreen:
return true;
case QPlatformIntegration::PasswordMaskDelay:
return defaultThemeHint(PasswordMaskDelay);
case QPlatformIntegration::FontSmoothingGamma:
return qreal(1.7);
case QPlatformIntegration::StartDragVelocity:
return defaultThemeHint(StartDragVelocity);
case QPlatformIntegration::UseRtlExtensions:
return false;
case QPlatformIntegration::SynthesizeMouseFromTouchEvents:
return true;
case QPlatformIntegration::PasswordMaskCharacter:
return defaultThemeHint(PasswordMaskCharacter);
case QPlatformIntegration::SetFocusOnTouchRelease:
return false;
case QPlatformIntegration::ShowIsMaximized:
return false;
case QPlatformIntegration::MousePressAndHoldInterval:
return defaultThemeHint(MousePressAndHoldInterval);
default:
break;
}
return QVariant();
}
const QPalette *QWinRTTheme::palette(Palette type) const
{
Q_D(const QWinRTTheme);
if (type == SystemPalette)
return &d->palette;
return QPlatformTheme::palette(type);
}
QT_END_NAMESPACE
| 38.051587 | 122 | 0.724059 | chihlee |
e2893983296a54d0a98e9fe11d5382e26457c54f | 3,731 | cpp | C++ | src/sequence.cpp | liangjin2007/smplxpp | 9a0d1cea136ea924628a9a031fa673fc9531dd85 | [
"Apache-2.0"
] | 73 | 2020-07-10T03:22:14.000Z | 2022-03-02T21:22:18.000Z | src/sequence.cpp | liangjin2007/smplxpp | 9a0d1cea136ea924628a9a031fa673fc9531dd85 | [
"Apache-2.0"
] | 4 | 2020-07-13T05:59:39.000Z | 2021-04-09T03:53:01.000Z | src/sequence.cpp | liangjin2007/smplxpp | 9a0d1cea136ea924628a9a031fa673fc9531dd85 | [
"Apache-2.0"
] | 16 | 2020-07-10T03:22:20.000Z | 2022-02-11T19:09:41.000Z | #include "smplx/sequence.hpp"
#include <fstream>
#include <iostream>
#include <cnpy.h>
#include "smplx/util.hpp"
#include "smplx/util_cnpy.hpp"
namespace smplx {
namespace {
using util::assert_shape;
} // namespace
// AMASS npz structure
// 'trans': (#frames, 3)
// 'gender': str
// 'mocap_framerate': float
// 'betas': (16) first 10 are from the usual SMPL
// 'dmpls': (#frames, 8) soft tissue
// 'poses': (#frames, 156) first 66 are SMPL joint parameters
// excluding hand.
// last 90 are MANO joint parameters, which
// correspond to last 90 joints in
// SMPL-X (NOT hand PCA)
//
template <class SequenceConfig>
Sequence<SequenceConfig>::Sequence(const std::string& path) {
if (path.size()) {
load(path);
} else {
n_frames = 0;
gender = Gender::neutral;
}
}
template <class SequenceConfig>
bool Sequence<SequenceConfig>::load(const std::string& path) {
if (!std::ifstream(path)) {
n_frames = 0;
gender = Gender::unknown;
std::cerr << "WARNING: Sequence '" << path
<< "' does not exist, loaded empty sequence\n";
return false;
}
// ** READ NPZ **
cnpy::npz_t npz = cnpy::npz_load(path);
if (npz.count("trans") != 1 || npz.count("poses") != 1 ||
npz.count("betas") != 1) {
n_frames = 0;
gender = Gender::unknown;
std::cerr << "WARNING: Sequence '" << path
<< "' is invalid, loaded empty sequence\n";
return false;
}
auto& trans_raw = npz["trans"];
assert_shape(trans_raw, {util::ANY_SHAPE, 3});
n_frames = trans_raw.shape[0];
trans = util::load_float_matrix(trans_raw, n_frames, 3);
auto& poses_raw = npz["poses"];
assert_shape(poses_raw, {n_frames, SequenceConfig::n_pose_params()});
pose = util::load_float_matrix(poses_raw, n_frames,
SequenceConfig::n_pose_params());
auto& shape_raw = npz["betas"];
assert_shape(shape_raw, {SequenceConfig::n_shape_params()});
shape =
util::load_float_matrix(poses_raw, SequenceConfig::n_shape_params(), 1);
if (SequenceConfig::n_dmpls() && npz.count("dmpls") == 1) {
auto& dmpls_raw = npz["dmpls"];
assert_shape(dmpls_raw, {n_frames, SequenceConfig::n_dmpls()});
dmpls = util::load_float_matrix(poses_raw, n_frames,
SequenceConfig::n_dmpls());
}
if (npz.count("gender")) {
char gender_spec = npz["gender"].data_holder[0];
gender =
gender_spec == 'f'
? Gender::female
: gender_spec == 'm'
? Gender::male
: gender_spec == 'n' ? Gender::neutral : Gender::unknown;
} else {
// Default to neutral
std::cerr << "WARNING: gender not present in '" << path
<< "', using neutral\n";
gender = Gender::neutral;
}
if (npz.count("mocap_framerate")) {
auto& mocap_frate_raw = npz["mocap_framerate"];
if (mocap_frate_raw.word_size == 8)
frame_rate = *mocap_frate_raw.data<double>();
else if (mocap_frate_raw.word_size == 4)
frame_rate = *mocap_frate_raw.data<float>();
} else {
// Reasonable default
std::cerr << "WARNING: mocap_framerate not present in '" << path
<< "', assuming 120 FPS\n";
frame_rate = 120.f;
}
return true;
}
// Instantiation
template class Sequence<sequence_config::AMASS>;
} // namespace smplx
| 33.017699 | 80 | 0.551327 | liangjin2007 |
e2897e5886fec358d757012ab5d190e56439589e | 6,020 | cpp | C++ | src/tools/ThreadGestion.cpp | etrange02/Fux | 2f49bcd8ec82eb521092c9162e01c8b0d00222ab | [
"CECILL-B"
] | 2 | 2016-03-21T10:48:34.000Z | 2017-03-17T19:50:34.000Z | src/tools/ThreadGestion.cpp | etrange02/Fux | 2f49bcd8ec82eb521092c9162e01c8b0d00222ab | [
"CECILL-B"
] | null | null | null | src/tools/ThreadGestion.cpp | etrange02/Fux | 2f49bcd8ec82eb521092c9162e01c8b0d00222ab | [
"CECILL-B"
] | null | null | null | /***************************************************************
* Name: ThreadGestion.cpp
* Purpose: Code for Fu(X) 2.0
* Author: David Lecoconnier (david.lecoconnier@free.fr)
* Created: 2010-05-07
* Copyright: David Lecoconnier (http://www.getfux.fr)
* License:
**************************************************************/
#include "../../include/tools/ThreadGestion.h"
/**
* @class ThreadFichierFichier
* @brief Thread faisant de la gestion de dossiers et fichiers
*/
static ThreadFichierFichier* s_instanceThreadFichier = NULL;
/**
* Constructeur
*/
ThreadFichierFichier::ThreadFichierFichier() : wxThread(wxTHREAD_JOINABLE)
{
m_estActif = false;
m_continue = false;
m_liste = new ArrayOfElementThreadFichier;
Create();
}
/**
* Destructeur
*/
ThreadFichierFichier::~ThreadFichierFichier()
{
ViderListe();
delete m_liste;
LogFileAppend(_T("ThreadFichierFichier::~ThreadFichierFichier"));
}
/**
* Ajoute à la liste de traitement les combinaisons d'éléments données en paramètre
* @param tableau un array contenant des chemins complets
* @param action l'action à effectuer (copie, déplacement, suppression)
* @param dest le répertoire de destination si besoin
*/
void ThreadFichierFichier::AjoutDonnee(wxArrayString *tableau, int action, wxString dest)
{
size_t max = tableau->GetCount();
for (size_t i=0; i<max; i++)
m_liste->Add(new ElementThreadFichier(tableau->Item(i), action, dest));
delete tableau;
/*if (IsPaused())
Resume();*/
}
/**
* Retourne l'instance de la classe
* @return l'instance
*/
ThreadFichierFichier* ThreadFichierFichier::Get()
{
if (!s_instanceThreadFichier)
s_instanceThreadFichier = new ThreadFichierFichier;
return s_instanceThreadFichier;
}
/**
* Retourne l'état du thread
* @return l'état
*/
bool ThreadFichierFichier::GetEtat()
{ return m_estActif;}
/**
* Stop le thread
*/
void ThreadFichierFichier::SetStop()
{ m_continue = false;}
/**
* Efface la liste des modifications non effectuées
*/
void ThreadFichierFichier::ViderListe()
{
m_liste->Clear();
}
/**
* Lance le traitement des dossiers et fichiers
*/
void* ThreadFichierFichier::Entry()
{
m_estActif = true;
m_continue = true;
ElementThreadFichier *element = NULL;
wxString chemin;
while (m_continue && !TestDestroy())
{
if (m_liste->IsEmpty())
Sleep(500);
else
{
element = m_liste->Item(0);
if (element->IsAction(COPIE))
{
chemin = element->GetDestination() + wxFileName::GetPathSeparator() + element->GetNom().AfterLast(wxFileName::GetPathSeparator());
if (wxFileExists(element->GetNom()))
wxCopyFile(element->GetNom(), chemin, false);
else if (wxDirExists(element->GetNom()))
{
DossierCopie(element->GetNom(), chemin);
FichierCopie(element->GetNom(), chemin);
}
}
else if (element->IsAction(DEPLACE))
{
chemin = element->GetDestination() + wxFileName::GetPathSeparator() + element->GetNom().AfterLast(wxFileName::GetPathSeparator());
if (wxFileExists(element->GetNom()))
wxRenameFile(element->GetNom(), chemin, false);
else if (wxDirExists(element->GetNom()))
{
DossierCopie(element->GetNom(), chemin);
FichierDeplace(element->GetNom(), chemin);
}
}
else if (element->IsAction(SUPPRIME))
{
if (wxFileExists(element->GetNom()))
wxRemoveFile(element->GetNom());
else if (wxDirExists(element->GetNom()))
FichierSuppression(element->GetNom());
}
element->~ElementThreadFichier();
m_liste->Remove(element);
}
}
m_estActif = false;
m_continue = false;
return NULL;
}
/**
* Supprime une arborescence de dossier. Le premier dossier est la racine. Les dossiers ne doivent contenir aucun fichier !
* @param dossier un array de nom de dossier dont le premier est la racine
* @see FichierSuppression
*/
void ThreadFichierFichier::DossierSuppression(wxArrayString &dossier)
{
size_t i = dossier.GetCount();
while(i>0)
{
wxRmdir(dossier[i-1]);
i--;
}
dossier.Empty();
}
/**
* Copie le contenu du dossier dep dans le répertoire dest. Les fichiers ne sont pas copiés.
* @param dep le dossier à copier
* @param dest le répertoire de destination
* @see FichierCopie
*/
void ThreadFichierFichier::DossierCopie(wxString dep, wxString dest)
{
wxDir dir(dep);
TraverserCopieDossier traverser(dest, dep);
dir.Traverse(traverser);
}
/**
* Supprime le répertoire chemin ainsi que les fichiers et dossiers se trouvant à l'intérieur
* @param chemin le répertoire à supprimer
*/
void ThreadFichierFichier::FichierSuppression(wxString chemin)
{
wxArrayString tableau;
wxDir dir(chemin);
// TraverserSupprimeFichier traverser(chemin, tableau);
// dir.Traverse(traverser);
DossierSuppression(tableau);
}
/**
* Copie les fichiers se trouvant dans l'arborescence dep dans le répertoire dest. Les dossiers doivent exister !
* @param dep le répertoire de départ
* @param dest le répertoire d'arrivée
*/
void ThreadFichierFichier::FichierCopie(wxString dep, wxString dest)
{
wxDir dir(dep);
TraverserCopieFichier traverser(dest, dep);
dir.Traverse(traverser);
}
/**
* Déplace le contenu de dep dans le répertoire dest
* @param dep le dossier de départ
* @param dest le dossier d'arrivée
*/
void ThreadFichierFichier::FichierDeplace(wxString dep, wxString dest)
{
wxArrayString tableau;
wxDir dir(dep);
TraverserDeplaceFichier traverser(dest, dep, tableau);
dir.Traverse(traverser);
DossierSuppression(tableau);
}
| 28 | 146 | 0.634219 | etrange02 |
e289a2a9b7a1347a9de65f3ad3194948f5550a39 | 4,782 | cpp | C++ | src2/freevariablesofterm.cpp | tamaskenez/forrestlang | 76b82803ac435f627ad52f9cfc12fe9c863a8495 | [
"MIT"
] | null | null | null | src2/freevariablesofterm.cpp | tamaskenez/forrestlang | 76b82803ac435f627ad52f9cfc12fe9c863a8495 | [
"MIT"
] | 1 | 2019-03-19T18:11:21.000Z | 2019-03-19T18:11:21.000Z | src2/freevariablesofterm.cpp | tamaskenez/somenewlanguage | 76b82803ac435f627ad52f9cfc12fe9c863a8495 | [
"MIT"
] | null | null | null | #include "freevariablesofterm.h"
#include "store.h"
namespace snl {
FreeVariables GetFreeVariablesCore(Store& store, TermPtr term)
{
using Tag = term::Tag;
const static FreeVariables empty_fvs;
switch (term->tag) {
case Tag::Abstraction: {
auto abstraction = term_cast<term::Abstraction>(term);
auto fvs = *GetFreeVariables(store, abstraction->body);
for (auto& p : abstraction->parameters) {
auto* fvs_expected_type = GetFreeVariables(store, p.expected_type);
fvs.insert(BE(*fvs_expected_type));
}
for (auto& p : abstraction->parameters) {
fvs.erase(p.variable);
}
for (auto it = abstraction->bound_variables.rbegin();
it != abstraction->bound_variables.rend(); ++it) {
fvs.erase(it->variable);
auto* fvs_of_value = GetFreeVariables(store, it->value);
fvs.insert(BE(*fvs_of_value));
}
fvs.erase(BE(abstraction->forall_variables));
return fvs;
}
case Tag::LetIns: {
auto let_ins = term_cast<term::Abstraction>(term);
auto fvs = *GetFreeVariables(store, let_ins->body);
for (auto it = let_ins->bound_variables.rbegin(); it != let_ins->bound_variables.rend();
++it) {
fvs.erase(it->variable);
auto* fvs_of_value = GetFreeVariables(store, it->value);
fvs.insert(BE(*fvs_of_value));
}
return fvs;
}
case Tag::Application: {
auto application = term_cast<term::Application>(term);
auto fvs = *GetFreeVariables(store, application->function);
for (auto& a : application->arguments) {
auto* fvs_argument = GetFreeVariables(store, a);
fvs.insert(BE(*fvs_argument));
}
return fvs;
}
case Tag::Variable:
return FreeVariables({term_cast<term::Variable>(term)});
case Tag::StringLiteral:
case Tag::NumericLiteral:
case Tag::UnitLikeValue:
case Tag::SimpleTypeTerm:
assert(false); // This should be caught in GetFreeVariables().
return empty_fvs;
case Tag::DeferredValue:
assert(false); // This should be put only into a Variable which is never dereferenced
// here.
return empty_fvs;
case Tag::ProductValue: {
auto product_value = term_cast<term::ProductValue>(term);
FreeVariables fvs;
for (auto& [selector, v] : product_value->values) {
auto* fvs_value = GetFreeVariables(store, v);
fvs.insert(BE(*fvs_value));
}
return fvs;
}
case Tag::FunctionType: {
auto function_type = term_cast<term::FunctionType>(term);
FreeVariables fvs;
for (auto p : function_type->parameter_types) {
auto* fvs_p = GetFreeVariables(store, p.type);
if (p.comptime_parameter) {
assert(function_type->forall_variables.count(*p.comptime_parameter) > 0);
}
fvs.insert(BE(*fvs_p));
}
auto* fvs_result_type = GetFreeVariables(store, function_type->result_type);
fvs.insert(BE(*fvs_result_type));
fvs.erase(BE(function_type->forall_variables));
return fvs;
}
case Tag::ProductType: {
auto product_type = term_cast<term::ProductType>(term);
FreeVariables fvs;
for (auto& [selector, type] : product_type->members) {
auto* fvs_m = GetFreeVariables(store, type);
fvs.insert(BE(*fvs_m));
}
return fvs;
}
}
}
FreeVariables const* GetFreeVariables(Store& store, TermPtr term)
{
using Tag = term::Tag;
switch (term->tag) {
case Tag::StringLiteral:
case Tag::NumericLiteral:
case Tag::SimpleTypeTerm:
const static FreeVariables empty_fv;
return &empty_fv;
case Tag::UnitLikeValue: {
auto* unit_like_value = term_cast<term::UnitLikeValue>(term);
return GetFreeVariables(store, unit_like_value->type);
}
default:
break;
}
auto it = store.free_variables_of_terms.find(term);
if (it == store.free_variables_of_terms.end()) {
it = store.free_variables_of_terms
.insert(make_pair(term, store.MakeCanonical(GetFreeVariablesCore(store, term))))
.first;
}
return it->second;
}
} // namespace snl
| 38.564516 | 100 | 0.557716 | tamaskenez |
e28f417b66cf026be331d48c20c12478da28b11a | 5,015 | hpp | C++ | code/include/graphicPrimitives/FrameRenderable.hpp | Shutter-Island-Team/Shutter-island | c5e7c0b2c60c34055e64104dcbc396b9e1635f33 | [
"MIT"
] | 4 | 2016-06-24T09:22:18.000Z | 2019-06-13T13:50:53.000Z | code/include/graphicPrimitives/FrameRenderable.hpp | Shutter-Island-Team/Shutter-island | c5e7c0b2c60c34055e64104dcbc396b9e1635f33 | [
"MIT"
] | null | null | null | code/include/graphicPrimitives/FrameRenderable.hpp | Shutter-Island-Team/Shutter-island | c5e7c0b2c60c34055e64104dcbc396b9e1635f33 | [
"MIT"
] | 2 | 2016-06-10T12:46:17.000Z | 2018-10-14T06:37:21.000Z | #ifndef FRAME_RENDERABLE_HPP
#define FRAME_RENDERABLE_HPP
/**@file
* @brief Define a class to render the world frame.
*
* This file defines the class FrameRenderable to render the world frame.
*/
#include "../HierarchicalRenderable.hpp"
#include <vector>
#include <glm/glm.hpp>
/**@brief Render the world frame.
*
* This class is the first renderable you will use (see the Tutorial 03 of
* practical 01). It will render the world frame on the screen: a red line
* for the X axis, a green line for the Y axis and a blue line for the Z
* axis. Have a look at the source: we documented it to help you to understand
* the details.
*/
// A renderable must implement the Renderable interface, as such we make this
// class inherit publicly from Renderable.
class FrameRenderable : public HierarchicalRenderable
{
// Only the constructor and the destructor are meant to be called outside of
// the class. This is why they constitute the only public methods.
public :
/**@brief Destructor.
*
* Instance destructor.
*/
~FrameRenderable();
/**@brief Constructor.
*
* Create a new instance that will rendered thanks to the given shader program.
* @param shaderProgram The shader program to use to render this frame renderable.
*/
FrameRenderable(ShaderProgramPtr shaderProgram);
// Define the private section: member and functions only accessible to the class itself
private:
/**@brief Forbidden default constructor.
*
* By putting the default constructor in the private section, we make it
* forbidden (since it is private, no other class can call it). We do not
* need to provide an implementation as the compiler will never need it.*/
FrameRenderable();
/**@brief Draw this renderable.
*
* The implementation of the draw() interface of Renderable. This is where
* drawing commands are issued.
*/
void do_draw();
/**@brief Animate this renderable.
*
* The implementation of the animate( float time ) or Renderable. This does
* nothing as we do not need to animate it.
* @param time The current simulation time.
*/
void do_animate( float time );
/**@brief Initialize the vertex attributes of the frame.
*
* This function intializes the geometry and the color of the frame. We put
* it in its own method help you to understand what is done in the constructor.
*/
void initAttributes();
/**@brief Position attribute of the vertices.
*
* Store the position attribute of the vertices. Notice that all the instances,
* those positions would be the same. Thus, you could make this data member
* static: shared by all instances of the class. We decided to not make it
* static to help people that are new to c++.
*/
/**@brief Color attribute of the vertices.
*
* Store the color attribute of the vertices. Notice that all the instances,
* those colors would be the same. Thus, you could make this data member
* static: shared by all instances of the class. We decided to not make it
* static to help people that are new to c++.
*/
std::vector< glm::vec3 > m_positions;
std::vector< glm::vec4 > m_colors;
/**@brief Location of the position attribute buffer.
*
* Store the location (index) of the position attribute buffer on the shader
* program used to render the instance. If all instances are rendered by the
* same shader program, you could make this location static and set this
* location when the first instance is created. We decided to not make it
* static as it would be harder to understand and it is quite constraining:
* if you want to use more than shader program to render frame renderable
* instances, this will lead to bugs tricky to understand for beginners.
*/
unsigned int m_pBuffer;
/**@brief Location of the color attribute buffer.
*
* Store the location (index) of the color attribute buffer on the shader
* program used to render the instance. If all instances are rendered by the
* same shader program, you could make this location static and set this
* location when the first instance is created. We decided to not make it
* static as it would be harder to understand and it is quite constraining:
* if you want to use more than shader program to render frame renderable
* instances, this will lead to bugs tricky to understand for beginners.
*/
unsigned int m_cBuffer;
/* Note: We could store all the buffers at the same place.
*
* enum { POSITION_BUFFER, COLOR_BUFFER, NUMBER_OF_BUFFERS };
* unsigned int m_buffers[ NUMBER_OF_BUFFERS ];
*
* Then, when we generate those buffers:
* glGenBuffers( NUMBER_OF_BUFFERS, m_buffers );
*
* And at destruction:
* glDeleteBuffers( NUMBER_OF_BUFFERS, m_buffers );
*/
};
typedef std::shared_ptr<FrameRenderable> FrameRenderablePtr;
#endif
| 38.875969 | 87 | 0.698106 | Shutter-Island-Team |
e290b27c13bab64d24723a7681fda41b9acd7c83 | 646 | cpp | C++ | data-structure/Raiz.cpp | ejpcr/libs-c | e544e4338ea9f2fe8c57de83045944f38ae06a07 | [
"MIT"
] | null | null | null | data-structure/Raiz.cpp | ejpcr/libs-c | e544e4338ea9f2fe8c57de83045944f38ae06a07 | [
"MIT"
] | null | null | null | data-structure/Raiz.cpp | ejpcr/libs-c | e544e4338ea9f2fe8c57de83045944f38ae06a07 | [
"MIT"
] | null | null | null | //Programa que calcula la raiz de un entero positivo N.
//Sin utilizar la libreria math.h
//Alumno: Castillo Gardea Mariano
//No Control: 01070097
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
void captura(int &);
void validacion(int &);
void raiz(int &);
void main()
{int numero; clrscr();
captura(numero);
getchar();
}
void captura(int &numero)
{cout<<"Introduce un numero entero y positivo ";
cin>>numero; validacion(numero);
}
void validacion(int &numero)
{if(numero>0)
cout<<"Numero Aceptado\n";
else
{cout<<"Numero no aceptado\n"; captura(numero);}
}
void raiz(int &x)
{int i=1;
do{x=(i/2)*(i+(x/i)}
while(x
}
| 17.459459 | 55 | 0.682663 | ejpcr |
e299e516b3c7bb22b7e0ebcf9328c7fd00722361 | 4,061 | cpp | C++ | RunInBash/RunInBash.cpp | neosmart/RunInBash | 3e2368f95030f1cd39c27001cb21fa50f2e289d1 | [
"MIT"
] | 83 | 2017-04-25T03:39:53.000Z | 2022-03-17T03:37:59.000Z | RunInBash/RunInBash.cpp | benpope82/RunInBash | 3e2368f95030f1cd39c27001cb21fa50f2e289d1 | [
"MIT"
] | 6 | 2017-04-25T20:13:01.000Z | 2021-08-02T05:03:08.000Z | RunInBash/RunInBash.cpp | neosmart/RunInBash | 3e2368f95030f1cd39c27001cb21fa50f2e289d1 | [
"MIT"
] | 11 | 2017-05-13T10:14:58.000Z | 2021-08-12T17:06:27.000Z | #include "stdafx.h"
#include <cassert>
#include <memory>
#include "ArgHelper.h"
template <typename T> //for both const and non-const
T *TrimStart(T *str)
{
assert(str != nullptr);
while (str[0] == _T(' '))
{
++str;
}
return str;
}
//There is no CommandLineToArgvA(), so we rely on the caller to pass in argv[]
template <typename T>
const TCHAR *GetArgumentString(const T argv)
{
const TCHAR *cmdLine = GetCommandLine();
bool escaped = cmdLine[0] == '\'' || cmdLine[0] == '\"';
const TCHAR *skipped = cmdLine + _tcsclen(argv[0]) + (escaped ? 1 : 0) * 2;
return TrimStart(skipped);
}
void PrintHelp()
{
_tprintf_s(_T("RunInBash by NeoSmart Technologies - Copyright 2017-2018\n"));
_tprintf_s(_T("Easily run command(s) under bash, capturing the exit code.\n"));
_tprintf_s(_T("Usage: Alias $ to RunInBash.exe and prefix WSL commands with $ to execute. For example:\n"));
_tprintf_s(_T("$ uname -a\n"));
}
TCHAR *Escape(const TCHAR *string)
{
assert(string != nullptr);
int newLength = 1; //terminating null
for (size_t i = 0; string[i] != _T('\0'); ++i)
{
++newLength;
//these characters will be escaped, so add room for one slash
if (string[i] == _T('"') || string[i] == _T('\\'))
{
++newLength;
}
}
TCHAR *escaped = (TCHAR *) calloc(newLength, sizeof(TCHAR));
for (size_t i = 0, j = 0; string[i] != _T('\0'); ++i, ++j)
{
if (string[i] == _T('"') || string[i] == _T('\\'))
{
escaped[j++] = _T('\\');
}
escaped[j] = string[i];
}
return escaped;
}
int _tmain(int argc, TCHAR *argv[])
{
//for multi-arch (x86/x64) support with one (x86) binary
PVOID oldValue;
Wow64DisableWow64FsRedirection(&oldValue);
//Search for bash.exe
TCHAR bash[MAX_PATH] = { 0 };
ExpandEnvironmentStrings(_T("%windir%\\system32\\bash.exe"), bash, _countof(bash));
bool found = GetFileAttributes(bash) != INVALID_FILE_ATTRIBUTES;
if (!found)
{
_ftprintf(stderr, _T("Unable to find bash.exe!\n"));
return -1;
}
#ifdef _DEBUG
int debugLevel = 1;
#else
int debugLevel = 0;
#endif
//Get whatever the user entered after our EXE as a single string
auto argument = GetArgumentString(argv);
if (_tcsclen(argument) == 0)
{
PrintHelp();
ExitProcess(-1);
}
//handle possible arguments
if (is_any_of(argv[1], _T("--help"), _T("-h"), _T("/h"), _T("/help"), _T("/?")))
{
PrintHelp();
ExitProcess(0);
}
if (is_any_of(argv[1], _T("--verbose"), _T("-v"), _T("/verbose"), _T("/v")))
{
debugLevel = 1;
argument = TrimStart(argument + 2);
}
if (is_any_of(argv[1], _T("--debug"), _T("-d"), _T("/debug"), _T("/d")))
{
debugLevel = 2;
argument = TrimStart(argument + 2);
}
//Escape it to be placed within double quotes.
//In a scope to prevent inadvertent use of freed variables
TCHAR *lpArg;
{
auto escaped = Escape(argument);
int temp = sizeof(escaped);
TCHAR *format = _T("bash -c \"%s\"");
size_t length = _tcsclen(format) + _tcslen(escaped) + 1;
lpArg = (TCHAR *)alloca(sizeof(TCHAR) * length);
ZeroMemory(lpArg, sizeof(TCHAR) * length);
_stprintf(lpArg, format, escaped);
free(escaped);
}
TCHAR currentDir[MAX_PATH] = { 0 };
GetCurrentDirectory(_countof(currentDir), currentDir);
if (debugLevel >= 1)
{
_ftprintf(stderr, _T("> %s\n"), lpArg);
}
auto startInfo = STARTUPINFO { 0 };
auto pInfo = PROCESS_INFORMATION { 0 };
bool success = CreateProcess(bash, lpArg, nullptr, nullptr, true, 0, nullptr, currentDir, &startInfo, &pInfo);
if (!success)
{
_ftprintf(stderr, _T("Failed to create process. Last error: 0x%x\n"), GetLastError());
return GetLastError();
}
WaitForSingleObject(pInfo.hProcess, INFINITE);
DWORD bashExitCode = -1;
while (GetExitCodeProcess(pInfo.hProcess, &bashExitCode) == TRUE)
{
if (bashExitCode == STILL_ACTIVE)
{
//somehow process hasn't terminated according to the kernel
continue;
}
break;
}
CloseHandle(pInfo.hProcess);
return bashExitCode;
}
| 25.067901 | 112 | 0.622014 | neosmart |
e29c1cafb8d6986ad83ffad1dd2ed9726774d92d | 298 | cpp | C++ | src/searchResultsLv.cpp | romdb/romdbLauncher | 492e6d124817b11f16e7d8329d854ed837a76ea0 | [
"Zlib"
] | null | null | null | src/searchResultsLv.cpp | romdb/romdbLauncher | 492e6d124817b11f16e7d8329d854ed837a76ea0 | [
"Zlib"
] | null | null | null | src/searchResultsLv.cpp | romdb/romdbLauncher | 492e6d124817b11f16e7d8329d854ed837a76ea0 | [
"Zlib"
] | null | null | null | #include "searchResultsLv.h"
#include "Resource.h"
LRESULT SearchResultsLv::OnDblClick(DWORD fwKeys, int X, int Y)
{
LVHITTESTINFO hti = {};
hti.pt.x = X;
hti.pt.y = Y;
int idx = HitTest(&hti);
if (idx != -1)
{
SendMessageW(GetParent(Handle), WM_COMMAND, ID_OPENROM, idx);
}
return 0;
}
| 18.625 | 63 | 0.667785 | romdb |
e29e300a0fbccbea4d87c0c7ef05878613e14c66 | 3,112 | cpp | C++ | sdl/main.cpp | bduvenhage/Bits-O-Cpp | a2325978646fd27fc14de99b45c42072447af2db | [
"MIT"
] | 19 | 2018-07-02T17:06:54.000Z | 2021-03-04T18:29:21.000Z | sdl/main.cpp | bduvenhage/Bits-O-Cpp | a2325978646fd27fc14de99b45c42072447af2db | [
"MIT"
] | 1 | 2019-04-06T13:46:41.000Z | 2020-06-15T14:59:26.000Z | sdl/main.cpp | bduvenhage/Bits-O-Cpp | a2325978646fd27fc14de99b45c42072447af2db | [
"MIT"
] | 3 | 2020-04-14T09:19:43.000Z | 2021-03-27T06:40:52.000Z | #include "../defines/tc_defines.h"
#include "../math/tc_math.h"
#include "../sdl/sdl.h"
#include <iostream>
#include <iomanip>
#include <vector>
using Vertex = std::pair<int, int>;
using Line = std::pair<Vertex, Vertex>;
//! Grow the snowflake one level deeper.
std::vector<Line> grow_koch_snowflake(const std::vector<Line> &input_snowflake)
{
std::vector<Line> output_snowflake;
output_snowflake.reserve(input_snowflake.size() * 4);
for (const auto &line : input_snowflake)
{
const double x0 = line.first.first + 0.5;
const double x1 = line.second.first + 0.5;
const double y0 = line.first.second + 0.5;
const double y1 = line.second.second + 0.5;
const double xa = (x1-x0) * (1.0/3.0) + x0;
const double xb = (x1-x0) * (1.0/2.0) + x0 - sin(60.0*M_PI/180.0)*(y1-y0)/3.0;
const double xc = (x1-x0) * (2.0/3.0) + x0;
const double ya = (y1-y0) * (1.0/3.0) + y0;
const double yb = (y1-y0) * (1.0/2.0) + y0 + sin(60.0*M_PI/180.0)*(x1-x0)/3.0;
const double yc = (y1-y0) * (2.0/3.0) + y0;
output_snowflake.push_back(Line(Vertex(x0, y0), Vertex(xa, ya)));
output_snowflake.push_back(Line(Vertex(xa, ya), Vertex(xb, yb)));
output_snowflake.push_back(Line(Vertex(xb, yb), Vertex(xc, yc)));
output_snowflake.push_back(Line(Vertex(xc, yc), Vertex(x1, y1)));
}
return output_snowflake;
}
//! Draw the snowflake using lines.
void draw_snowflake(const std::vector<Line> &input_snowflake)
{
for (const auto &line : input_snowflake)
{
sdl::render_line(line.first.first, line.first.second,
line.second.first, line.second.second,
0, 0, 0);
}
}
int main()
{
// Init the SDL system.
sdl::init(800, 600);
// === Create a snowflake ===
const int snowflake_depth = 5;
const int num_sides = 3;
std::vector<Line> snowflake;
for (int i=0; i<num_sides; ++i)
{
const int x0 = 250.0 * cos(-((i+0)*2.0*M_PI)/num_sides) + 400.5;
const int y0 = 250.0 * sin(-((i+0)*2.0*M_PI)/num_sides) + 300.5;
const int x1 = 250.0 * cos(-((i+1)*2.0*M_PI)/num_sides) + 400.5;
const int y1 = 250.0 * sin(-((i+1)*2.0*M_PI)/num_sides) + 300.5;
snowflake.push_back(Line(Vertex(x0, y0), Vertex(x1, y1)));
}
for (int i=0; i<snowflake_depth; ++i)
{
snowflake = grow_koch_snowflake(snowflake);
}
// ==========================
// === SDL event loop ===
bool quits = false;
SDL_Event es;
while( !quits )
{
// Clear buffer to white.
sdl::clear_buffer();
// Draw the snowflake using lines.
draw_snowflake(snowflake);
// Update the display with the snowflake
sdl::update_display();
while( SDL_PollEvent( &es ) != 0 )
{
if( es.type == SDL_QUIT )
{
quits = true;
}
}
SDL_Delay(10);
}
sdl::quit();
}
| 27.785714 | 86 | 0.541131 | bduvenhage |
e29ed02de4ad3f403c946707012cff195fa80cdc | 3,714 | cpp | C++ | src/common/containers/trie-pool.cpp | asgerfv/ai_boggle | 7ea541124296e730d10e64de0a7038090a876bb5 | [
"MIT"
] | null | null | null | src/common/containers/trie-pool.cpp | asgerfv/ai_boggle | 7ea541124296e730d10e64de0a7038090a876bb5 | [
"MIT"
] | null | null | null | src/common/containers/trie-pool.cpp | asgerfv/ai_boggle | 7ea541124296e730d10e64de0a7038090a876bb5 | [
"MIT"
] | null | null | null | #include "trie-pool.hpp"
// ----------------------------------------------------------------------------
#define ROTA_USE_CUSTOM_ALLOCATOR 1
// ----------------------------------------------------------------------------
/// Note: Could also have used "__declspec(selectany)" in the header, but this is
/// more cross-platform.
#if defined(_DEBUG)
int32_t common::CTriePool::s_instanceCount = 0;
#endif
// ----------------------------------------------------------------------------
namespace common
{
namespace details
{
class CTriePoolAllocator
{
public:
CTriePoolAllocator();
~CTriePoolAllocator();
CTriePool::Index_t AllocateTrie(CTriePool::Index_t parent);
void FreeAll();
CTriePool* GetPtrFromIndex(const CTriePool::Index_t index);
CTriePool::Index_t GetIndexFromPtr(const CTriePool*);
private:
static const size_t C_SSE_ALIGNMENT = 16;
static const size_t C_TRIE_SIZE = common::AlignUpTo(sizeof(CTriePool), C_SSE_ALIGNMENT);
static const size_t C_PREALLOCATED_INSTANCE_COUNT = 600 * 1000;
uint8_t* m_pMem = nullptr;
uint8_t* m_pAlignedMem = nullptr;
uint32_t m_freeCount = C_PREALLOCATED_INSTANCE_COUNT;
uint32_t m_instanceCount = 1;
};
}
}
// ----------------------------------------------------------------------------
static common::details::CTriePoolAllocator* g_pTrieAllocator = nullptr;
// ----------------------------------------------------------------------------
common::details::CTriePoolAllocator::CTriePoolAllocator()
{
m_pMem = new uint8_t[(C_PREALLOCATED_INSTANCE_COUNT * C_TRIE_SIZE) + C_CACHE_SIZE];
m_pAlignedMem = common::AlignUpToPtr(m_pMem, C_CACHE_SIZE);
}
common::details::CTriePoolAllocator::~CTriePoolAllocator()
{
FreeAll();
}
common::CTriePool::Index_t common::details::CTriePoolAllocator::AllocateTrie(CTriePool::Index_t parent)
{
const uint32_t indexToUse = m_instanceCount;
assert(indexToUse < C_PREALLOCATED_INSTANCE_COUNT);
void* pMemForTrie = &m_pAlignedMem[indexToUse * C_TRIE_SIZE];
m_instanceCount++;
new (pMemForTrie) CTriePool(parent);
return indexToUse;
}
void common::details::CTriePoolAllocator::FreeAll()
{
delete [] m_pMem;
m_pMem = nullptr;
}
common::CTriePool* common::details::CTriePoolAllocator::GetPtrFromIndex(const CTriePool::Index_t index)
{
void* pMemForTrie = &m_pAlignedMem[index * C_TRIE_SIZE];
return reinterpret_cast<common::CTriePool*>(pMemForTrie);
}
common::CTriePool::Index_t common::details::CTriePoolAllocator::GetIndexFromPtr(const CTriePool* pTrie)
{
const uintptr_t diff = uintptr_t(pTrie) - uintptr_t(m_pAlignedMem);
const CTriePool::Index_t result = static_cast<CTriePool::Index_t>(diff / C_TRIE_SIZE);
return result;
}
// ----------------------------------------------------------------------------
common::CTriePool::Index_t common::details::AllocateTrie(const CTriePool::Index_t parent)
{
return g_pTrieAllocator->AllocateTrie(parent);
}
common::CTriePool* common::details::GetPtrFromIndex(CTriePool::Index_t index)
{
return g_pTrieAllocator->GetPtrFromIndex(index);
}
common::CTriePool::Index_t common::details::GetIndexFromPtr(CTriePool* pTrie)
{
return g_pTrieAllocator->GetIndexFromPtr(pTrie);
}
// ----------------------------------------------------------------------------
void common::CTriePool::InitializePool()
{
g_pTrieAllocator = new details::CTriePoolAllocator();
}
void common::CTriePool::ClearAllTries()
{
delete g_pTrieAllocator;
g_pTrieAllocator = nullptr;
}
| 24.27451 | 104 | 0.600969 | asgerfv |
e2a1546692645f661d2b57fc2aec06b24dbdc63a | 247 | cpp | C++ | SDLEngine/SDLEngine/SDLEngine/src/Collision.cpp | AyushNathJha007/SDLEngine | ef779884fac9e72c038387f976c6e75eb2dd4187 | [
"MIT"
] | 1 | 2021-03-23T06:15:30.000Z | 2021-03-23T06:15:30.000Z | SDLEngine/SDLEngine/SDLEngine/src/Collision.cpp | AyushNathJha007/SDLEngine | ef779884fac9e72c038387f976c6e75eb2dd4187 | [
"MIT"
] | null | null | null | SDLEngine/SDLEngine/SDLEngine/src/Collision.cpp | AyushNathJha007/SDLEngine | ef779884fac9e72c038387f976c6e75eb2dd4187 | [
"MIT"
] | null | null | null |
#include "Collision.h"
bool Collision::CheckCollisonAABB(const SDL_Rect & RectA, const SDL_Rect & RectB)
{
return (RectA.x + RectA.w >= RectB.x && RectB.x + RectB.w >= RectA.x && RectA.y + RectA.h >= RectB.y && RectB.y + RectB.h >= RectA.y);
}
| 30.875 | 135 | 0.651822 | AyushNathJha007 |
e2a1b19379e49506277b71c350e108a2b1c638b2 | 1,320 | cpp | C++ | test/pprm_irs_integration_test.cpp | elishafer/mpt | e0997259fbd1431bab4b5ffb6f0d2f00fa380660 | [
"BSD-3-Clause"
] | 54 | 2018-09-28T17:28:02.000Z | 2022-01-25T20:30:32.000Z | test/pprm_irs_integration_test.cpp | elishafer/mpt | e0997259fbd1431bab4b5ffb6f0d2f00fa380660 | [
"BSD-3-Clause"
] | 2 | 2019-11-21T20:16:26.000Z | 2020-03-27T12:55:31.000Z | test/pprm_irs_integration_test.cpp | elishafer/mpt | e0997259fbd1431bab4b5ffb6f0d2f00fa380660 | [
"BSD-3-Clause"
] | 27 | 2019-05-15T00:18:46.000Z | 2021-07-30T00:41:37.000Z | #define MPT_LOG_LEVEL WARN
#include "planner_integration_test.hpp"
#include <mpt/pprm_irs.hpp>
#include <nigh/gnat.hpp>
#include <nigh/linear.hpp>
using namespace unc::robotics;
using namespace mpt;
using namespace mpt_test;
TEST(pprm_irs_until_solved) {
testSolvingBasicScenario<PPRMIRS<>>();
}
TEST(pprm_irs_until_solved_with_stats) {
testSolvingBasicScenario<PPRMIRS<report_stats<true>>>();
}
TEST(pprm_irs_until_solved_single_threaded) {
testSolvingBasicScenario<PPRMIRS<single_threaded>>();
}
TEST(pprm_irs_until_solved_with_gnat) {
testSolvingBasicScenario<PPRMIRS<nigh::GNAT<>>>();
}
TEST(pprm_irs_until_solved_with_linear) {
testSolvingBasicScenario<PPRMIRS<nigh::Linear>>();
}
TEST(pprm_irs_options_parser) {
// The options parser should resolve the following two planners to
// the same concrete type.
using Scenario = BasicScenario<>;
using A = mpt::Planner<Scenario, PPRMIRS<nigh::Linear, single_threaded, report_stats<true>>>;
using B = mpt::Planner<Scenario, PPRMIRS<single_threaded, report_stats<true>, nigh::Linear>>;
EXPECT((std::is_same_v<A, B>)) == true;
}
TEST(pprm_irs_with_trajectory) {
testSolvingTrajectoryScenario<PPRMIRS<>>();
}
#if 0
TEST(pprm_irs_with_shared_trajectory) {
testSolvingSharedTrajectoryScenario<PPRMIRS<>>();
}
#endif
| 27.5 | 97 | 0.758333 | elishafer |
e2a7eb02618e1146d3dcc4face2b43a79ee039dd | 706 | cpp | C++ | examples/keyboard_example.cpp | yamaha-bps/cbr_drivers | 64e971c0a7e79c414e81fe2ac32e6360adb266eb | [
"MIT"
] | null | null | null | examples/keyboard_example.cpp | yamaha-bps/cbr_drivers | 64e971c0a7e79c414e81fe2ac32e6360adb266eb | [
"MIT"
] | null | null | null | examples/keyboard_example.cpp | yamaha-bps/cbr_drivers | 64e971c0a7e79c414e81fe2ac32e6360adb266eb | [
"MIT"
] | null | null | null | // Copyright Yamaha 2021
// MIT License
// https://github.com/yamaha-bps/cbr_drivers/blob/master/LICENSE
#include <cbr_drivers/keyboard.hpp>
#include <thread>
#include <chrono>
#include <iostream>
int main(int argc, char ** argv)
{
if (argc != 2) {
std::cerr << "usage: keyboard_example <device>" << std::endl;
exit(EXIT_FAILURE);
}
cbr::Keyboard keyboard(argv[1]);
for (auto i = 0u; i < 500; ++i) {
std::this_thread::sleep_for(std::chrono::milliseconds(50));
std::cout << std::endl << "W: " << keyboard.getKeyState(KEY_W) << " A: " <<
keyboard.getKeyState(KEY_A) <<
" S: " << keyboard.getKeyState(KEY_S) << " D: " << keyboard.getKeyState(KEY_D) << std::endl;
}
}
| 27.153846 | 98 | 0.626062 | yamaha-bps |
e2ab3dfaa11c7ab8c72a35523b37b1b5fedf4220 | 19,759 | cpp | C++ | src/core/impl/StdPlayQueue.cpp | varunamachi/tanyatu | ce055e0fb0b688054fe19ef39b09a6ca655e2457 | [
"MIT"
] | 1 | 2018-01-07T18:11:04.000Z | 2018-01-07T18:11:04.000Z | src/core/impl/StdPlayQueue.cpp | varunamachi/tanyatu | ce055e0fb0b688054fe19ef39b09a6ca655e2457 | [
"MIT"
] | null | null | null | src/core/impl/StdPlayQueue.cpp | varunamachi/tanyatu | ce055e0fb0b688054fe19ef39b09a6ca655e2457 | [
"MIT"
] | null | null | null | /*******************************************************************************
* Copyright (c) 2014 Varuna L Amachi. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
******************************************************************************/
#include <QSize>
#include <QFont>
#include <QAbstractItemModel>
#include <QTime>
#include <QtAlgorithms>
#include "StdPlayQueue.h"
#include "../data/AudioTrack.h"
#include "../data/VideoTrack.h"
#include "../data/MediaItem.h"
#include "../coreutils/Utils.h"
#include "../interfaces/IComponent.h"
#define RANDOM_STOP_PERCENTAGE 80
#define PREV_LIST_REMOVE_THRESHOLD 100
namespace Tanyatu { namespace Impl {
StdPlayQueue::StdPlayQueue( QObject *parent )
: IPlayQueue( parent )
, m_currentIndex( -1 )
, m_prevListIndex( -1 )
, m_random( false )
, m_repeatType( IPlayQueue::RepeatType_RepeatAll )
{
}
void StdPlayQueue::addItem( const Tanyatu::Data::MediaItem *c_item,
bool selected )
{
Data::MediaItem *item = const_cast< Data::MediaItem *>( c_item );
if( item ) {
emit aboutToChangePlayQueue();
m_items.append( item );
m_unplayedIds.insert( item->trackId() );
emit itemAdded( item );
if( selected ) {
selectIndex( m_items.size() - 1 );
}
emit playQueueChanged();
}
}
void StdPlayQueue::addItems(
const QList< Tanyatu::Data::MediaItem *> &items )
{
if( ! items.empty() ) {
emit aboutToChangePlayQueue();
for( int i = 0; i < items.size(); ++i ) {
Data::MediaItem *item = items.at( i );
m_items.append( item );
m_unplayedIds.insert( item->trackId() );
emit itemAdded( item );
}
emit playQueueChanged();
}
}
void StdPlayQueue::removeItem( const QString itemId )
{
QList< int > indices;
getAllIndicesOf( itemId, indices );
if( ! indices.isEmpty() ) {
removeItems( indices );
}
}
void StdPlayQueue::removeItem( const Tanyatu::Data::MediaItem *item )
{
QList< int > indices;
getAllIndicesOf( item->trackId(), indices );
if( ! indices.isEmpty() ) {
removeItems( indices );
}
}
void StdPlayQueue::removeItem( int index )
{
QList< int > solo;
solo << index;
removeItems( solo );
}
void StdPlayQueue::removeItems(
const QList< Tanyatu::Data::MediaItem * > &items )
{
QList< int > indices;
foreach( Data::MediaItem *item, items ) {
getAllIndicesOf( item->trackId(), indices );
}
if( ! indices.isEmpty() ) {
removeItems( indices );
}
}
void StdPlayQueue::removeItems( int fromIndex, int toIndex )
{
if( fromIndex > toIndex ) {
QList< int > indices;
for( int i = fromIndex; i < toIndex; ++i ) {
indices.append( i );
}
removeItems( indices );
}
}
void StdPlayQueue::removeItems( QList< int > &indices )
{
/* We have to delete the items which are being deleted from the playlist
* which are persisted items */
QList< Data::MediaItem * > deletionCandidates;
bool currentIndexChanged = false;
// bool plChanged = false;
qSort( indices );
emit aboutToChangePlayQueue();
for( int i = indices.size() - 1; i >= 0; -- i ) {
int index = indices.at( i );
if( isValidIndex( index ) ) {
//Notify the removal to the view
Data::MediaItem *delItem = m_items.at( index );
if( m_items.size() == 1 ) {
//If the there is only one item, then clear the list
emit clearingPlayQueue();
emit removingSelectedItem();
emit removingItem( delItem, index );
deletionCandidates.append( delItem );
m_items.removeAt( index );
emit removedItem( delItem, index);
m_currentIndex = -1;
break;
currentIndexChanged = true;
// plChanged = true;
}
else if( index > m_currentIndex ) {
/* If the index for removal is more than the current selected
* index then we are relieved since the removal wont affect the
* currently selected index
*/
emit removingItem( delItem, index );
deletionCandidates.append( delItem );
m_items.removeAt( index );
emit removedItem( delItem, index);
// plChanged = true;
}
else if ( index == m_currentIndex ) {
int oldCurIndex = m_currentIndex;
/* If we are removing the current item, we should notify it,
* since player may be using it and we hope it will handle this
* situaltion properly.
*/
emit removingSelectedItem();
emit removingItem( delItem, index );
/* Since current item is no more, we set it to invalid. Later we
* will select the next one
*/
m_currentIndex = -1;
emit indexOfCurrentChanged( m_currentIndex, oldCurIndex );
m_items.removeAt( index );
deletionCandidates.append( delItem );
emit removedItem( delItem, index );
currentIndexChanged = true;
// plChanged = true;
}
else if( index < m_currentIndex ) {
/* If we are removing an item before the current one, the index
* of the current item needs to be adjusted - decremented.
*/
-- m_currentIndex;
emit indexOfCurrentChanged( m_currentIndex, m_currentIndex +1 );
emit removingItem( delItem, index );
deletionCandidates.append( delItem );
m_items.removeAt( index );
emit removedItem( delItem, index );
// plChanged = true;
currentIndexChanged = true;
}
}
}
if( currentIndexChanged ) {
if( m_currentIndex == -1 ) {
selectNext();
}
}
/*
* Update the internal structures: clear the previously played items and
* if the player is currently in random play mode then remove the track
* from unplayed ids.
* Deallocate the items for which playlist is the owner. The
* PersistedItems are owned by the media library and shall not be
* deallocated here
*/
m_prevIndicesList.clear();
for( int i = 0; i < deletionCandidates.size(); ++i) {
Data::MediaItem *item = deletionCandidates.at( i );
if( m_random ) {
m_unplayedIds.remove( item->trackId() );
}
if( item->type() != Data::Media_StoredAudio
&& item->type() != Data::Media_StoredVideo) {
delete item;
}
}
// if( plChanged ) {
emit playQueueChanged();
// }
}
void StdPlayQueue::clearAllStoredItems()
{
bool atleastOneRemoved = false;
emit aboutToChangePlayQueue();
for( int i = m_items.size() - 1; i >= 0; --i ) {
Data::MediaItem *item = m_items.at( i );
if( item->type() == Data::Media_StoredAudio
|| item->type() == Data::Media_StoredVideo ) {
if( ! atleastOneRemoved ) {
atleastOneRemoved = true;
emit clearingPlayQueue();
}
m_items.removeAt( i );
m_unplayedIds.remove( item->trackId() );
}
}
if( atleastOneRemoved ) {
m_prevIndicesList.clear();
if( m_items.isEmpty() ) {
m_currentIndex = -1;
m_prevListIndex = -1;
emit playQueueCleared();
}
else {
}
}
emit playQueueChanged();
}
void StdPlayQueue::clear()
{
emit clearingPlayQueue();
emit aboutToChangePlayQueue();
for(int i = 0; i < m_items.size(); ++ i) {
Data::MediaItem *item = m_items.at( i );
if( ! ( item->type() == Data::Media_StoredAudio
|| item->type() == Data::Media_StoredVideo )) {
//Delete item which is not owned by 'this'
delete item;
}
}
m_items.clear();
m_unplayedIds.clear();
m_prevIndicesList.clear();
m_currentIndex = -1;
m_prevListIndex = -1;
emit playQueueChanged();
emit playQueueCleared();
}
void StdPlayQueue::selectNext()
{
int selectedIndex = 0;
if( ! m_prevIndicesList.isEmpty()
&& m_prevListIndex >= 0
&& m_prevListIndex < m_prevIndicesList.size() - 1 ) {
m_prevListIndex = m_prevListIndex > m_prevIndicesList.size() - 1
? m_prevIndicesList.size() - 1
: m_prevListIndex;
/**
* If we are down the previously played track and we are trieng to
* select the next track, this track will the next index present in
* the previously played indices list and not a new track.
*/
selectedIndex = m_prevIndicesList.at( m_prevListIndex );
++ m_prevListIndex;
}
else if( m_random ) {
selectedIndex = getRandomIndex();
}
/* If random is not selected then we check if next is available if yes we
* have few conditions to check for, if not availabel notify that playlist
* finished
*/
else if( hasNext() ) {
if( m_currentIndex == m_items.size() - 1
&& m_repeatType == IPlayQueue::RepeatType_RepeatAll) {
//Start all over again
selectedIndex = 0;
}
else if( m_repeatType == IPlayQueue::RepeatType_RepeatOne ) {
selectedIndex = m_currentIndex;
}
else {
selectedIndex = m_currentIndex + 1;
}
}
else {
emit playQueueConfigChanged();
emit finished();
return;
}
//And if it is selected, it's no longer unplayed
m_unplayedIds.remove( m_items.at( selectedIndex )->trackId() );
addToPrevList( selectedIndex );
m_currentIndex = selectedIndex;
emit itemSelected( m_items.at( m_currentIndex ), m_currentIndex );
/*
* Although playlist contents themself didn't change, the state of the
* playlist has changed
*/
emit playQueueConfigChanged();
}
void StdPlayQueue::selectPrevious()
{
if( m_items.isEmpty() )
{
m_currentIndex = -1;
return;
}
int selectedIndex = 0;
if( ! m_prevIndicesList.isEmpty() && m_prevListIndex != 0 ) {
-- m_prevListIndex;
m_prevListIndex = m_prevListIndex > m_prevIndicesList.size() - 1
? m_prevIndicesList.size() - 1
: m_prevListIndex;
selectedIndex = m_prevIndicesList.at( m_prevListIndex );
m_unplayedIds.remove( m_items.at( selectedIndex )->trackId() );
}
else if( m_prevIndicesList.isEmpty() )
{
selectedIndex = m_currentIndex == 0 ? m_items.size() - 1
: m_currentIndex - 1;
}
else {
if( m_random ) {
//If its random doesn't matter if it is next or previous
selectedIndex = getRandomIndex();
m_unplayedIds.remove( m_items.at( selectedIndex )->trackId() );
addToPrevList( selectedIndex );
}
else if( m_repeatType == IPlayQueue::RepeatType_RepeatAll ) {
selectedIndex = m_currentIndex == 0 ? ( m_items.size() - 1 )
: ( m_currentIndex - 1 );
}
else if( m_repeatType == IPlayQueue::RepeatType_RepeatOne ) {
//Play it again and again
selectedIndex = m_currentIndex;
}
else if( m_currentIndex != 0 ) {
//Decrement to go behind
selectedIndex = m_currentIndex - 1;
}
else {
//Ok done walking backwords
emit playQueueConfigChanged();
emit finished();
return;
}
}
m_currentIndex = selectedIndex;
emit itemSelected( m_items.at( m_currentIndex ), m_currentIndex );
/*
* Although playlist contents themself didn't change, the state of the
* playlist has changed
*/
emit playQueueConfigChanged();
}
void StdPlayQueue::selectIndex( int index )
{
if( isValidIndex( index ) ) {
Data::MediaItem *item = m_items.at( index );
m_unplayedIds.remove( item->trackId() );
m_prevIndicesList.append( index );
++ m_prevListIndex;
m_currentIndex = index;
emit itemSelected( item, m_currentIndex );
emit playQueueConfigChanged();
}
}
void StdPlayQueue::insert(
int index,
const QList< Tanyatu::Data::MediaItem * > &items )
{
emit aboutToChangePlayQueue();
foreach( Data::MediaItem *item, items ) {
m_items.insert( index, item );
m_unplayedIds.insert( item->trackId() );
}
//Clear the prev played list since updating it costly
m_prevIndicesList.clear();
emit playQueueChanged();
}
void StdPlayQueue::moveItem( int origIndex, int newIndex, int numItems )
{
if( origIndex >= 0 && origIndex < m_items.size()
&& newIndex >=0 && newIndex < m_items.size()
&& newIndex != origIndex )
{
emit aboutToChangePlayQueue();
for( int index = origIndex;
index < ( origIndex +numItems );
++ index ) {
Data::MediaItem *item = m_items.at( index );
m_items.move( index, newIndex );
++ newIndex;
emit itemMoved( item, index, newIndex );
if( index == m_currentIndex ) {
emit indexOfCurrentChanged( newIndex, index );
}
}
m_prevIndicesList.clear();
emit playQueueChanged();
}
}
void StdPlayQueue::setRandom( bool value )
{
m_random = value;
m_unplayedIds.clear();
m_prevIndicesList.clear();
m_prevListIndex = -1;
emit playQueueConfigChanged();
}
void StdPlayQueue::setRepeat(
Tanyatu::IPlayQueue::RepeatType repeatType)
{
m_repeatType = repeatType;
emit playQueueConfigChanged();
}
Data::MediaItem* StdPlayQueue::current() const
{
return m_items.at( m_currentIndex );
}
int StdPlayQueue::currentIndex() const
{
return m_currentIndex;
}
bool StdPlayQueue::hasNext() const
{
if( m_items.isEmpty() || m_currentIndex == -1 ) {
return false;
}
else if( m_repeatType == IPlayQueue::RepeatType_NoRepeat
&& m_currentIndex == m_items.size() - 1)
{
return false;
}
return true;
}
bool StdPlayQueue::hasPrev() const
{
bool result = true;
if( m_items.isEmpty() || m_currentIndex == -1 || m_prevListIndex == -1) {
result = false;
}
else if( m_random && m_prevIndicesList.isEmpty() )
{
result = false;
}
return result;
}
int StdPlayQueue::numberOfItems() const
{
return m_items.size();
}
bool StdPlayQueue::isRandom() const
{
return m_random;
}
IPlayQueue::RepeatType StdPlayQueue::repeatType() const
{
return m_repeatType;
}
const QList<Data::MediaItem *> *StdPlayQueue::getAllItemsInOrder() const
{
return &m_items;
}
void StdPlayQueue::addToPrevList( int index )
{
m_prevIndicesList.append( index );
//Always point to the most recently played
m_prevListIndex = m_prevIndicesList.size() - 1;
if( m_prevIndicesList.size() > PREV_LIST_REMOVE_THRESHOLD ) {
m_prevIndicesList.removeFirst();
}
}
int StdPlayQueue::getRandomIndex()
{
int selectedIndex = 0;
if( m_unplayedIds.empty() ) {
//We dont have nothing unplayed now... replenish
for( int i = 0; i < m_items.size(); ++ i ) {
m_unplayedIds.insert( m_items.at( i )->trackId() );
}
return selectedIndex;
}
//findout the percentage of tracks that are already played
int usedPc = static_cast< int >(
( m_items.size() - m_unplayedIds.size() )
/ m_items.size()
* 100);
if( usedPc > RANDOM_STOP_PERCENTAGE ) {
/**
* If 80pc of the tracks are already played, there is no point in
* generating random numbers. So we iterate through the item list
* and play the first available unplayed track
*/
for( int index = 0; index < m_items.size(); ++ index) {
Data::MediaItem *item = m_items.at( index );
if( m_unplayedIds.contains( item->trackId() )) {
selectedIndex = index;
break;
}
}
}
else {
/**
* If we have got more than 20pc tracks unplayed, we generate
* random number and see the generated index is unplayed, if yes
* then select it, otherwise generate a new random number
*/
int indexCandidate = qrand() % m_items.size();
while( ! m_unplayedIds.contains(
m_items.at( indexCandidate )->trackId() )) {
indexCandidate = qrand() % m_items.size();
}
selectedIndex = indexCandidate;
}
return selectedIndex;
}
void StdPlayQueue::getAllIndicesOf( QString itemId,
QList<int> &indices ) const
{
for( int index = 0; index < m_items.size(); ++ index ) {
if ( m_items[ index ]->trackId() == itemId ) {
indices.append( index );
}
}
}
QString StdPlayQueue::uniqueName() const
{
return "StdPlayQueue";
}
QString StdPlayQueue::module() const
{
return "Tanyatu::Core::StandrdComponents";
}
QString StdPlayQueue::displayName() const
{
return "Playlist";
}
bool StdPlayQueue::init()
{
/**
* @todo May be we can load the tracks loaded in the previous session here
*/
return true;
}
bool StdPlayQueue::isValidIndex(int index) const
{
return index >= 0 && index < m_items.size();
}
} } //end of ns
| 30.921753 | 81 | 0.557974 | varunamachi |
e2af05453b217872a1efe228e70abdbbdee2d7c8 | 4,892 | cpp | C++ | csvfix/src/csved_fmerge.cpp | moissinac/csvfix | 06cd5638e3a3bb0049fb7138c72211aef972c8d4 | [
"MIT"
] | 4 | 2022-01-25T15:54:29.000Z | 2022-03-18T21:32:16.000Z | csvfix/src/csved_fmerge.cpp | moissinac/csvfix | 06cd5638e3a3bb0049fb7138c72211aef972c8d4 | [
"MIT"
] | 1 | 2022-02-08T12:37:47.000Z | 2022-02-08T12:37:47.000Z | csvfix/src/csved_fmerge.cpp | moissinac/csvfix | 06cd5638e3a3bb0049fb7138c72211aef972c8d4 | [
"MIT"
] | 5 | 2021-12-14T05:42:52.000Z | 2022-03-11T04:23:47.000Z | //---------------------------------------------------------------------------
// csved_fmerge.cpp
//
// merge multiple sorted csv files
//
// Copyright (C) 20011 Neil Butterworth
//---------------------------------------------------------------------------
#include "a_base.h"
#include "a_collect.h"
#include "csved_cli.h"
#include "csved_fmerge.h"
#include "csved_strings.h"
#include <string>
#include <vector>
#include <memory>
using std::string;
namespace CSVED {
//---------------------------------------------------------------------------
// Register fmerge command
//---------------------------------------------------------------------------
static RegisterCommand <FMergeCommand> rc1_(
CMD_FMERGE,
"merge multiple sorted CSV files"
);
//----------------------------------------------------------------------------
// Help
//----------------------------------------------------------------------------
const char * const FMERGE_HELP = {
"merge multiple sorted CSV files into single output\n"
"usage: csvfix fmerge [flags] file ...\n"
"where flags are:\n"
" -f fields\tfields to compare when merging (default all)\n"
"#ALL"
};
//----------------------------------------------------------------------------
// The fmerge command
//----------------------------------------------------------------------------
FMergeCommand :: FMergeCommand( const string & name, const string & desc )
: Command( name, desc, FMERGE_HELP ) {
AddFlag( ALib::CommandLineFlag( FLAG_COLS, false, 1 ) );
}
//----------------------------------------------------------------------------
// Exec the command, merging all inputs into a single output.
//----------------------------------------------------------------------------
int FMergeCommand :: Execute( ALib::CommandLine & cmd ) {
ProcessFlags( cmd );
IOManager io( cmd );
MinFinder mf( io, mFields );
CSVRow row;
while( mf.FindMin( row ) ) {
io.WriteRow( row );
}
return 0;
}
//----------------------------------------------------------------------------
// Get command line options
//----------------------------------------------------------------------------
void FMergeCommand :: ProcessFlags( ALib::CommandLine & cmd ) {
if ( cmd.HasFlag( FLAG_COLS ) ) {
ALib::CommaList cl( cmd.GetValue( FLAG_COLS ) );
CommaListToIndex( cl, mFields );
}
}
//----------------------------------------------------------------------------
// Create row getters for all input sources
//----------------------------------------------------------------------------
MinFinder :: MinFinder( IOManager & io, const FieldList & f ) : mFields( f ){
for ( unsigned int i = 0; i < io.InStreamCount(); i++ ) {
mGetters.push_back( new RowGetter( io.CreateStreamParser( i ) ));
}
}
//----------------------------------------------------------------------------
// Delete all row getters
//----------------------------------------------------------------------------
MinFinder :: ~MinFinder() {
for ( unsigned int i = 0; i < mGetters.size(); i++ ) {
delete mGetters[ i ];
}
}
//----------------------------------------------------------------------------
// Find least row and return it
//----------------------------------------------------------------------------
bool MinFinder :: FindMin( CSVRow & rmin ) {
CSVRow row;
int gi = -1;
for ( unsigned int i = 0; i < mGetters.size(); i++ ) {
bool ok = mGetters[i]->Get( row );
if ( ok ) {
if ( gi == -1 || CmpRow( row, rmin, mFields ) < 1 ) {
rmin = row;
gi = i;
}
}
}
if ( gi >= 0 ) {
mGetters[gi]->ClearLatch();
}
return gi >= 0;
}
//----------------------------------------------------------------------------
// Getter encapsulates astream parser and a latched input row
//----------------------------------------------------------------------------
RowGetter :: RowGetter( ALib::CSVStreamParser * p )
: mParser( p ), mDone( false ), mHave( false ) {
}
RowGetter :: ~RowGetter() {
delete mParser;
}
//----------------------------------------------------------------------------
// If there is anything in the latch, return that, else try to get a row
// and return that.
//----------------------------------------------------------------------------
bool RowGetter :: Get( CSVRow & row ) {
if ( mHave ) {
row = mLatch;
return true;
}
else {
mDone = ! mParser->ParseNext( mLatch );
mHave = ! mDone;
row = mLatch;
return mHave;
}
}
//----------------------------------------------------------------------------
// Clear the latch - used if we have located the least row.
//----------------------------------------------------------------------------
void RowGetter :: ClearLatch() {
mHave = false;
}
} // namespace
| 26.879121 | 79 | 0.370196 | moissinac |
e2b91deab820a163ea6533cda2728508541ec8c7 | 402 | cpp | C++ | protocol_lib/ServiceDelegate.cpp | ThoughtWorksIoTGurgaon/nodes | 2973a331b744c7f2abd412b0e0e760f6111ce687 | [
"Apache-2.0"
] | null | null | null | protocol_lib/ServiceDelegate.cpp | ThoughtWorksIoTGurgaon/nodes | 2973a331b744c7f2abd412b0e0e760f6111ce687 | [
"Apache-2.0"
] | 1 | 2015-09-24T02:11:17.000Z | 2015-09-24T02:11:17.000Z | protocol_lib/ServiceDelegate.cpp | ThoughtWorksIoTGurgaon/nodes | 2973a331b744c7f2abd412b0e0e760f6111ce687 | [
"Apache-2.0"
] | null | null | null | /*
* File: ServiceDelegate.cpp
* Author: Anuj
*
* Created on 29 November, 2015, 10:13 AM
*/
#include "ServiceDelegate.h"
ServiceDelegate::ServiceDelegate() {
}
void ServiceDelegate::didWriteToCharacteristic(char id, int len, char * value) {}
void ServiceDelegate::didReadFromCharacteristic(char id, int len, char * value) {}
void ServiceDelegate::didCompleteWritingToCharacteristics() {}
| 23.647059 | 82 | 0.738806 | ThoughtWorksIoTGurgaon |
e2ba4a8bd05cb9fca6d510aa2b05975d4cfc3e42 | 342 | cc | C++ | src/ast/literals.cc | anurudhp/decaf-compiler | 67a72bb9cf77d46515165074c2ca8786738b02e6 | [
"MIT"
] | null | null | null | src/ast/literals.cc | anurudhp/decaf-compiler | 67a72bb9cf77d46515165074c2ca8786738b02e6 | [
"MIT"
] | null | null | null | src/ast/literals.cc | anurudhp/decaf-compiler | 67a72bb9cf77d46515165074c2ca8786738b02e6 | [
"MIT"
] | null | null | null | #include "literals.hh"
#include "../visitors/visitor.hh"
#include "variables.hh"
void LiteralAST::accept(ASTvisitor &V) { V.visit(*this); }
void IntegerLiteralAST::accept(ASTvisitor &V) { V.visit(*this); }
void BooleanLiteralAST::accept(ASTvisitor &V) { V.visit(*this); }
void StringLiteralAST::accept(ASTvisitor &V) { V.visit(*this); }
| 26.307692 | 65 | 0.710526 | anurudhp |
e2c5da21e0c4be2c2cdde04b62a614c9b5c97567 | 605 | cpp | C++ | Game/Source/Boss.cpp | BooStarGamer/Makers-Vs-Players-v2 | db7f32e978f682e55f9d2542ac5879f7137e40ff | [
"MIT"
] | null | null | null | Game/Source/Boss.cpp | BooStarGamer/Makers-Vs-Players-v2 | db7f32e978f682e55f9d2542ac5879f7137e40ff | [
"MIT"
] | null | null | null | Game/Source/Boss.cpp | BooStarGamer/Makers-Vs-Players-v2 | db7f32e978f682e55f9d2542ac5879f7137e40ff | [
"MIT"
] | null | null | null | #include "Boss.h"
#include "App.h"
#include "Textures.h"
Boss::Boss() : Entity(EntityType::BOSS)
{
}
Boss::Boss(BossClass bClass) : Entity(EntityType::BOSS)
{
bossClass = bClass;
// LIFE -> ((x / 1.5) + 20)
// STRG -> ((x / 2) + 8)
// DEFS -> ((x / 4) + 2) nose
// EXPR -> expActLvl + expNextLvl / 2
}
Boss::~Boss()
{
}
void Boss::SetUp(SDL_Rect combatCollider, int xexp, int xhealth, int xstrength, int xdefense)
{
colliderCombat = combatCollider;
exp = xexp;
health = xhealth;
maxHealth = xhealth;
strength = xstrength;
defense = xdefense;
}
void Boss::Refill()
{
health = maxHealth;
}
| 16.805556 | 93 | 0.634711 | BooStarGamer |
e2c6d4dcf2ef538a5ee27808e7c3a82e63a97086 | 20,493 | cxx | C++ | resip/stack/Contents.cxx | dulton/reSipServer | ac4241df81c1e3eef2e678271ffef4dda1fc6747 | [
"Apache-2.0"
] | 1 | 2019-04-15T14:10:58.000Z | 2019-04-15T14:10:58.000Z | resip/stack/Contents.cxx | dulton/reSipServer | ac4241df81c1e3eef2e678271ffef4dda1fc6747 | [
"Apache-2.0"
] | null | null | null | resip/stack/Contents.cxx | dulton/reSipServer | ac4241df81c1e3eef2e678271ffef4dda1fc6747 | [
"Apache-2.0"
] | 2 | 2019-10-31T09:11:09.000Z | 2021-09-17T01:00:49.000Z | #include <vector>
#if defined(HAVE_CONFIG_H)
#include "config.h"
#endif
#include "resip/stack/Contents.hxx"
#include "rutil/ParseBuffer.hxx"
#include "rutil/Logger.hxx"
#include "resip/stack/OctetContents.hxx"
#include "rutil/MD5Stream.hxx"
#include "rutil/WinLeakCheck.hxx"
using namespace resip;
using namespace std;
#define RESIPROCATE_SUBSYSTEM Subsystem::CONTENTS
H_ContentID resip::h_ContentID;
H_ContentDescription resip::h_ContentDescription;
Contents::Contents(const HeaderFieldValue& headerFieldValue,
const Mime& contentType)
: LazyParser(headerFieldValue),
mType(contentType)
{
init();
}
Contents::Contents(const Mime& contentType)
: mType(contentType)
{
init();
}
Contents::Contents(const Contents& rhs)
: LazyParser(rhs)
{
init(rhs);
}
Contents::Contents(const Contents& rhs,HeaderFieldValue::CopyPaddingEnum e)
: LazyParser(rhs,e)
{
init(rhs);
}
Contents::Contents(const HeaderFieldValue& headerFieldValue,
HeaderFieldValue::CopyPaddingEnum e,
const Mime& contentsType)
: LazyParser(headerFieldValue,e),
mType(contentsType)
{
init();
}
Contents::~Contents()
{
freeMem();
}
static const Data errorContextData("Contents");
const Data&
Contents::errorContext() const
{
return errorContextData;
}
Contents&
Contents::operator=(const Contents& rhs)
{
if (this != &rhs)
{
freeMem();
LazyParser::operator=(rhs);
init(rhs);
}
return *this;
}
void
Contents::init(const Contents& orig)
{
mBufferList.clear();
mType = orig.mType;
if (orig.mDisposition)
{
mDisposition = new H_ContentDisposition::Type(*orig.mDisposition);
}
else
{
mDisposition = 0;
}
if (orig.mTransferEncoding)
{
mTransferEncoding = new H_ContentTransferEncoding::Type(*orig.mTransferEncoding);
}
else
{
mTransferEncoding = 0;
}
if (orig.mLanguages)
{
mLanguages = new H_ContentLanguages::Type(*orig.mLanguages);
}
else
{
mLanguages = 0;
}
if (orig.mId)
{
mId = new Token(*orig.mId);
}
else
{
mId = 0;
}
if (orig.mDescription)
{
mDescription = new StringCategory(*orig.mDescription);
}
else
{
mDescription = 0;
}
if(orig.mLength)
{
mLength = new StringCategory(*orig.mLength);
}
else
{
mLength = 0;
}
mVersion = orig.mVersion;
mMinorVersion = orig.mMinorVersion;
}
Contents*
Contents::createContents(const Mime& contentType,
const Data& contents)
{
// !ass! why are we asserting that the Data doesn't own the buffer?
// .dlb. because this method is to be called only within a multipart
// !ass! HFV is an overlay -- then setting c->mIsMine to true ?? dlb Q
// .dlb. we are telling the content that it owns its HFV, not the data that it
// .dlb. owns its memory
// .bwc. So, we are _violating_ _encapsulation_, to make an assertion that the
// Data is an intermediate instead of owning the buffer itself? What do we
// care how this buffer is owned? All we require is that the buffer doesn't
// get dealloced/modified while we're still around. The assertion might mean
// that the Data will not do either of these things, but it affords no
// protection from the actual owner doing so. We are no more protected with
// the assertion, so I am removing it.
// assert(!contents.mMine);
HeaderFieldValue hfv(contents.data(), (unsigned int)contents.size());
// !bwc! This padding stuff is now the responsibility of the Contents class.
// if(contentType.subType()=="sipfrag"||contentType.subType()=="external-body")
// {
// // .bwc. The parser for sipfrag requires padding at the end of the hfv.
// HeaderFieldValue* temp = hfv;
// hfv = new HeaderFieldValue(*temp,HeaderFieldValue::CopyPadding);
// delete temp;
// }
Contents* c;
if (ContentsFactoryBase::getFactoryMap().find(contentType) != ContentsFactoryBase::getFactoryMap().end())
{
c = ContentsFactoryBase::getFactoryMap()[contentType]->create(hfv, contentType);
}
else
{
c = new OctetContents(hfv, contentType);
}
return c;
}
bool
Contents::exists(const HeaderBase& headerType) const
{
checkParsed();
switch (headerType.getTypeNum())
{
case Headers::ContentType :
{
return true;
}
case Headers::ContentDisposition :
{
return mDisposition != 0;
}
case Headers::ContentTransferEncoding :
{
return mTransferEncoding != 0;
}
case Headers::ContentLanguage :
{
return mLanguages != 0;
}
default : return false;
}
}
bool
Contents::exists(const MIME_Header& type) const
{
if (&type == &h_ContentID)
{
return mId != 0;
}
if (&type == &h_ContentDescription)
{
return mDescription != 0;
}
assert(false);
return false;
}
void
Contents::remove(const HeaderBase& headerType)
{
switch (headerType.getTypeNum())
{
case Headers::ContentDisposition :
{
delete mDisposition;
mDisposition = 0;
break;
}
case Headers::ContentLanguage :
{
delete mLanguages;
mLanguages = 0;
break;
}
case Headers::ContentTransferEncoding :
{
delete mTransferEncoding;
mTransferEncoding = 0;
break;
}
default :
;
}
}
void
Contents::remove(const MIME_Header& type)
{
if (&type == &h_ContentID)
{
delete mId;
mId = 0;
return;
}
if (&type == &h_ContentDescription)
{
delete mDescription;
mDescription = 0;
return;
}
assert(false);
}
const H_ContentType::Type&
Contents::header(const H_ContentType& headerType) const
{
return mType;
}
H_ContentType::Type&
Contents::header(const H_ContentType& headerType)
{
return mType;
}
const H_ContentDisposition::Type&
Contents::header(const H_ContentDisposition& headerType) const
{
checkParsed();
if (mDisposition == 0)
{
ErrLog(<< "You called "
"Contents::header(const H_ContentDisposition& headerType) _const_ "
"without first calling exists(), and the header does not exist. Our"
" behavior in this scenario is to implicitly create the header(using const_cast!); "
"this is probably not what you want, but it is either this or "
"assert/throw an exception. Since this has been the behavior for "
"so long, we are not throwing here, _yet_. You need to fix your "
"code, before we _do_ start throwing. This is why const-correctness"
" should never be made a TODO item </rant>");
Contents* ncthis = const_cast<Contents*>(this);
ncthis->mDisposition = new H_ContentDisposition::Type;
}
return *mDisposition;
}
H_ContentDisposition::Type&
Contents::header(const H_ContentDisposition& headerType)
{
checkParsed();
if (mDisposition == 0)
{
mDisposition = new H_ContentDisposition::Type;
}
return *mDisposition;
}
const H_ContentTransferEncoding::Type&
Contents::header(const H_ContentTransferEncoding& headerType) const
{
checkParsed();
if (mTransferEncoding == 0)
{
ErrLog(<< "You called "
"Contents::header(const H_ContentTransferEncoding& headerType) _const_ "
"without first calling exists(), and the header does not exist. Our"
" behavior in this scenario is to implicitly create the header(using const_cast!); "
"this is probably not what you want, but it is either this or "
"assert/throw an exception. Since this has been the behavior for "
"so long, we are not throwing here, _yet_. You need to fix your "
"code, before we _do_ start throwing. This is why const-correctness"
" should never be made a TODO item </rant>");
Contents* ncthis = const_cast<Contents*>(this);
ncthis->mTransferEncoding = new H_ContentTransferEncoding::Type;
}
return *mTransferEncoding;
}
H_ContentTransferEncoding::Type&
Contents::header(const H_ContentTransferEncoding& headerType)
{
checkParsed();
if (mTransferEncoding == 0)
{
mTransferEncoding = new H_ContentTransferEncoding::Type;
}
return *mTransferEncoding;
}
const H_ContentLanguages::Type&
Contents::header(const H_ContentLanguages& headerType) const
{
checkParsed();
if (mLanguages == 0)
{
ErrLog(<< "You called "
"Contents::header(const H_ContentLanguages& headerType) _const_ "
"without first calling exists(), and the header does not exist. Our"
" behavior in this scenario is to implicitly create the header(using const_cast!); "
"this is probably not what you want, but it is either this or "
"assert/throw an exception. Since this has been the behavior for "
"so long, we are not throwing here, _yet_. You need to fix your "
"code, before we _do_ start throwing. This is why const-correctness"
" should never be made a TODO item </rant>");
Contents* ncthis = const_cast<Contents*>(this);
ncthis->mLanguages = new H_ContentLanguages::Type;
}
return *mLanguages;
}
H_ContentLanguages::Type&
Contents::header(const H_ContentLanguages& headerType)
{
checkParsed();
if (mLanguages == 0)
{
mLanguages = new H_ContentLanguages::Type;
}
return *mLanguages;
}
const H_ContentDescription::Type&
Contents::header(const H_ContentDescription& headerType) const
{
checkParsed();
if (mDescription == 0)
{
ErrLog(<< "You called "
"Contents::header(const H_ContentDescription& headerType) _const_ "
"without first calling exists(), and the header does not exist. Our"
" behavior in this scenario is to implicitly create the header(using const_cast!); "
"this is probably not what you want, but it is either this or "
"assert/throw an exception. Since this has been the behavior for "
"so long, we are not throwing here, _yet_. You need to fix your "
"code, before we _do_ start throwing. This is why const-correctness"
" should never be made a TODO item </rant>");
Contents* ncthis = const_cast<Contents*>(this);
ncthis->mDescription = new H_ContentDescription::Type;
}
return *mDescription;
}
H_ContentDescription::Type&
Contents::header(const H_ContentDescription& headerType)
{
checkParsed();
if (mDescription == 0)
{
mDescription = new H_ContentDescription::Type;
}
return *mDescription;
}
const H_ContentID::Type&
Contents::header(const H_ContentID& headerType) const
{
checkParsed();
if (mId == 0)
{
ErrLog(<< "You called "
"Contents::header(const H_ContentID& headerType) _const_ "
"without first calling exists(), and the header does not exist. Our"
" behavior in this scenario is to implicitly create the header(using const_cast!); "
"this is probably not what you want, but it is either this or "
"assert/throw an exception. Since this has been the behavior for "
"so long, we are not throwing here, _yet_. You need to fix your "
"code, before we _do_ start throwing. This is why const-correctness"
" should never be made a TODO item </rant>");
Contents* ncthis = const_cast<Contents*>(this);
ncthis->mId = new H_ContentID::Type;
}
return *mId;
}
H_ContentID::Type&
Contents::header(const H_ContentID& headerType)
{
checkParsed();
if (mId == 0)
{
mId = new H_ContentID::Type;
}
return *mId;
}
// !dlb! headers except Content-Disposition may contain (comments)
void
Contents::preParseHeaders(ParseBuffer& pb)
{
const char* start = pb.position();
Data all( start, pb.end()-start);
Data headerName;
try
{
while (!pb.eof())
{
const char* anchor = pb.skipWhitespace();
pb.skipToOneOf(Symbols::COLON, ParseBuffer::Whitespace);
pb.data(headerName, anchor);
pb.skipWhitespace();
pb.skipChar(Symbols::COLON[0]);
anchor = pb.skipWhitespace();
pb.skipToTermCRLF();
Headers::Type type = Headers::getType(headerName.data(), (int)headerName.size());
ParseBuffer subPb(anchor, pb.position() - anchor);
switch (type)
{
case Headers::ContentType :
{
// already set
break;
}
case Headers::ContentDisposition :
{
mDisposition = new H_ContentDisposition::Type;
mDisposition->parse(subPb);
break;
}
case Headers::ContentTransferEncoding :
{
mTransferEncoding = new H_ContentTransferEncoding::Type;
mTransferEncoding->parse(subPb);
break;
}
// !dlb! not sure this ever happens?
case Headers::ContentLanguage :
{
if (mLanguages == 0)
{
mLanguages = new H_ContentLanguages::Type;
}
subPb.skipWhitespace();
while (!subPb.eof() && *subPb.position() != Symbols::COMMA[0])
{
H_ContentLanguages::Type::value_type tmp;
header(h_ContentLanguages).push_back(tmp);
header(h_ContentLanguages).back().parse(subPb);
subPb.skipLWS();
}
break; // .kw. added -- this is needed, right?
}
default :
{
if (isEqualNoCase(headerName, "Content-Transfer-Encoding"))
{
mTransferEncoding = new StringCategory();
mTransferEncoding->parse(subPb);
}
else if (isEqualNoCase(headerName, "Content-Description"))
{
mDescription = new StringCategory();
mDescription->parse(subPb);
}
else if (isEqualNoCase(headerName, "Content-Id"))
{
mId = new Token();
mId->parse(subPb);
}
// Some people put this in ...
else if (isEqualNoCase(headerName, "Content-Length"))
{
mLength = new StringCategory();
mLength->parse(subPb);
}
else if (isEqualNoCase(headerName, "MIME-Version"))
{
subPb.skipWhitespace();
if (!subPb.eof() && *subPb.position() == Symbols::LPAREN[0])
{
subPb.skipToEndQuote(Symbols::RPAREN[0]);
subPb.skipChar(Symbols::RPAREN[0]);
}
mVersion = subPb.integer();
if (!subPb.eof() && *subPb.position() == Symbols::LPAREN[0])
{
subPb.skipToEndQuote(Symbols::RPAREN[0]);
subPb.skipChar(Symbols::RPAREN[0]);
}
subPb.skipChar(Symbols::PERIOD[0]);
if (!subPb.eof() && *subPb.position() == Symbols::LPAREN[0])
{
subPb.skipToEndQuote(Symbols::RPAREN[0]);
subPb.skipChar(Symbols::RPAREN[0]);
}
mMinorVersion = subPb.integer();
}
else
{
// add to application headers someday
std::cerr << "Unknown MIME Content- header: " << headerName << std::endl;
ErrLog(<< "Unknown MIME Content- header: " << headerName);
assert(false);
}
}
}
}
}
catch (ParseException & e )
{
ErrLog( << "Some problem parsing contents: " << e );
throw e;
}
}
EncodeStream&
Contents::encodeHeaders(EncodeStream& str) const
{
if (mVersion != 1 || mMinorVersion != 0)
{
str << "MIME-Version" << Symbols::COLON[0] << Symbols::SPACE[0]
<< mVersion << Symbols::PERIOD[0] << mMinorVersion
<< Symbols::CRLF;
}
str << "Content-Type" << Symbols::COLON[0] << Symbols::SPACE[0]
<< mType
<< Symbols::CRLF;
if (exists(h_ContentDisposition))
{
str << "Content-Disposition" << Symbols::COLON[0] << Symbols::SPACE[0];
header(h_ContentDisposition).encode(str);
str << Symbols::CRLF;
}
if (exists(h_ContentLanguages))
{
str << "Content-Languages" << Symbols::COLON[0] << Symbols::SPACE[0];
size_t count = 0;
size_t size = header(h_ContentLanguages).size();
for (H_ContentLanguages::Type::const_iterator
i = header(h_ContentLanguages).begin();
i != header(h_ContentLanguages).end(); ++i)
{
i->encode(str);
if (++count < size)
str << Symbols::COMMA << Symbols::SPACE;
}
str << Symbols::CRLF;
}
if (mTransferEncoding)
{
str << "Content-Transfer-Encoding" << Symbols::COLON[0] << Symbols::SPACE[0]
<< *mTransferEncoding
<< Symbols::CRLF;
}
if (mId)
{
str << "Content-Id" << Symbols::COLON[0] << Symbols::SPACE[0]
<< *mId
<< Symbols::CRLF;
}
if (mDescription)
{
str << "Content-Description" << Symbols::COLON[0] << Symbols::SPACE[0]
<< *mDescription
<< Symbols::CRLF;
}
if (mLength)
{
str << "Content-Length" << Symbols::COLON[0] << Symbols::SPACE[0]
<< *mLength
<< Symbols::CRLF;
}
str << Symbols::CRLF;
return str;
}
Data
Contents::getBodyData() const
{
checkParsed();
return Data::from(*this);
}
void
Contents::addBuffer(char* buf)
{
mBufferList.push_back(buf);
}
bool
resip::operator==(const Contents& lhs, const Contents& rhs)
{
MD5Stream lhsStream;
lhsStream << lhs;
MD5Stream rhsStream;
rhsStream << rhs;
return lhsStream.getHex() == rhsStream.getHex();
}
bool
resip::operator!=(const Contents& lhs, const Contents& rhs)
{
return !operator==(lhs,rhs);
}
/* ====================================================================
* The Vovida Software License, Version 1.0
*
* Copyright (c) 2000-2005
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The names "VOCAL", "Vovida Open Communication Application Library",
* and "Vovida Open Communication Application Library (VOCAL)" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact vocal@vovida.org.
*
* 4. Products derived from this software may not be called "VOCAL", nor
* may "VOCAL" appear in their name, without prior written
* permission of Vovida Networks, Inc.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
* NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL VOVIDA
* NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
* IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* ====================================================================
*
* This software consists of voluntary contributions made by Vovida
* Networks, Inc. and many individuals on behalf of Vovida Networks,
* Inc. For more information on Vovida Networks, Inc., please see
* <http://www.vovida.org/>.
*
*/
| 28.0342 | 108 | 0.611819 | dulton |
e2c7250919917ab7e48d5f7a5ccb8bdb691ee30b | 11,209 | cpp | C++ | droneTrajectoryPlanner/src/sources/potencialFieldMap.cpp | MorS25/cvg_quadrotor_swarm | da75d02049163cf65fd7305bc46a16359a851c7c | [
"BSD-3-Clause"
] | null | null | null | droneTrajectoryPlanner/src/sources/potencialFieldMap.cpp | MorS25/cvg_quadrotor_swarm | da75d02049163cf65fd7305bc46a16359a851c7c | [
"BSD-3-Clause"
] | null | null | null | droneTrajectoryPlanner/src/sources/potencialFieldMap.cpp | MorS25/cvg_quadrotor_swarm | da75d02049163cf65fd7305bc46a16359a851c7c | [
"BSD-3-Clause"
] | null | null | null | //////////////////////////////////////////////////////
// potencialFieldMap.cpp
//
// Created on: Jul 3, 2013
// Author: joselusl
//
// Last modification on: Oct 26, 2013
// Author: joselusl
//
//////////////////////////////////////////////////////
#include "potencialFieldMap.h"
using namespace std;
////////////////// ObstacleInPotencialMap ////////////////////////
ObstacleInPotencialMap::ObstacleInPotencialMap()
{
init();
return;
}
ObstacleInPotencialMap::~ObstacleInPotencialMap()
{
clear();
return;
}
int ObstacleInPotencialMap::init()
{
obstacleAltitudeDef=OBSTACLE_ALTITUDE_DEF;
obstaclePrecissionDef=OBSTACLE_PRECISSION_DEF;
return 1;
}
int ObstacleInPotencialMap::clear()
{
return 1;
}
int ObstacleInPotencialMap::define(double obstacleAltitudeDefIn, double obstaclePrecissionDefIn)
{
obstacleAltitudeDef=obstacleAltitudeDefIn;
obstaclePrecissionDef=obstaclePrecissionDefIn;
return 1;
}
int ObstacleInPotencialMap::calculateAltitudePotMap(double &valueAltitudeOut, double valueImplicitEquation)
{
//double value=0.0;
//value=implicitEquation(pointIn);
if(valueImplicitEquation<0.0)
{
valueAltitudeOut=obstacleAltitudeDef/2.0;
return 1;
}
valueAltitudeOut=obstacleAltitudeDef/(1+exp(obstaclePrecissionDef*valueImplicitEquation));
return 1;
}
////////////////// EllipseObstacleInPotencialMap2d ////////////////////////
/*
double EllipseObstacleInPotencialMap2d::calculateAltitudePotMap(std::vector<double> pointIn)
{
double valueImplicitEquation=TheEllipseObstacle2d->implicitEquation(pointIn);
return ObstacleInPotencialMap::calculateAltitudePotMap(valueImplicitEquation);
}
*/
////////////////// PotencialFieldMap ////////////////////////
PotencialFieldMap::PotencialFieldMap()
{
init();
return;
}
PotencialFieldMap::~PotencialFieldMap()
{
clear();
return;
}
int PotencialFieldMap::init()
{
pointInitAltitude=0.0;
pointFinAltitude=0.0;
return 1;
}
int PotencialFieldMap::clear()
{
return 1;
}
int PotencialFieldMap::setDimension(unsigned int dimensionIn)
{
dimension=dimensionIn;
//cout<<"dim="<<dimension<<endl;
pointInit.resize(dimension);
pointFin.resize(dimension);
return 1;
}
int PotencialFieldMap::setRobotDimensions(std::vector<double> robotDimensionsIn)
{
robotDimensions=robotDimensionsIn;
return 1;
}
int PotencialFieldMap::setRealMap(WorldMap* RealMapIn)
{
RealMap=RealMapIn;
//cout<<"Real map dime="<<RealMap->dimension.at(0)<<";"<<RealMap->dimension[1]<<endl;
return 1;
}
int PotencialFieldMap::setPointsInitFin(std::vector<double> pointInitIn, std::vector<double> pointFinIn, double pointInitAltitudeIn, double pointFinAltitudeIn)
{
pointInit=pointInitIn;
pointFin=pointFinIn;
if(pointInit.size()!=dimension && pointFin.size()!=dimension)
return 0;
if(pointFinAltitudeIn==0.0)
pointFinAltitude=0.0;
else
pointFinAltitude=pointFinAltitudeIn;
if(pointInitAltitudeIn==-1.0)
{
pointInitAltitude=0.0;
for(unsigned int i=0;i<pointInit.size();i++)
{
pointInitAltitude+=pow(pointInit[i]-pointFin[i],2);
}
pointInitAltitude=sqrt(pointInitAltitude);
}
else
pointInitAltitude=pointInitAltitudeIn;
if(pointInitAltitude<pointFinAltitude)
return 0;
//cout<<"pointIn="<<pointInit[0]<<"; "<<pointInit[1]<<endl;
//cout<<"pointFin="<<pointFin[0]<<"; "<<pointFin[1]<<endl;
//cout<<"altitudes in and fin="<<pointInitAltitude<<"; "<<pointFinAltitude<<endl;
if(!calculatePotMapCurve())
return 0;
return 1;
}
int PotencialFieldMap::setPointInit(std::vector<double> pointInitIn, double pointInitAltitudeIn)
{
// cout<<"b0"<<endl;
pointInit=pointInitIn;
//cout<<"b1"<<endl;
if(pointInitAltitudeIn==-1.0)
{
//cout<<"b2"<<endl;
pointInitAltitude=0.0;
for(unsigned int i=0;i<pointInit.size();i++)
{
pointInitAltitude+=pow(pointInit[i]-pointFin[i],2);
}
//cout<<"b3"<<endl;
pointInitAltitude=sqrt(pointInitAltitude);
}
else
pointInitAltitude=pointInitAltitudeIn;
//cout<<"b"<<endl;
if(!calculatePotMapCurve())
return 0;
//cout<<"bb"<<endl;
return 1;
}
int PotencialFieldMap::setPointFin(std::vector<double> pointFinIn, double pointFinAltitudeIn)
{
//cout<<"b"<<endl;
pointFin=pointFinIn;
if(pointFinAltitudeIn==0.0)
pointFinAltitude=0.0;
else
pointFinAltitude=pointFinAltitudeIn;
//cout<<"bn-1"<<endl;
if(!calculatePotMapCurve())
return 0;
//cout<<"bn"<<endl;
return 1;
}
int PotencialFieldMap::updateObstacleMap()
{
ObstaclesList.resize(RealMap->getNumberObstacles());
#ifdef VERBOSE_POTENCIAL_FIELD_MAP
cout<<"[PFM] (updateObstacleMap) number of obstacles in potencial field map="<<RealMap->getNumberObstacles()<<endl;
#endif
return 1;
}
int PotencialFieldMap::calculateAltitudePotMapCurve(double &valueAltitudeOut, std::vector<double> pointIn)
{
return 0;
}
int PotencialFieldMap::calculateAltitudePotMapObstacleI(double &valueAltitudeOut, std::vector<double> pointIn, unsigned int numObstacleI)
{
double value=0.0;
//cout<<"calculateAltitudePotMapObstacleI"<<endl;
//getHandleObstacle(numObstacleI)
//value=RealMap->obstaclesList[numObstacleI]->implicitEquation(pointIn,robotDimensions);
if(!RealMap->implicitEquationObstacleI(value,numObstacleI,pointIn,robotDimensions))
return 0;
//cout<<"Inside pot field map:"<<value<<endl;
//value=obstacleAltitudeDef/(1+exp(obstaclePrecissionDef*value));
return ObstaclesList[numObstacleI].calculateAltitudePotMap(valueAltitudeOut,value);
}
int PotencialFieldMap::calculatePotMapCurve()
{
return 0;
}
int PotencialFieldMap::calculateDistPotMap(double &distanceOut, std::vector<double> pointIn, std::vector<double> pointFin, bool useObstacles, bool useCurve)
{
distanceOut=0.0;
//end
return 0;
}
////////////////// PotencialFieldMap2d ////////////////////////
PotencialFieldMap2d::PotencialFieldMap2d()
{
init();
return;
}
PotencialFieldMap2d::~PotencialFieldMap2d()
{
clear();
return;
}
int PotencialFieldMap2d::init()
{
dimension=2;
return 1;
}
int PotencialFieldMap2d::clear()
{
return 1;
}
int PotencialFieldMap2d::calculatePotMapCurve()
{
potFieldMapCurve.resize(dimension);
potFieldMapCurve[0]= ( (pow(pointInit[0]-pointFin[0],2)+pow(pointInit[1]-pointFin[1],2)) / (pointInitAltitude-pointFinAltitude) );
potFieldMapCurve[1]= ( (pow(pointInit[0]-pointFin[0],2)+pow(pointInit[1]-pointFin[1],2)) / (pointInitAltitude-pointFinAltitude) );
return 1;
}
int PotencialFieldMap2d::setRealMap(WorldMap2d* RealMapIn)
{
RealMap=RealMapIn;
unsigned int dimensionIn;
if(!RealMap->getDimension(dimensionIn))
return 0;
//cout<<"[inside potFieldMap2d] dimension real map="<<dimensionIn<<endl;
if(!setDimension(dimensionIn))
return 0;
return 1;
}
int PotencialFieldMap2d::calculateAltitudePotMapCurve(double &valueAltitudeOut, std::vector<double> pointIn)
{
//cout<<"PointFin="<<pointFin[0]<<"; "<<pointFin[1]<<endl;
valueAltitudeOut=pointFinAltitude+pow((pointIn[0]-pointFin[0]),2)/potFieldMapCurve[0]+pow((pointIn[1]-pointFin[1]),2)/potFieldMapCurve[1];
//cout<<"altitude curve="<<valueAltitudeOut<<endl;
return 1;
}
int PotencialFieldMap2d::calculateDistPotMap(double &distanceOut, std::vector<double> pointInitIn, std::vector<double> pointFinIn, bool useObstacles, bool useCurve)
{
//cout<<"aqui\n";
//cout<<"calculateDistPotMap"<<endl;
//Change of variable
double angleAlpha=atan2(pointFinIn[1]-pointInitIn[1],pointFinIn[0]-pointInitIn[0]);
double smin=0.0;
double smax=sqrt( pow(pointFinIn[1]-pointInitIn[1],2)+pow(pointFinIn[0]-pointInitIn[0],2) );
//Iteration vars
double stepSize=STEP_SIZE_IN_INTEGRATION_S;
int numSteps=floor((smax-smin)/stepSize);
//cout<<"smax="<<smax<<endl;
//cout<<"numSteps="<<numSteps<<endl;
//Point to change the variables
vector<double> pointSwap(dimension);
//Altitudes for integration
double altitudeInit;
double altitudeFin;
//Init algorithm
distanceOut=0.0;
double s=0.0;
//Point of change the variables
pointSwap[0]=pointInitIn[0]+s*cos(angleAlpha);
pointSwap[1]=pointInitIn[1]+s*sin(angleAlpha);
//Init loop
altitudeInit=0.0;
//cout<<"aqui"<<endl;
//Potencial of curve
if(useCurve)
{
double aux=0.0;
if(!calculateAltitudePotMapCurve(aux,pointSwap))
return 0;
altitudeInit+=aux;
}
//cout<<"aqui"<<endl;
//cout<<altitudeInit<<endl;
//Potencial of obstacles
if(useObstacles)
{
double aux=0.0;
for(unsigned int numObstacleI=0;numObstacleI<ObstaclesList.size();numObstacleI++)
{
if(!calculateAltitudePotMapObstacleI(aux,pointSwap,numObstacleI))
return 0;
altitudeInit+=aux;
}
}
//cout<<"aqui"<<endl;
//cout<<altitudeInit<<endl;
for(int numStepI=0;numStepI<numSteps;numStepI++)
{
//Take step
s+=stepSize;
//Old variables
pointSwap[0]=pointInitIn[0]+s*cos(angleAlpha);
pointSwap[1]=pointInitIn[1]+s*sin(angleAlpha);
//ALtitude fin
altitudeFin=0.0;
//Potencial of curve
if(useCurve)
{
double aux=0.0;
if(!calculateAltitudePotMapCurve(aux,pointSwap))
return 0;
altitudeFin+=aux;
}
//Potencial of obstacles
if(useObstacles)
{
double aux=0.0;
for(unsigned int numObstacleI=0;numObstacleI<ObstaclesList.size();numObstacleI++)
{
if(!calculateAltitudePotMapObstacleI(aux,pointSwap,numObstacleI))
return 0;
altitudeFin+=aux;
}
}
//Longitud arc
distanceOut+=sqrt( pow(altitudeFin-altitudeInit,2) + pow(stepSize,2) );
//Update for next step
altitudeInit=altitudeFin;
}
//Last step
double lastDs=(smax-smin)-stepSize*numSteps;
s+=lastDs;
//Old variables
pointSwap[0]=pointInitIn[0]+s*cos(angleAlpha);
pointSwap[1]=pointInitIn[1]+s*sin(angleAlpha);
//ALtitude fin
altitudeFin=0.0;
//Potencial of curve
if(useCurve)
{
double aux=0.0;
if(!calculateAltitudePotMapCurve(aux,pointSwap))
return 0;
altitudeFin+=aux;
}
//Potencial of obstacles
if(useObstacles)
{
double aux=0.0;
for(unsigned int numObstacleI=0;numObstacleI<ObstaclesList.size();numObstacleI++)
{
if(!calculateAltitudePotMapObstacleI(aux,pointSwap,numObstacleI))
return 0;
altitudeFin+=aux;
}
}
//Longitud arc
distanceOut+=sqrt( pow(altitudeFin-altitudeInit,2) + pow(lastDs,2) );
//end
return 1;
}
| 21.514395 | 164 | 0.646356 | MorS25 |
e2d957adf0fc88c1af7466201525729df6da168a | 731 | cpp | C++ | Cpp_Programs/lougu/oj/P1008.cpp | xiazeyu/OI_Resource | 1de0ab9a84ee22ae4edb612ddeddc712c3c38e56 | [
"Apache-2.0"
] | 2 | 2018-10-01T09:03:35.000Z | 2019-05-24T08:53:06.000Z | Cpp_Programs/lougu/oj/P1008.cpp | xiazeyu/OI_Resource | 1de0ab9a84ee22ae4edb612ddeddc712c3c38e56 | [
"Apache-2.0"
] | null | null | null | Cpp_Programs/lougu/oj/P1008.cpp | xiazeyu/OI_Resource | 1de0ab9a84ee22ae4edb612ddeddc712c3c38e56 | [
"Apache-2.0"
] | null | null | null | #include <cstdio>
#include <iostream>
using namespace std;
bool check(int a, int b, int c){
if((a > 999) || (b > 999) || (c > 999)) return false;
int i;
int t[10] = {0};
t[a % 10] = 1;
t[(a % 100) / 10] = 1;
t[a / 100] = 1;
t[b % 10] = 1;
t[(b % 100) / 10] = 1;
t[b / 100] = 1;
t[c % 10] = 1;
t[(c % 100) / 10] = 1;
t[c / 100] = 1;
for(i = 1; i <= 9; i++){
if(t[i] == 0) return false;
}
return true;
}
int main(){
int a, b, c;
for(a = 100; a <= 999; a++){
b = a * 2;
c = a * 3;
if(check(a, b, c)) printf("%d %d %d\n", a, b, c);
}
return 0;
} | 17 | 58 | 0.347469 | xiazeyu |
e2db74577ced00a689d0405635de3263496311e0 | 3,775 | cpp | C++ | algorithms/cpp/Problems 201-300/_210_CourseScheduleII.cpp | shivamacs/LeetCode | f8f8b4e9872c47fbaaf9196c422f7e04986e6c3a | [
"MIT"
] | null | null | null | algorithms/cpp/Problems 201-300/_210_CourseScheduleII.cpp | shivamacs/LeetCode | f8f8b4e9872c47fbaaf9196c422f7e04986e6c3a | [
"MIT"
] | null | null | null | algorithms/cpp/Problems 201-300/_210_CourseScheduleII.cpp | shivamacs/LeetCode | f8f8b4e9872c47fbaaf9196c422f7e04986e6c3a | [
"MIT"
] | null | null | null | /* Source - https://leetcode.com/problems/course-schedule-ii/
Author - Shivam Arora
*/
#include <bits/stdc++.h>
using namespace std;
bool dfs(vector<vector<int>>& graph, unordered_set<int>& visited, vector<bool>& recStack, stack<int>& st, int src) {
visited.insert(src);
recStack[src] = true;
for(int i = 0; i < graph[src].size(); i++) {
int nbr = graph[src][i];
if(recStack[nbr])
return true;
if(visited.find(nbr) == visited.end()) {
bool answer = dfs(graph, visited, recStack, st, nbr);
if(answer)
return true;
}
}
st.push(src);
recStack[src] = false;
return false;
}
// approach 1
vector<int> findOrderUsingDFS(int numCourses, vector<vector<int>>& prerequisites) {
vector<vector<int>> graph(numCourses);
for(int i = 0; i < prerequisites.size(); i++)
graph[prerequisites[i][1]].push_back(prerequisites[i][0]);
unordered_set<int> visited;
stack<int> st;
vector<bool> recStack(numCourses);
for(int i = 0; i < graph.size(); i++) {
if(visited.find(i) == visited.end()) {
bool answer = dfs(graph, visited, recStack, st, i);
if(answer == true)
return {};
}
}
if(visited.size() != numCourses)
return {};
vector<int> result;
while(!st.empty()) {
result.push_back(st.top());
st.pop();
}
return result;
}
// approach 2
vector<int> findOrderUsingKahnsAlgo(int numCourses, vector<vector<int>>& prerequisites) {
vector<vector<int>> graph(numCourses);
for(int i = 0; i < prerequisites.size(); i++)
graph[prerequisites[i][1]].push_back(prerequisites[i][0]);
vector<int> indegree(numCourses);
for(int i = 0; i < graph.size(); i++) {
for(int j = 0; j < graph[i].size(); j++)
indegree[graph[i][j]]++;
}
queue<int> q;
int count = 0;
for(int i = 0; i < indegree.size(); i++) {
if(indegree[i] == 0) {
q.push(i);
count++;
}
}
vector<int> result;
while(!q.empty()) {
int front = q.front();
q.pop();
result.push_back(front);
for(int i = 0; i < graph[front].size(); i++) {
int nbr = graph[front][i];
if(--indegree[nbr] == 0) {
q.push(nbr);
count++;
}
}
}
if(count != numCourses)
return {};
return result;
}
int main()
{
int numCourses;
cout<<"Enter number of courses: ";
cin>>numCourses;
int p;
cout<<"Enter number of prerequisite pairs: ";
cin>>p;
vector<vector<int>> prerequisites(p);
int f, s;
cout<<"Enter prerequisite pairs: "<<endl;
for(int i = 0; i < p; i++) {
cin>>f>>s;
prerequisites[i].push_back(f);
prerequisites[i].push_back(s);
}
vector<int> result = findOrderUsingDFS(numCourses, prerequisites);
cout<<"Correct ordering of courses to finish all courses (using DFS - recursive): [";
if(result.size() > 0) {
for(int i = 0; i < result.size() - 1; i++)
cout<<result[i]<<", ";
cout<<result[result.size() - 1];
}
cout<<"]"<<endl;
result = findOrderUsingKahnsAlgo(numCourses, prerequisites);
cout<<"Correct ordering of courses to finish all courses (using Kahn's Algo - iterative): [";
if(result.size() > 0) {
for(int i = 0; i < result.size() - 1; i++)
cout<<result[i]<<", ";
cout<<result[result.size() - 1];
}
cout<<"]"<<endl;
} | 24.673203 | 116 | 0.509934 | shivamacs |
e2ddc96b8f612c794049531c117810a073c8de18 | 4,671 | cpp | C++ | app/genCSV.cpp | yukatayu/tentee_image_similarity | ae787c1b530483b30fdd152dbe51e8b50a1d9c5b | [
"MIT"
] | 9 | 2020-05-07T17:30:04.000Z | 2020-07-22T02:11:45.000Z | app/genCSV.cpp | yukatayu/tentee_image_similarity | ae787c1b530483b30fdd152dbe51e8b50a1d9c5b | [
"MIT"
] | null | null | null | app/genCSV.cpp | yukatayu/tentee_image_similarity | ae787c1b530483b30fdd152dbe51e8b50a1d9c5b | [
"MIT"
] | null | null | null | #include <iostream>
#include <map>
#include <vector>
#include <utility>
#include <string>
#include <algorithm>
#include <fstream>
#include <boost/filesystem.hpp>
#include <boost/foreach.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/features2d.hpp>
#include <illust_image_similarity.hpp>
using namespace illust_image_similarity::feature;
std::vector<std::string> getFileNames(std::string pathStr) {
std::vector<std::string> res;
namespace fs = boost::filesystem;
const fs::path path(pathStr);
BOOST_FOREACH(const fs::path& p, std::make_pair(fs::directory_iterator(path), fs::directory_iterator())) {
if (!fs::is_directory(p))
res.push_back(p.filename().string());
}
return res;
}
int main(){
cv::Mat mask = cv::imread("tentee_patch/mask/mask.png", 0);
// vvv For testing vvv //
// b1, b3, y1 -> double edge
// b2, p1, p2, p3 -> single edge
// p3 -> no edge
/*std::map<std::string, cv::Mat> images = {
{ "blue1", cv::imread("../tentee_patch/dream/0001.png") },
{ "blue2", cv::imread("../tentee_patch/dream/0087.png") },
{ "blue3", cv::imread("../tentee_patch/dream/0006.png") },
{ "blue4", cv::imread("../tentee_patch/dream/0255.png") },
{ "yell1", cv::imread("../tentee_patch/dream/0005.png") },
{ "pink1", cv::imread("../tentee_patch/dream/0002.png") },
{ "pink2", cv::imread("../tentee_patch/dream/0132.png") },
{ "pink3", cv::imread("../tentee_patch/dream/0138.png") },
{ "pink4", cv::imread("../tentee_patch/dream/0004.png") }
};*/
// memo: 1と12は近い, 2は遠い
// memo: 255と2はどちらも縞
// ^^^ For testing ^^^ //
std::map<std::string, cv::Mat> images;
auto fileList = getFileNames("../tentee_patch/dream/");
{
int cnt = 0;
for(auto&& fName : fileList){
cv::Mat img = cv::imread("../tentee_patch/dream/" + fName);
if(++cnt % 10 == 0)
std::cout << "loading: " << cnt << " images..." << std::endl;
if(img.data)
images[fName] = img;
}
}
std::cout << "start" << std::endl;
std::map<std::string, cv::MatND> hists;
for(auto&& [name, img] : images)
hists[name] = img | hueHistgramAlgorithm(mask);
std::map<std::string, cv::MatND> placements;
for(auto&& [name, img] : images)
placements[name] = img | placementAlgorithm;
std::map<std::string, std::vector<double>> directions;
for(auto&& [name, img] : images)
directions[name] = img | directionPreprocess | directionVec(mask);
int cnt = 0;
auto cdot = [](const std::vector<double>& lhs, const std::vector<double>& rhs) -> double {
int dim = std::min(lhs.size(), rhs.size());
double res = 0;
for(int i=0; i<dim; ++i)
res += lhs[i] * rhs[i];
return res;
};
// from, type [hue, edge, dir], to, index (0-), score (0-1)
const int maxIndex = 5;
std::ofstream data("recommend_data.csv");
for(auto&& [name, img] : images){
if(++cnt % 10 == 0)
std::cout << cnt << " / " << images.size() << " ... " << std::endl;
std::vector<std::pair<double, std::string>> list_hue;
std::vector<std::pair<double, std::string>> list_edge;
std::vector<std::pair<double, std::string>> list_dir;
auto&& pls = placements.at(name);
auto&& hist = hists.at(name);
auto&& dir = directions.at(name);
// target
for(auto&& [tName, tImg] : images){
if(name == tName) continue; // 自身とは比較しない (edge,dir,hueのスコアは常に1)
auto&& tPls = placements.at(tName);
auto&& tHist = hists.at(tName);
auto&& tDir = directions.at(tName);
list_hue.emplace_back(cv::compareHist(hist, tHist, cv::HISTCMP_CORREL), tName);
cv::Mat tmp;
// Normalized Cross-Correlation
//list_edge.emplace_back(cv::norm(img, tImg, cv::NORM_L1), tName);
cv::matchTemplate(pls, tPls, tmp, CV_TM_CCOEFF_NORMED);
list_edge.emplace_back(tmp.at<float>(0,0), tName);
// dot product
list_dir.emplace_back(cdot(dir, tDir), tName);
}
std::sort(list_edge.begin(), list_edge.end());
std::reverse(list_edge.begin(), list_edge.end());
std::sort(list_dir.begin(), list_dir.end());
std::reverse(list_dir.begin(), list_dir.end());
std::sort(list_hue.begin(), list_hue.end());
std::reverse(list_hue.begin(), list_hue.end());
for(int i=0; i<maxIndex && i < list_hue.size(); ++i){
auto [tHist, tName] = list_hue[i];
data << name << "," << "hue" << "," << tName << "," << i << "," << tHist << "\n";
}
for(int i=0; i<maxIndex && i < list_edge.size(); ++i){
auto [tHist, tName] = list_edge[i];
data << name << "," << "edge" << "," << tName << "," << i << "," << tHist << "\n";
}
for(int i=0; i<maxIndex && i < list_dir.size(); ++i){
auto [tHist, tName] = list_dir[i];
data << name << "," << "dir" << "," << tName << "," << i << "," << tHist << "\n";
}
data << std::flush;
}
std::cout << "end" << std::endl;
}
| 32.213793 | 107 | 0.61079 | yukatayu |
e2e0191f848a36905cd9e826c939e59b0ed66ac0 | 335 | cc | C++ | nofx/nofx_ofTexture/nofx_ofGetUsingCustomTextureWrap.cc | sepehr-laal/nofx | 7abc9da3d4fc0f5b72c6b3d591a08cf44d00277e | [
"MIT"
] | null | null | null | nofx/nofx_ofTexture/nofx_ofGetUsingCustomTextureWrap.cc | sepehr-laal/nofx | 7abc9da3d4fc0f5b72c6b3d591a08cf44d00277e | [
"MIT"
] | null | null | null | nofx/nofx_ofTexture/nofx_ofGetUsingCustomTextureWrap.cc | sepehr-laal/nofx | 7abc9da3d4fc0f5b72c6b3d591a08cf44d00277e | [
"MIT"
] | null | null | null | #include "nofx_ofGetUsingCustomTextureWrap.h"
#include "ofTexture.h"
namespace nofx
{
namespace ClassWrappers
{
NAN_METHOD(nofx_ofGetUsingCustomTextureWrap)
{
NanReturnValue(ofGetUsingCustomTextureWrap());
} // !nofx_ofGetUsingCustomTextureWrap
} // !namespace ClassWrappers
} // !namespace nofx | 25.769231 | 52 | 0.722388 | sepehr-laal |
e2e3b44726b15ea0fa6726997db88f50fdcb0b6c | 5,867 | cpp | C++ | src/sorting_network.cpp | afnaanhashmi/smt-switch | 73dd8ccf3c737e6bcf214d9f967df4a16b437eb8 | [
"BSD-3-Clause"
] | 49 | 2018-02-20T12:47:28.000Z | 2021-08-14T17:06:19.000Z | src/sorting_network.cpp | afnaanhashmi/smt-switch | 73dd8ccf3c737e6bcf214d9f967df4a16b437eb8 | [
"BSD-3-Clause"
] | 117 | 2017-06-30T18:26:02.000Z | 2021-08-17T19:50:18.000Z | src/sorting_network.cpp | afnaanhashmi/smt-switch | 73dd8ccf3c737e6bcf214d9f967df4a16b437eb8 | [
"BSD-3-Clause"
] | 21 | 2019-10-10T22:22:03.000Z | 2021-07-22T14:15:10.000Z | /********************* */
/*! \file sorting_network.cpp
** \verbatim
** Top contributors (to current version):
** Makai Mann
** This file is part of the smt-switch project.
** Copyright (c) 2020 by the authors listed in the file AUTHORS
** in the top-level source directory) and their institutional affiliations.
** All rights reserved. See the file LICENSE in the top-level source
** directory for licensing information.\endverbatim
**
** \brief Implements a symbolic sorting network for boolean-sorted variables.
**
**/
#include "sorting_network.h"
#include <assert.h>
#include "exceptions.h"
namespace smt {
// implementation based on SortingNetwork in the predecessor, CoSA:
// https://github.com/cristian-mattarei/CoSA/blob/141be4b23f4012c6ad5676907d7c211ae2b6614a/cosa/utils/formula_mngm.py#L198
TermVec SortingNetwork::sorting_network(const TermVec & unsorted) const
{
if (unsorted.empty())
{
return {};
}
// check that all the terms in unsorted are boolean sorted
// for sort aliasing solvers, best to compare to the object
// rather than rely on the SortKind
Sort boolsort = solver_->make_sort(BOOL);
Sort sort;
for (const auto & tt : unsorted)
{
sort = tt->get_sort();
if (tt->get_sort() != boolsort)
{
throw IncorrectUsageException("Expected all boolean sorts but got "
+ tt->to_string() + ":"
+ sort->to_string());
}
}
return sorting_network_rec(unsorted);
}
TermVec SortingNetwork::sort_two(const Term & t1, const Term & t2) const
{
return { solver_->make_term(Or, t1, t2), solver_->make_term(And, t1, t2) };
}
TermVec SortingNetwork::merge(const TermVec & sorted1,
const TermVec & sorted2) const
{
size_t len1 = sorted1.size();
size_t len2 = sorted2.size();
if (len1 == 0)
{
return sorted2;
}
else if (len2 == 0)
{
return sorted1;
}
else if (len1 == 1 && len2 == 1)
{
return sort_two(sorted1[0], sorted2[0]);
}
bool sorted1_is_even = (len1 % 2) == 0;
bool sorted2_is_even = (len2 % 2) == 0;
if (!sorted1_is_even and sorted2_is_even)
{
// normalize so we don't have to do all cases
return merge(sorted2, sorted1);
}
TermVec even_sorted1;
TermVec odd_sorted1;
for (size_t i = 0; i < len1; ++i)
{
if (i % 2 == 0)
{
odd_sorted1.push_back(sorted1[i]);
}
else
{
even_sorted1.push_back(sorted1[i]);
}
}
TermVec even_sorted2;
TermVec odd_sorted2;
for (size_t i = 0; i < len2; ++i)
{
if (i % 2 == 0)
{
odd_sorted2.push_back(sorted2[i]);
}
else
{
even_sorted2.push_back(sorted2[i]);
}
}
TermVec res_even = merge(even_sorted1, even_sorted2);
TermVec res_odd = merge(odd_sorted1, odd_sorted2);
size_t len_res_even = res_even.size();
size_t len_res_odd = res_odd.size();
TermVec res;
res.reserve(len1 + len2);
if (sorted1_is_even && sorted2_is_even)
{
assert(len_res_even == len_res_odd);
// if both inputs were even, they have same number of elements
// need to interleave and compare all inner elements
// the first odd result and last even result have already
// been compared via the base case of merge (two length 1
// lists)
Term first_res_odd = res_odd[0];
res.push_back(first_res_odd);
for (size_t i = 0; i < len_res_odd - 1; ++i)
{
const TermVec & two_sorted = sort_two(res_odd[i + 1], res_even[i]);
assert(two_sorted.size() == 2);
res.push_back(two_sorted[0]);
res.push_back(two_sorted[1]);
}
Term last_res_even = res_even.back();
res.push_back(last_res_even);
}
else if (sorted1_is_even && !sorted2_is_even)
{
assert(len_res_even + 1 == len_res_odd);
// if first element was even and second was odd,
// then there's one extra element in the merged
// odd list
// the first odd element has already been fully
// processed down to the base case of merge
Term first_res_odd = res_odd[0];
res.push_back(first_res_odd);
for (size_t i = 0; i < len_res_even; ++i)
{
const TermVec & two_sorted = sort_two(res_odd[i + 1], res_even[i]);
assert(two_sorted.size() == 2);
res.push_back(two_sorted[0]);
res.push_back(two_sorted[1]);
}
}
else if (!sorted1_is_even && !sorted2_is_even)
{
assert(len_res_even + 2 == len_res_odd);
// if both inputs were odd, then there are
// two more elements in the odd merged list
// the first and last elements have already
// been fully processed down to the base
// case of merge
// the rest need to be merged with the even
// merged list
Term first_res_odd = res_odd[0];
Term last_res_odd = res_odd.back();
res.push_back(first_res_odd);
for (size_t i = 0; i < len_res_even; ++i)
{
const TermVec & two_sorted = sort_two(res_odd[i + 1], res_even[i]);
assert(two_sorted.size() == 2);
res.push_back(two_sorted[0]);
res.push_back(two_sorted[1]);
}
res.push_back(last_res_odd);
}
else
{
// should not occur to due normalization above
assert(false);
}
assert(res.size() == len1 + len2);
return res;
}
// protected methods
TermVec SortingNetwork::sorting_network_rec(const TermVec & unsorted) const
{
size_t len = unsorted.size();
if (len == 1)
{
return unsorted;
}
else if (len == 2)
{
return sort_two(unsorted[0], unsorted[1]);
}
size_t pivot = len / 2;
auto begin = unsorted.begin();
TermVec left_vec(begin, begin + pivot);
TermVec right_vec(begin + pivot, unsorted.end());
TermVec left_res = sorting_network_rec(left_vec);
TermVec right_res = sorting_network_rec(right_vec);
return merge(left_res, right_res);
}
} // namespace smt
| 26.309417 | 122 | 0.63593 | afnaanhashmi |
e2eb0f892f50f04886c4aa27d03cc01a76b60bcd | 2,264 | cpp | C++ | zap/src/zap.cpp | colugomusic/blockhead_fx | e03f493b76f8747aea5522d214f3e8c3bb404110 | [
"MIT"
] | null | null | null | zap/src/zap.cpp | colugomusic/blockhead_fx | e03f493b76f8747aea5522d214f3e8c3bb404110 | [
"MIT"
] | null | null | null | zap/src/zap.cpp | colugomusic/blockhead_fx | e03f493b76f8747aea5522d214f3e8c3bb404110 | [
"MIT"
] | null | null | null | #include <rack++/module/smooth_param.h>
#include <rack++/module/channel.h>
#include <snd/misc.h>
#include "zap.h"
using namespace rack;
using namespace std::placeholders;
Zap::Zap()
: BasicStereoEffect("Zap")
{
param_spread_ = add_smooth_param(0.0f, "Spread");
param_spread_->set_transform([](const ml::DSPVector& v)
{
const auto x = v / 100.0f;
return x * x * ml::signBit(x);
});
param_spread_->set_size_hint(0.75);
param_spread_->set_format_hint(Rack_ParamFormatHint_Percentage);
param_spread_->set_min(-100.0f);
param_spread_->set_max(100.0f);
param_freq_ = add_smooth_param(1000.0f, "Frequency");
param_freq_->set_format_hint(Rack_ParamFormatHint_Hertz);
param_freq_->set_min(MIN_FREQ);
param_freq_->set_max(MAX_FREQ);
param_res_ = add_smooth_param(50.0f, "Resonance");
param_res_->set_transform([](const ml::DSPVector& v) { return v / 100.0f; });
param_res_->set_size_hint(0.75);
param_res_->set_format_hint(Rack_ParamFormatHint_Percentage);
param_res_->set_min(0.0f);
param_res_->set_max(100.0f);
param_mix_ = add_smooth_param(100.0f, "Mix");
param_mix_->set_transform([](const ml::DSPVector& v) { return v / 100.0f; });
param_mix_->set_size_hint(0.5);
param_mix_->set_format_hint(Rack_ParamFormatHint_Percentage);
param_mix_->set_min(0.0f);
param_mix_->set_max(100.0f);
param_spread_->begin_notify();
param_freq_->begin_notify();
param_res_->begin_notify();
param_mix_->begin_notify();
}
ml::DSPVectorArray<2> Zap::operator()(const ml::DSPVectorArray<2>& in)
{
ml::DSPVectorArray<2> out;
const auto& spread = (*param_spread_)();
const auto& base_freq = (*param_freq_)();
const auto& res = (*param_res_)();
const auto& mix = (*param_mix_)();
const auto offset = spread * 1000.0f;
const ml::DSPVector min_freq(MIN_FREQ);
const ml::DSPVector max_freq(MAX_FREQ);
const auto freq_L = ml::clamp(base_freq - offset, min_freq, max_freq);
const auto freq_R = ml::clamp(base_freq + offset, min_freq, max_freq);
const auto freq = ml::concatRows(freq_L, freq_R);
out = filter_(in, sample_rate_, freq, ml::repeatRows<2>(res));
return ml::lerp(in, out, ml::repeatRows<2>(mix));
}
void Zap::effect_clear()
{
filter_.clear();
}
| 29.025641 | 79 | 0.699647 | colugomusic |
e2edde13f8bd56ca97d153ea6c610c7940641ed8 | 5,174 | hpp | C++ | eagleye_util/fix2kml/include/fix2kml/GoogleEarthPath.hpp | lonfr/eagleye | 8c5880827cd41ce62b6f2a1e2f10e90351bab19b | [
"BSD-3-Clause"
] | 329 | 2020-03-19T00:41:00.000Z | 2022-03-31T05:52:33.000Z | eagleye_util/fix2kml/include/fix2kml/GoogleEarthPath.hpp | yxw027/eagleye | b5eab2fd162841d7be17ef320faf0bbd4f9627c4 | [
"BSD-3-Clause"
] | 22 | 2020-03-20T09:14:19.000Z | 2022-03-24T23:47:55.000Z | eagleye_util/fix2kml/include/fix2kml/GoogleEarthPath.hpp | yxw027/eagleye | b5eab2fd162841d7be17ef320faf0bbd4f9627c4 | [
"BSD-3-Clause"
] | 79 | 2020-03-19T03:08:29.000Z | 2022-03-09T00:54:03.000Z | // 1 tab = 8 spaces
/**
* ID: GoogleEarthPath.hpp
* EDITED: 23-09-2014
* AUTOR: Andres Gongora
*
* +------ Description: -----------------------------------------------------------+
* | |
* | Class to store GPS coordinates in a Google Earth compatible KML file. |
* | This can then be loaded and displayed as a route on Google Earth. |
* | |
* | |
* | EXAMPLE OF USE: |
* | 1 #include <GoogleEarthPath.hpp> //This class |
* | 2 #include <unistd.h> //Sleep |
* | 3 #include <magic_GPS_library.hpp> //Your GPS library |
* | 4 |
* | 5 int main() |
* | 6 { |
* | 7 // CREATE PATH |
* | 8 GoogleEarthPath path(myPath.kml, NameToShowInGEarth) |
* | 9 double longitude, latitude; |
* | 10 |
* | 11 for(int i=0; i < 10; i++) |
* | 12 { |
* | 13 //SOMEHOW GET GPS COORDINATES |
* | 14 yourGPSfunction(longitude,latitude); |
* | 15 |
* | 16 //ADD POINT TO PATH |
* | 17 path.addPoint(longitude,latitude); |
* | 18 |
* | 19 //WAIT FOR NEW POINTS |
* | 20 sleep(10); //sleep 10 seconds |
* | 21 } |
* | 22 return 0; |
* | 23 } |
* | |
* | This example code obtains GPS coordenates from an external function |
* | and stores them in the GoogleEarthPath instance. It samples 10 points |
* | during 100 seconds. Once the desctructor is called, the file |
* | myPath.kml is ready to be imported in G.E. |
* | |
* +-------------------------------------------------------------------------------+
*
**/
/*
* Copyright (C) 2014 Andres Gongora
* <https://yalneb.blogspot.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GOOGLEEARTHPATH_HPP_INCLUDED
#define GOOGLEEARTHPATH_HPP_INCLUDED
//----- INCLUDE ------------------------------------------------------------------------------------
#include <iostream>
#include <fstream> // File I/O
#include <iomanip> // std::setprecision
using namespace std;
//----- DEFINE -------------------------------------------------------------------------------------
//##### DECLARATION ################################################################################
class GoogleEarthPath
{
public:
GoogleEarthPath(const char*, const char*); //Requires log filename & Path name (to show inside googleearth)
~GoogleEarthPath(); // Default destructor
inline void addPoint(double, double, double);
private:
fstream fileDescriptor; // File descriptor
};
//##### DEFINITION #################################################################################
/***************************************************************************************************
* Constructor & Destructor
**************************************************************************************************/
GoogleEarthPath::GoogleEarthPath(const char* file, const char* pathName)
{
fileDescriptor.open(file, ios::out | ios::trunc); // Delete previous file if it exists
if(!fileDescriptor)
std::cerr << "GoogleEarthPath::\tCould not open file file! " << file << std::endl;
fileDescriptor << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << "\n"
<< "<kml xmlns=\"http://earth.google.com/kml/2.2\">" << "\n"
<< "<Document>" << "\n"
<< "<Placemark>" << "\n"
<< "<name>"<< pathName <<"</name>" << "\n"
<< "<Style>" << "\n"
<< "<LineStyle>" << "\n"
<< "<color>ff0000ff</color>" << "\n"
<< "<width>5.00</width>" << "\n"
<< "</LineStyle>" << "\n"
<< "</Style>" << "\n"
<< "<LineString>" << "\n"
<< "<tessellate>1</tessellate>" << "\n"
<< "<coordinates>" << "\n" ;
}
GoogleEarthPath::~GoogleEarthPath()
{
if(fileDescriptor)
{
fileDescriptor << "</coordinates>" << "\n"
<< "</LineString>" << "\n"
<< "</Placemark>" << "\n"
<< "</Document>" << "\n"
<< "</kml>" << "\n";
}
}
/***************************************************************************************************
* Path handling
**************************************************************************************************/
inline void GoogleEarthPath::addPoint(double longitude, double latitude, double altitude)
{
if(fileDescriptor)
{
fileDescriptor << setprecision(13)
<< longitude <<","
<< setprecision(13)
<< latitude << ","
<< setprecision(13)
<< altitude << "\n"
<< flush;
}
}
#endif //GOOGLEEARTHPATH
| 32.3375 | 111 | 0.473521 | lonfr |
e2f0970a4793179463cf01ac6c1cd4a28c13fce6 | 294 | cpp | C++ | codeforces/contests/round/622-div2/b.cpp | tysm/cpsols | 262212646203e516d1706edf962290de93762611 | [
"MIT"
] | 4 | 2020-10-05T19:24:10.000Z | 2021-07-15T00:45:43.000Z | codeforces/contests/round/622-div2/b.cpp | tysm/cpsols | 262212646203e516d1706edf962290de93762611 | [
"MIT"
] | null | null | null | codeforces/contests/round/622-div2/b.cpp | tysm/cpsols | 262212646203e516d1706edf962290de93762611 | [
"MIT"
] | null | null | null | #include <cpplib/stdinc.hpp>
int32_t main(){
desync();
int t;
cin >> t;
while(t--){
int n, x, y;
cin >> n >> x >> y;
int lo = min(n, 1+max((int)0, (x+y)-n));
int hi = min(n, x+y-1);
cout << lo << ' ' << hi << endl;
}
return 0;
}
| 18.375 | 48 | 0.394558 | tysm |
e2f70fecbc94632b3e8635ec2962c9468f336e2a | 2,588 | cpp | C++ | Olimpiada/2013/betasah.cpp | rlodina99/Learn_cpp | 0c5bd9e6c52ca21e2eb95eb91597272ddc842c08 | [
"MIT"
] | null | null | null | Olimpiada/2013/betasah.cpp | rlodina99/Learn_cpp | 0c5bd9e6c52ca21e2eb95eb91597272ddc842c08 | [
"MIT"
] | null | null | null | Olimpiada/2013/betasah.cpp | rlodina99/Learn_cpp | 0c5bd9e6c52ca21e2eb95eb91597272ddc842c08 | [
"MIT"
] | null | null | null | #include <iostream>
#include <fstream>
#include <climits>
using namespace std;
int main(){
ifstream f("betasah.in");
int n,d,k;
f >> n >> d >> k;
int mat[n][n];
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
mat[i][j]=0;
}
}
for(int i=0;i<n;i++){
for(int j=n-1;j>i;j--){
mat[i][j]=9;
}
}
int x,y;
for(int i=0;i<d;i++){
f >> x >> y;
mat[x-1][y-1]=3;
}
for(int i=0;i<k;i++){
f >> x >> y;
mat[x-1][y-1]=1;
}
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cout << mat[i][j] << ' ';
}
cout << '\n';
}
int maxPatrateAlbePeRand=0,max;
for(int i=0;i<n;i++){
max=0;
for(int j=0;j<n;j++){
if(mat[i][j]==0)
max++;
}
if(max>maxPatrateAlbePeRand)
maxPatrateAlbePeRand=max;
}
cout << maxPatrateAlbePeRand;
//NUMARAM nr de patrate
int albe =0;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if(mat[i][j]==3){
//DREAPTA
for(int g=j+1;g<n;g++){
if(mat[i][g]==0){
albe++;
mat[i][g]=11;
}
if(mat[i][g]==1 || mat[i][g]==9)
break;
}
//STANGA
for(int g=j-1;g>=0;g--){
if(mat[i][g]==0){
albe++;
mat[i][g]=11;
}
if(mat[i][g]==1 || mat[i][g]==9)
break;
}
//SUS
for(int k=i-1;k>=0;k--){
if(mat[k][j]==0){
albe++;
mat[k][j]=11;
}
if(mat[k][j]==1 || mat[k][j]==9)
break;
}
//JOS
for(int k=i+1;k<n;k++){
if(mat[k][j]==0){
albe++;
mat[k][j]=11;
}
if(mat[k][j]==1 || mat[k][j]==9)
break;
}
//STANGA SUS
int l=i-1;
int c=j-1;
while(l>=0 && c>=0){
if(mat[l][c]==0){
albe++;
mat[l][c]=11;
}
if(mat[l][c]==1 || mat[l][c]==9)
break;
l--;
c--;
}
//DREAPTA JOS
l=i+1;
c=j+1;
while(l<n && c<n){
if(mat[l][c]==0){
albe++;
mat[l][c]=11;
}
if(mat[l][c]==1 || mat[l][c]==9)
break;
l++;
c++;
}
//STANGA JOS
l=i+1;
c=j-1;
while(l<n && c>=0){
if(mat[l][c]==0){
albe++;
mat[l][c]=11;
}
if(mat[l][c]==1 || mat[l][c]==9)
break;
l++;
c--;
}
//DREAPTA SUS
l=i-1;
c=j+1;
while(l>=0 && c<n){
if(mat[l][c]==0){
albe++;
mat[l][c]=11;
}
if(mat[l][c]==1 || mat[l][c]==9)
break;
l--;
c++;
}
}
}
}
cout << '\n' << albe <<'\n';
return 0;
} | 15.046512 | 38 | 0.362056 | rlodina99 |
e2fd2b9e121b52834370eaba288ccfb959c9505a | 1,405 | hpp | C++ | source/oc/ocEngine/Components/ocComponentAllocator.hpp | mackron/openchernobyl | 47c854ce37e1c361b184e29a59e4881a6faa387c | [
"BSD-3-Clause"
] | 2 | 2021-05-24T21:18:13.000Z | 2021-12-20T07:21:20.000Z | source/oc/ocEngine/Components/ocComponentAllocator.hpp | openchernobyl/openchernobyl | 47c854ce37e1c361b184e29a59e4881a6faa387c | [
"BSD-3-Clause"
] | null | null | null | source/oc/ocEngine/Components/ocComponentAllocator.hpp | openchernobyl/openchernobyl | 47c854ce37e1c361b184e29a59e4881a6faa387c | [
"BSD-3-Clause"
] | null | null | null | // Copyright (C) 2018 David Reid. See included LICENSE file.
typedef ocComponent* (* ocCreateComponentProc)(ocEngineContext* pEngine, ocComponentType type, ocWorldObject* pObject, void* pUserData);
typedef void (* ocDeleteComponentProc)(ocComponent* pComponent, void* pUserData);
struct ocComponentAllocatorInstance
{
ocComponentType type;
ocCreateComponentProc onCreate;
ocDeleteComponentProc onDelete;
void* pUserData;
};
struct ocComponentAllocator
{
ocEngineContext* pEngine;
ocComponentAllocatorInstance* pAllocators;
};
//
ocResult ocComponentAllocatorInit(ocEngineContext* pEngine, ocComponentAllocator* pAllocator);
//
void ocComponentAllocatorUninit(ocComponentAllocator* pAllocator);
// Registers an allocator for a specific type of component.
//
// This will return OC_INVALID_ARGS if an allocator for the specified type has already been registered.
ocResult ocComponentAllocatorRegister(ocComponentAllocator* pAllocator, ocComponentType type, ocCreateComponentProc onCreate, ocDeleteComponentProc onDelete, void* pUserData);
// Creates an instance of a component of the given type.
ocComponent* ocComponentAllocatorCreateComponent(ocComponentAllocator* pAllocator, ocComponentType type, ocWorldObject* pObject);
// Deletes an instance of a component.
void ocComponentAllocatorDeleteComponent(ocComponentAllocator* pAllocator, ocComponent* pComponent); | 37.972973 | 175 | 0.814235 | mackron |
e2fd49c1a4ad988db34e8acb9d050ed78d2ee2bb | 6,653 | cpp | C++ | book_samples/opencl_interop/my_vx_tensor_map_impl.cpp | jwinarske/openvx_tutorial | 3b57b1c043c5e28e03b6c7121bad87f4ce67ea8c | [
"MIT"
] | 220 | 2016-03-20T00:48:58.000Z | 2022-03-31T09:46:21.000Z | book_samples/opencl_interop/my_vx_tensor_map_impl.cpp | jwinarske/openvx_tutorial | 3b57b1c043c5e28e03b6c7121bad87f4ce67ea8c | [
"MIT"
] | 28 | 2016-06-16T19:17:41.000Z | 2021-09-16T16:19:18.000Z | book_samples/opencl_interop/my_vx_tensor_map_impl.cpp | jwinarske/openvx_tutorial | 3b57b1c043c5e28e03b6c7121bad87f4ce67ea8c | [
"MIT"
] | 84 | 2016-03-24T01:13:07.000Z | 2022-03-22T04:37:03.000Z | /*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and/or associated documentation files (the
* "Materials"), to deal in the Materials without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Materials, and to
* permit persons to whom the Materials are furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/*!
* \file my_vx_tensor_map_impl.c
* \brief This is a simple reference implementation (not optimized)
* to demonstrate vxMapTensorPatch functionality, since it is
* not yet available in KhronosGroup/OpenVX-sample-impl repo
* \author Radhakrishna Giduthuri <radhakrishna.giduthuri@ieee.org>
*/
#include <VX/vx_khr_opencl_interop.h>
#include "my_vx_tensor_map_impl.h"
#include "common.h"
////
// constants
//
#define MAX_TENSOR_DIMS 6
////
// local data structure to pass data between vxMapTensorPatch & vxUnmapTensorPatch
//
struct my_vx_tensor_map_id {
vx_size number_of_dims;
vx_size view_start[MAX_TENSOR_DIMS];
vx_size view_end[MAX_TENSOR_DIMS];
vx_size stride[MAX_TENSOR_DIMS];
void * ptr;
vx_enum usage;
vx_enum mem_type;
};
////
// simple reference implementation (not optimized) for vxMapTensorPatch
// this creates a temporary buffer and uses a copy, instead of returning
// OpenVX internal buffer allocated for the tensor (so the copy overheads)
//
vx_status myVxMapTensorPatch(
vx_tensor tensor,
vx_size number_of_dims,
const vx_size* view_start,
const vx_size* view_end,
vx_map_id* map_id,
vx_size* stride,
void** ptr,
vx_enum usage,
vx_enum mem_type)
{
////
// calculate output stride values
//
vx_enum data_type;
vx_size dims[MAX_TENSOR_DIMS];
ERROR_CHECK_STATUS( vxQueryTensor(tensor, VX_TENSOR_DATA_TYPE, &data_type, sizeof(vx_enum)) );
ERROR_CHECK_STATUS( vxQueryTensor(tensor, VX_TENSOR_DIMS, &dims, sizeof(vx_size)*number_of_dims) );
switch(data_type) {
case VX_TYPE_INT16: stride[0] = sizeof(vx_int16); break;
case VX_TYPE_UINT8: stride[0] = sizeof(vx_uint8); break;
default: return VX_ERROR_NOT_SUPPORTED;
}
for(size_t dim = 1; dim < number_of_dims; dim++) {
stride[dim] = dims[dim-1] * stride[dim-1];
}
vx_size size = dims[number_of_dims-1] * stride[number_of_dims-1];
////
// create map_id and allocate temporary buffers to return
//
my_vx_tensor_map_id * id = new my_vx_tensor_map_id;
ERROR_CHECK_NOT_NULL( id );
id->number_of_dims = number_of_dims;
id->usage = usage;
id->mem_type = mem_type;
if(id->mem_type == VX_MEMORY_TYPE_OPENCL_BUFFER)
{
vx_context context = vxGetContext((vx_reference)tensor);
cl_context opencl_ctx;
ERROR_CHECK_STATUS( vxQueryContext(context, VX_CONTEXT_CL_CONTEXT, &opencl_ctx, sizeof(cl_context)) );
cl_int err;
id->ptr = clCreateBuffer(opencl_ctx, CL_MEM_READ_WRITE, size, NULL, &err);
ERROR_CHECK_STATUS( err );
}
else
{
id->ptr = new vx_uint8[size];
ERROR_CHECK_NOT_NULL( id->ptr );
}
for(size_t dim = 0; dim < number_of_dims; dim++) {
id->view_start[dim] = view_start ? view_start[dim] : 0;
id->view_end[dim] = view_end ? view_end[dim] : dims[dim];
id->stride[dim] = stride[dim];
}
*map_id = (vx_map_id)id;
*ptr = id->ptr;
////
// copy tensor patch into temporarily allocated map buffer if read requested
//
if(id->usage == VX_READ_ONLY || id->usage == VX_READ_AND_WRITE)
{
vx_status status = vxCopyTensorPatch(tensor, id->number_of_dims,
id->view_start, id->view_end, id->stride, id->ptr,
VX_READ_ONLY, id->mem_type);
if(status != VX_SUCCESS)
{
// release resources in case or error
if(id->mem_type == VX_MEMORY_TYPE_OPENCL_BUFFER) {
ERROR_CHECK_STATUS( clReleaseMemObject((cl_mem)id->ptr) );
}
else {
delete (vx_uint8 *)id->ptr;
}
delete id;
return status;
}
}
return VX_SUCCESS;
}
////
// simple reference implementation (not optimized) for vxUnmapTensorPatch
// this uses the temporary buffer used for mapping in myVxMapTensorPatch
//
vx_status myVxUnmapTensorPatch(
vx_tensor tensor,
const vx_map_id map_id)
{
////
// access mapped data
//
my_vx_tensor_map_id * id = (my_vx_tensor_map_id *)map_id;
////
// copy tensor patch into temporarily allocated map buffer if read requested
//
if(id->usage == VX_WRITE_ONLY || id->usage == VX_READ_AND_WRITE)
{
vx_status status = vxCopyTensorPatch(tensor, id->number_of_dims,
id->view_start, id->view_end, id->stride, id->ptr,
VX_WRITE_ONLY, id->mem_type);
if(status != VX_SUCCESS) {
// release resources in case or error
if(id->mem_type == VX_MEMORY_TYPE_OPENCL_BUFFER) {
ERROR_CHECK_STATUS( clReleaseMemObject((cl_mem)id->ptr) );
}
else {
delete (vx_uint8 *)id->ptr;
}
delete id;
return status;
}
}
////
// release temporary buffers allocated for mapping
//
if(id->mem_type == VX_MEMORY_TYPE_OPENCL_BUFFER) {
ERROR_CHECK_STATUS( clReleaseMemObject((cl_mem)id->ptr) );
}
else {
delete (vx_uint8 *)id->ptr;
}
delete id;
return VX_SUCCESS;
}
| 35.57754 | 110 | 0.620171 | jwinarske |
c3b3be02cd5e6b18b4c670130f18b31ae9fcae99 | 20,235 | cxx | C++ | test/unit/config/config_test.cxx | ANSAKsoftware/ansak-lib | 93eff12a50464f3071b27c8eb16336f93d0d04c6 | [
"BSD-2-Clause"
] | null | null | null | test/unit/config/config_test.cxx | ANSAKsoftware/ansak-lib | 93eff12a50464f3071b27c8eb16336f93d0d04c6 | [
"BSD-2-Clause"
] | null | null | null | test/unit/config/config_test.cxx | ANSAKsoftware/ansak-lib | 93eff12a50464f3071b27c8eb16336f93d0d04c6 | [
"BSD-2-Clause"
] | null | null | null | ///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2015, Arthur N. Klassen
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////
//
// 2015.01.02 - First Version
//
// May you do good and not evil.
// May you find forgiveness for yourself and forgive others.
// May you share freely, never taking more than you give.
//
///////////////////////////////////////////////////////////////////////////
//
// configTest.cxx -- unit tests for the configuration collection
//
///////////////////////////////////////////////////////////////////////////
#include <gtest/gtest.h>
#include <config.hxx>
#include <config_atom.hxx>
#include <config_types.hxx>
#include <runtime_exception.hxx>
#include <ansak/string.hxx>
#include <string>
#include <vector>
using namespace std;
using namespace ansak;
using namespace ansak::internal;
using namespace testing;
//===========================================================================
TEST(ConfigTest, testSimpleInit)
{
Config simple;
EXPECT_TRUE(simple.getValueNames().empty());
simple.initValue("foo", true);
EXPECT_FALSE(simple.getValueNames().empty());
}
//===========================================================================
TEST(ConfigTest, testUnchangeableInitValues)
{
Config un;
un.initValue("b", true, Config::immutable);
un.initValue("i", 23, Config::immutable);
un.initValue("f", 3.1415926535f, Config::immutable);
un.initValue("d", 4.222333344444555555, Config::immutable);
un.initValue("s", string("Now is the time"), Config::immutable);
un.initValue("cp", "for all good men to come", Config::immutable);
un.initValue("pt", toPoint(3, 4), Config::immutable);
un.initValue("r", toRect(100, 60, 50, 30), Config::immutable);
bool b, changed;
int i;
float f;
double d;
string s, cp;
Point pt;
Rect r; changed = true;
EXPECT_TRUE(un.get("b", b, &changed)); EXPECT_FALSE(changed);
EXPECT_FALSE(un.get("bb", b, &changed)); changed = true;
EXPECT_TRUE(un.get("i", i, &changed)); EXPECT_FALSE(changed);
EXPECT_FALSE(un.get("ii", i, &changed)); changed = true;
EXPECT_TRUE(un.get("f", f, &changed)); EXPECT_FALSE(changed);
EXPECT_FALSE(un.get("ff", f, &changed)); changed = false;
// retrieving a double value -- officially, we only store floats in settings,
// so retrieving a double is always a change from the original
EXPECT_TRUE(un.get("d", d, &changed)); EXPECT_TRUE(changed);
EXPECT_FALSE(un.get("dd", d, &changed)); changed = true;
EXPECT_TRUE(un.get("s", s, &changed)); EXPECT_FALSE(changed);
EXPECT_FALSE(un.get("ss", s, &changed)); changed = true;
EXPECT_TRUE(un.get("cp", cp, &changed)); EXPECT_FALSE(changed);
EXPECT_FALSE(un.get("ccp", cp, &changed)); changed = true;
EXPECT_TRUE(un.get("pt", pt, &changed)); EXPECT_FALSE(changed);
EXPECT_FALSE(un.get("ppt", pt, &changed)); changed = true;
EXPECT_TRUE(un.get("r", r, &changed)); EXPECT_FALSE(changed);
EXPECT_FALSE(un.get("rr", r, &changed)); changed = true;
EXPECT_TRUE(b);
EXPECT_EQ(23, i);
EXPECT_TRUE(floatEqual(3.1415926535f, f));
EXPECT_TRUE(floatEqual(4.222333344444555555, d));
EXPECT_EQ(string("Now is the time"), s);
EXPECT_EQ(string("for all good men to come"), cp);
EXPECT_EQ(3, x(pt));
EXPECT_EQ(4, y(pt));
EXPECT_EQ(100, left(r));
EXPECT_EQ(60, top(r));
EXPECT_EQ(50, width(r));
EXPECT_EQ(30, height(r));
EXPECT_THROW(un.put("b", false), RuntimeException);
}
//===========================================================================
TEST(ConfigTest, testChangeableInitValues)
{
Config ch;
ch.initValue("b", true);
ch.initValue("i", 23);
ch.initValue("f", 3.1415926535f);
ch.initValue("d", 4.222333344444555555);
ch.initValue("s", string("Now is the time"));
ch.initValue("cp", "for all good men to come");
ch.initValue("pt", toPoint(3, 4));
ch.initValue("r", toRect(100, 60, 50, 30));
bool b, changed;
int i;
float f, d;
string s, cp;
Point pt;
Rect r; changed = true;
EXPECT_TRUE(ch.get("b", b, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(ch.get("i", i, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(ch.get("f", f, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(ch.get("d", d, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(ch.get("s", s, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(ch.get("cp", cp, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(ch.get("pt", pt, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(ch.get("r", r, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(b);
EXPECT_EQ(23, i);
EXPECT_TRUE(floatEqual(3.1415926535f, f));
EXPECT_TRUE(floatEqual(4.222333344444555555, d));
EXPECT_EQ(string("Now is the time"), s);
EXPECT_EQ(string("for all good men to come"), cp);
EXPECT_EQ(3, x(pt));
EXPECT_EQ(4, y(pt));
EXPECT_EQ(100, left(r));
EXPECT_EQ(60, top(r));
EXPECT_EQ(50, width(r));
EXPECT_EQ(30, height(r));
ch.put("b", false);
ch.put("i", 32);
ch.put("f", 2.7182818301f);
ch.put("d", 5.6677788889999900000111111);
ch.put("s", "Et Earello Endorenna utulien.");
ch.put("cp", "Sinome maruvan ar Hildinyar tenn' ambar metta.");
ch.put("pt", toPoint(5, 6));
ch.put("r", toRect(500, 300, 20, 20));
changed = false;
EXPECT_TRUE(ch.get("b", b, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_TRUE(ch.get("i", i, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_TRUE(ch.get("f", f, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_TRUE(ch.get("d", d, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_TRUE(ch.get("s", s, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_TRUE(ch.get("cp", cp, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_TRUE(ch.get("pt", pt, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_TRUE(ch.get("r", r, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_FALSE(b);
EXPECT_EQ(32, i);
EXPECT_TRUE(floatEqual(2.7182818301f, f));
EXPECT_TRUE(floatEqual(5.6677788889999900000111111, d));
EXPECT_EQ(string("Et Earello Endorenna utulien."), s);
EXPECT_EQ(string("Sinome maruvan ar Hildinyar tenn' ambar metta."), cp);
EXPECT_EQ(5, x(pt));
EXPECT_EQ(6, y(pt));
EXPECT_EQ(500, left(r));
EXPECT_EQ(300, top(r));
EXPECT_EQ(20, width(r));
EXPECT_EQ(20, height(r));
}
//===========================================================================
TEST(ConfigTest, testGetValueNames)
{
Config ch;
ch.initValue("b", true);
ch.initValue("i", 23);
ch.initValue("f", 3.1415926535f);
ch.initValue("d", 4.222333344444555555);
ch.initValue("s", string("Now is the time"));
ch.initValue("cp", "for all good men to come");
ch.initValue("pt", toPoint(3, 4));
ch.initValue("r", toRect(100, 60, 50, 30));
bool gotB = false;
bool gotI = false;
bool gotF = false;
bool gotD = false;
bool gotS = false;
bool gotCP = false;
bool gotPT = false;
bool gotR = false;
auto names = ch.getValueNames();
EXPECT_EQ(static_cast<size_t>(8), names.size());
for (auto n : names)
{
if (n == "b") gotB = true;
else if (n == "i") gotI = true;
else if (n == "f") gotF = true;
else if (n == "d") gotD = true;
else if (n == "s") gotS = true;
else if (n == "cp") gotCP = true;
else if (n == "pt") gotPT = true;
else if (n == "r") gotR = true;
}
EXPECT_TRUE(gotB);
EXPECT_TRUE(gotI);
EXPECT_TRUE(gotF);
EXPECT_TRUE(gotD);
EXPECT_TRUE(gotS);
EXPECT_TRUE(gotCP);
EXPECT_TRUE(gotPT);
EXPECT_TRUE(gotR);
}
//===========================================================================
TEST(ConfigTest, testTemplatedConstructor)
{
const vector<string> utf8v{
"b=true",
"i=23",
"f=3.14159265",
"d=5.66777888899999",
"s=ash nazg durbatuluk",
"pt=3,4",
"",
"r=(100,40),(60,20)",
"q=v=w"
};
Config c0(utf8v);
bool b, changed;
int i;
float f, d;
string s,q;
Point pt;
Rect r; changed = true;
EXPECT_TRUE(c0.get("b", b, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(c0.get("i", i, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(c0.get("f", f, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(c0.get("d", d, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(c0.get("s", s, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(c0.get("pt", pt, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(c0.get("r", r, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(c0.get("q", q, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(b);
EXPECT_EQ(23, i);
EXPECT_TRUE(floatEqual(3.14159265f, f));
EXPECT_TRUE(floatEqual(5.66777888899999, d));
EXPECT_EQ(string("ash nazg durbatuluk"), s);
EXPECT_EQ(3, x(pt));
EXPECT_EQ(4, y(pt));
EXPECT_EQ(100, left(r));
EXPECT_EQ(40, top(r));
EXPECT_EQ(60, width(r));
EXPECT_EQ(20, height(r));
EXPECT_EQ(string("v=w"), q);
}
//===========================================================================
TEST(ConfigTest, testGetValues)
{
Config ch;
ch.initValue("b", true);
ch.initValue("i", 23);
ch.initValue("f", 3.1415926535f);
ch.initValue("d", 4.222333344444555555);
ch.initValue("s", string("Now is the time"));
ch.initValue("cp", "for all good men to come");
ch.initValue("pt", toPoint(3, 4));
ch.initValue("r", toRect(100, 60, 50, 30));
bool b;
int i;
float f;
double d;
string s;
Point pt;
Rect r;
EXPECT_TRUE(ch.get("b", b)); EXPECT_TRUE(b);
EXPECT_TRUE(ch.get("b", i)); EXPECT_EQ(1, i);
EXPECT_TRUE(ch.get("b", f)); EXPECT_TRUE(floatEqual(1.0f, f));
EXPECT_TRUE(ch.get("b", d)); EXPECT_TRUE(floatEqual(1.0, d));
EXPECT_TRUE(ch.get("b", s)); EXPECT_EQ(string("true"), s);
EXPECT_FALSE(ch.get("b", pt));
EXPECT_FALSE(ch.get("b", r));
EXPECT_TRUE(ch.get("i", b)); EXPECT_TRUE(b);
EXPECT_TRUE(ch.get("i", i)); EXPECT_EQ(23, i);
EXPECT_TRUE(ch.get("i", f)); EXPECT_TRUE(floatEqual(23.0f, f));
EXPECT_TRUE(ch.get("i", d)); EXPECT_TRUE(floatEqual(23.0, d));
EXPECT_TRUE(ch.get("i", s)); EXPECT_EQ(string("23"), s);
EXPECT_FALSE(ch.get("i", pt));
EXPECT_FALSE(ch.get("i", r));
EXPECT_TRUE(ch.get("f", b)); EXPECT_TRUE(b);
EXPECT_FALSE(ch.get("f", i));
EXPECT_TRUE(ch.get("f", f)); EXPECT_TRUE(floatEqual(3.1415926535f, f));
EXPECT_TRUE(ch.get("f", d)); EXPECT_TRUE(floatEqual(3.1415926535, d));
EXPECT_TRUE(ch.get("f", s)); EXPECT_EQ(string("3.14159"), s);
EXPECT_FALSE(ch.get("f", pt));
EXPECT_FALSE(ch.get("f", r));
EXPECT_TRUE(ch.get("d", b)); EXPECT_TRUE(b);
EXPECT_FALSE(ch.get("d", i));
EXPECT_TRUE(ch.get("d", f)); EXPECT_TRUE(floatEqual(4.2223333444f, f));
EXPECT_TRUE(ch.get("d", d)); EXPECT_TRUE(floatEqual(4.2223333444, d));
EXPECT_TRUE(ch.get("d", s)); EXPECT_EQ(string("4.22233"), s);
EXPECT_FALSE(ch.get("d", pt));
EXPECT_FALSE(ch.get("d", r));
EXPECT_FALSE(ch.get("s", b));
EXPECT_FALSE(ch.get("s", i));
EXPECT_FALSE(ch.get("s", f));
EXPECT_FALSE(ch.get("s", d));
EXPECT_TRUE(ch.get("s", s)); EXPECT_EQ(string("Now is the time"), s);
EXPECT_FALSE(ch.get("s", pt));
EXPECT_FALSE(ch.get("s", r));
EXPECT_FALSE(ch.get("cp", b));
EXPECT_FALSE(ch.get("cp", i));
EXPECT_FALSE(ch.get("cp", f));
EXPECT_FALSE(ch.get("cp", d));
EXPECT_TRUE(ch.get("cp", s)); EXPECT_EQ(string("for all good men to come"), s);
EXPECT_FALSE(ch.get("cp", pt));
EXPECT_FALSE(ch.get("cp", r));
EXPECT_FALSE(ch.get("pt", b));
EXPECT_FALSE(ch.get("pt", i));
EXPECT_FALSE(ch.get("pt", f));
EXPECT_FALSE(ch.get("pt", d));
EXPECT_TRUE(ch.get("pt", s)); EXPECT_EQ(string("3,4"), s);
EXPECT_TRUE(ch.get("pt", pt));
EXPECT_EQ(3, x(pt));
EXPECT_EQ(4, y(pt));
EXPECT_FALSE(ch.get("pt", r));
EXPECT_FALSE(ch.get("r", b));
EXPECT_FALSE(ch.get("r", i));
EXPECT_FALSE(ch.get("r", f));
EXPECT_FALSE(ch.get("r", d));
EXPECT_TRUE(ch.get("r", s)); EXPECT_EQ(string("(100,60),(50,30)"), s);
EXPECT_FALSE(ch.get("r", pt));
EXPECT_TRUE(ch.get("r", r));
EXPECT_EQ(100, left(r));
EXPECT_EQ(60, top(r));
EXPECT_EQ(50, width(r));
EXPECT_EQ(30, height(r));
}
// these two "case" ideas are being tested in testChangeableInitValues
// TEST(ConfigTest, testPutValues);
// TEST(ConfigTest, testGetChangedValues);
//===========================================================================
TEST(ConfigTest, testPutForceTypeValues)
{
Config ch;
ch.initValue("b", true);
ch.initValue("i", 23);
ch.initValue("pi", 3.1415926535f, Config::immutable);
ch.initValue("d", 4.222333344444555555);
ch.initValue("s", string("Now is the time"));
ch.initValue("cp", "for all good men to come");
ch.initValue("pt", toPoint(3, 4));
ch.initValue("r", toRect(100, 60, 50, 30));
ch.put("b", 34, Config::forceTypeChange);
ch.put("i", 2.71828301, Config::forceTypeChange);
EXPECT_THROW(ch.put("pi", 3.14, Config::forceTypeChange), RuntimeException);
ch.put("d", "Sorry, Murphy, no real constants are variable.", Config::forceTypeChange);
ch.put("s", toPoint(16,22), Config::forceTypeChange);
ch.put("pt", toRect(1,4,9,16), Config::forceTypeChange);
ch.put("r", false, Config::forceTypeChange);
bool b, changed;
int i;
float pi, d;
string s;
Point pt;
Rect r; changed = false;
EXPECT_TRUE(ch.get("b", i, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_EQ(34, i);
EXPECT_TRUE(ch.get("i", d, &changed)); EXPECT_TRUE(changed); changed = true;
EXPECT_TRUE(floatEqual(2.71828301, d));
EXPECT_TRUE(ch.get("pi", pi, &changed)); EXPECT_FALSE(changed); changed = false;
EXPECT_TRUE(floatEqual(3.1415926, pi));
EXPECT_TRUE(ch.get("d", s, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_EQ(string("Sorry, Murphy, no real constants are variable."), s);
EXPECT_TRUE(ch.get("s", pt, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_EQ(16, x(pt));
EXPECT_EQ(22, y(pt));
EXPECT_TRUE(ch.get("pt", r, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_EQ(1, left(r));
EXPECT_EQ(4, top(r));
EXPECT_EQ(9, width(r));
EXPECT_EQ(16, height(r));
EXPECT_TRUE(ch.get("r", b, &changed)); EXPECT_TRUE(changed); changed = false;
EXPECT_FALSE(b);
ch.put("b", 1.618f, Config::forceTypeChange);
EXPECT_TRUE(ch.get("b", d, &changed)); EXPECT_TRUE(changed); changed = true;
EXPECT_TRUE(floatEqual(1.618, d));
}
//===========================================================================
TEST(ConfigTest, testDefaultWith)
{
Config s;
s.initValue("a", 3);
s.initValue("b", 4);
Config q;
q.initValue("c", 5);
s.defaultWith(q);
int a, b, c;
bool changed = true;
EXPECT_TRUE(s.get("a", a, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(s.get("b", b, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(s.get("c", c, &changed)); EXPECT_FALSE(changed);
EXPECT_EQ(3, a);
EXPECT_EQ(4, b);
EXPECT_EQ(5, c);
}
//===========================================================================
TEST(ConfigTest, testOverrideWith)
{
Config s;
s.initValue("a", "33");
s.initValue("b", 4);
s.initValue("pi", 3.141592653, Config::immutable);
Config q;
q.initValue("c", 5);
q.initValue("a", 3);
q.initValue("pi", "3.14");
s.overrideWith(q);
int a, b, c;
float f;
bool changed = true;
EXPECT_TRUE(s.get("a", a, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(s.get("b", b, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(s.get("c", c, &changed)); EXPECT_FALSE(changed); changed = true;
EXPECT_TRUE(s.get("pi", f, &changed)); EXPECT_FALSE(changed);
EXPECT_EQ(3, a);
EXPECT_EQ(4, b);
EXPECT_EQ(5, c);
EXPECT_TRUE(floatEqual(3.1415926, f));
}
//===========================================================================
TEST(ConfigTest, testKeepOverridesOf)
{
Config s;
s.initValue("a", 3);
s.initValue("b", 4);
s.initValue("c", 55);
Config q;
q.initValue("c", 5);
Config savedQ(q);
EXPECT_EQ(q, savedQ);
q.defaultWith(s);
EXPECT_NE(q, savedQ);
q.keepOverridesOf(s);
EXPECT_EQ(q, savedQ);
}
//===========================================================================
TEST(ConfigTest, testAtomTransaction)
{
const vector<string> utf8v{
"b= true ",
"i=23",
"f=3.14159265",
"d=5.66777888899999",
"s=ash nazg durbatuluk",
"pt=3,4",
"",
"r=(100,40),(60,20)",
"q=v=w"
};
Config c0(utf8v);
vector<ConfigAtomPair> atomPairs;
atomPairs.push_back(ConfigAtomPair(string("b"), c0.getAtom("b")));
atomPairs.push_back(ConfigAtomPair(string("i"), c0.getAtom("i")));
atomPairs.push_back(ConfigAtomPair(string("f"), c0.getAtom("f")));
atomPairs.push_back(ConfigAtomPair(string("d"), c0.getAtom("d")));
atomPairs.push_back(ConfigAtomPair(string("s"), c0.getAtom("s")));
atomPairs.push_back(ConfigAtomPair(string("pt"), c0.getAtom("pt")));
atomPairs.push_back(ConfigAtomPair(string("r"), c0.getAtom("r")));
atomPairs.push_back(ConfigAtomPair(string("q"), c0.getAtom("q")));
EXPECT_EQ(ConfigAtom(), c0.getAtom("notThere"));
Config c1(atomPairs);
EXPECT_EQ(c0, c1);
Config c2 = c1;
c2.put("b", false);
EXPECT_NE(c2, c1);
c1.put("b", false);
EXPECT_EQ(c2, c1);
Config c3;
c3 = c2;
EXPECT_EQ(c3, c1);
}
//===========================================================================
TEST(ConfigTest, manualAdd)
{
const vector<string> utf8v{
"b=true",
"i=23",
"f=3.14159265",
"d=5.66777888899999",
"s=ash nazg durbatuluk",
"pt=3,4",
"r=(100,40),(60,20)"
};
Config c0(utf8v);
Config c1;
c1.put("r", toRect(100,40,60,20));
c1.put("pt", toPoint(3,4));
c1.put("s", "ash nazg durbatuluk");
c1.put("d", 5.66777888899999);
c1.put("f", 3.14159265f);
c1.put("i", 23);
c1.put("b", true);
EXPECT_EQ(c0, c1);
}
| 35.437828 | 91 | 0.586064 | ANSAKsoftware |
c3b899b877daa6a822136cf309b6e165c4c3e3dc | 2,820 | cpp | C++ | sources/Renderer/Direct3D12/Command/D3D12CommandContext.cpp | wirx6/LLGL | 2fc63aa5ddf4f5bd006c496cd9bbf6b40c2133ee | [
"BSD-3-Clause"
] | null | null | null | sources/Renderer/Direct3D12/Command/D3D12CommandContext.cpp | wirx6/LLGL | 2fc63aa5ddf4f5bd006c496cd9bbf6b40c2133ee | [
"BSD-3-Clause"
] | null | null | null | sources/Renderer/Direct3D12/Command/D3D12CommandContext.cpp | wirx6/LLGL | 2fc63aa5ddf4f5bd006c496cd9bbf6b40c2133ee | [
"BSD-3-Clause"
] | null | null | null | /*
* D3D12CommandContext.cpp
*
* This file is part of the "LLGL" project (Copyright (c) 2015-2018 by Lukas Hermanns)
* See "LICENSE.txt" for license information.
*/
#include "D3D12CommandContext.h"
#include "../D3D12Resource.h"
#include "../../DXCommon/DXCore.h"
namespace LLGL
{
void D3D12CommandContext::SetCommandList(ID3D12GraphicsCommandList* commandList)
{
if (commandList_ != commandList)
{
FlushResourceBarrieres();
commandList_ = commandList;
}
}
void D3D12CommandContext::TransitionResource(D3D12Resource& resource, D3D12_RESOURCE_STATES newState, bool flushBarrieres)
{
auto oldState = resource.transitionState;
if (oldState != newState)
{
auto& barrier = NextResourceBarrier();
/* Initialize resource barrier for resource transition */
barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
barrier.Transition.pResource = resource.native.Get();
barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
barrier.Transition.StateBefore = oldState;
barrier.Transition.StateAfter = newState;
/* Store new state in resource */
resource.transitionState = newState;
/* Flush resource barrieres if required */
if (flushBarrieres)
FlushResourceBarrieres();
}
}
void D3D12CommandContext::FlushResourceBarrieres()
{
if (numResourceBarriers_ > 0)
{
commandList_->ResourceBarrier(numResourceBarriers_, resourceBarriers_);
numResourceBarriers_ = 0;
}
}
void D3D12CommandContext::ResolveRenderTarget(
D3D12Resource& dstResource,
UINT dstSubresource,
D3D12Resource& srcResource,
UINT srcSubresource,
DXGI_FORMAT format)
{
/* Transition both resources */
TransitionResource(dstResource, D3D12_RESOURCE_STATE_RESOLVE_DEST, false);
TransitionResource(srcResource, D3D12_RESOURCE_STATE_RESOLVE_SOURCE);
/* Resolve multi-sampled render targets */
commandList_->ResolveSubresource(
dstResource.native.Get(),
dstSubresource,
srcResource.native.Get(),
srcSubresource,
format
);
/* Transition both resources */
TransitionResource(dstResource, dstResource.usageState, false);
TransitionResource(srcResource, srcResource.usageState);
}
/*
* ======= Private: =======
*/
D3D12_RESOURCE_BARRIER& D3D12CommandContext::NextResourceBarrier()
{
if (numResourceBarriers_ == g_maxNumResourceBarrieres)
FlushResourceBarrieres();
return resourceBarriers_[numResourceBarriers_++];
}
} // /namespace LLGL
// ================================================================================
| 27.647059 | 122 | 0.669149 | wirx6 |
c3b9a85b1d2b939baf36f5aa43b50e021a7dc906 | 115 | hpp | C++ | gtrc_vehicles/CfgAmmo.hpp | kzfoxx/GTRC-Framework | e60b1f6d7c5d594e22ef6c2d95c0db61d7d3d0f6 | [
"MIT"
] | null | null | null | gtrc_vehicles/CfgAmmo.hpp | kzfoxx/GTRC-Framework | e60b1f6d7c5d594e22ef6c2d95c0db61d7d3d0f6 | [
"MIT"
] | null | null | null | gtrc_vehicles/CfgAmmo.hpp | kzfoxx/GTRC-Framework | e60b1f6d7c5d594e22ef6c2d95c0db61d7d3d0f6 | [
"MIT"
] | null | null | null |
class CfgAmmo {
class BulletBase;
class Gatling_30mm_HE_Plane_CAS_01_F: BulletBase {
caliber = 6;
};
}; | 16.428571 | 52 | 0.695652 | kzfoxx |
c3bba75286889988256e08f90493166842347443 | 7,911 | cpp | C++ | src/Mesh.cpp | akoylasar/PBR | 17e6197fb5357220e2f1454898a18f8890844d4d | [
"MIT"
] | null | null | null | src/Mesh.cpp | akoylasar/PBR | 17e6197fb5357220e2f1454898a18f8890844d4d | [
"MIT"
] | null | null | null | src/Mesh.cpp | akoylasar/PBR | 17e6197fb5357220e2f1454898a18f8890844d4d | [
"MIT"
] | null | null | null | /*
* Copyright (c) Fouad Valadbeigi (akoylasar@gmail.com) */
#include "Mesh.hpp"
#include <cmath>
#include "Debug.hpp"
namespace Akoylasar
{
constexpr double kTwoPi = Neon::kPi * 2.0;
std::unique_ptr<Mesh> Mesh::buildSphere(double radius,
unsigned int hSegments,
unsigned int vSegments)
{
std::unique_ptr<Mesh> mesh = std::make_unique<Mesh>();
const int numVerts = (hSegments + 1) * (vSegments + 1);
mesh->vertices.reserve(numVerts);
for (int h = 0; h <= hSegments; ++h)
{
const double phi = static_cast<double>(h) / hSegments;
const double y = radius * std::cos(phi * Neon::kPi);
const double r = radius * std::sin(phi * Neon::kPi);
for (int v = 0; v <= vSegments; ++v)
{
Vertex vert;
const double theta = static_cast<double>(v) / vSegments;
const double x = -std::cos(theta * kTwoPi) * r;
const double z = std::sin(theta * kTwoPi) * r;
vert.position.x = x;
vert.position.y = y;
vert.position.z = z;
vert.normal = Neon::normalize(vert.position);
vert.uv.x = theta;
vert.uv.y = phi;
mesh->vertices.push_back(vert);
}
}
// Generate indices. TRIANGLE topology.
unsigned int indexCount = 6 * vSegments * (hSegments - 1);
mesh->indices.reserve(indexCount);
for (int h = 0; h < hSegments; ++h)
{
for (int v = 0; v < vSegments; ++v)
{
const unsigned int s = vSegments + 1;
const unsigned int a = h * s + (v + 1);
const unsigned int b = h * s + v;
const unsigned int c = (h + 1) * s + v;
const unsigned int d = (h + 1) * s + (v + 1);
// Avoid degenerate triangles in the caps.
if (h != 0)
{
mesh->indices.push_back(a);
mesh->indices.push_back(b);
mesh->indices.push_back(d);
}
if (h != hSegments - 1)
{
mesh->indices.push_back(b);
mesh->indices.push_back(c);
mesh->indices.push_back(d);
}
}
}
return mesh;
}
std::unique_ptr<Mesh> Mesh::buildQuad()
{
std::unique_ptr<Mesh> mesh = std::make_unique<Mesh>();
std::vector<Vertex> vertices = {
{Neon::Vec3f{-1, 1, 0.0}, Neon::Vec3f{0, 0, 1.0}, Neon::Vec2f{0, 0}}, // top left
{Neon::Vec3f{1, 1, 0.0}, Neon::Vec3f{0, 0, 1.0}, Neon::Vec2f{1, 0}}, // top right
{Neon::Vec3f{1, -1, 0.0}, Neon::Vec3f{0, 0, 1.0}, Neon::Vec2f{1, 1}}, // bottom right
{Neon::Vec3f{-1, -1, 0.0}, Neon::Vec3f{0, 0, 1.0}, Neon::Vec2f{0, 1}} // bottom left
};
std::vector<unsigned int> indices {
3, 1, 0,
3, 2, 1
};
mesh->vertices.assign(vertices.begin(), vertices.end());
mesh->indices.assign(indices.begin(), indices.end());
return mesh;
}
std::unique_ptr<Mesh> Mesh::buildCube()
{
std::unique_ptr<Mesh> mesh = std::make_unique<Mesh>();
std::vector<Vertex> vertices = {
// Front face
{Neon::Vec3f{-1, 1, 1.0}, Neon::Vec3f{0, 0, 1.0}, Neon::Vec2f{0, 0}},
{Neon::Vec3f{1, 1, 1.0}, Neon::Vec3f{0, 0, 1.0}, Neon::Vec2f{1, 0}},
{Neon::Vec3f{1, -1, 1.0}, Neon::Vec3f{0, 0, 1.0}, Neon::Vec2f{1, 1}},
{Neon::Vec3f{-1, -1, 1.0}, Neon::Vec3f{0, 0, 1.0}, Neon::Vec2f{0, 1}},
// Back face
{Neon::Vec3f{-1, 1, -1.0}, Neon::Vec3f{0, 0, -1.0}, Neon::Vec2f{1, 0}},
{Neon::Vec3f{1, 1, -1.0}, Neon::Vec3f{0, 0, -1.0}, Neon::Vec2f{0, 0}},
{Neon::Vec3f{1, -1, -1.0}, Neon::Vec3f{0, 0, -1.0}, Neon::Vec2f{0, 1}},
{Neon::Vec3f{-1, -1, -1.0}, Neon::Vec3f{0, 0, -1.0}, Neon::Vec2f{1, 1}},
// Left face
{Neon::Vec3f{-1, 1, -1.0}, Neon::Vec3f{-1, 0, 0}, Neon::Vec2f{0, 0}},
{Neon::Vec3f{-1, 1, 1.0}, Neon::Vec3f{-1, 0, 0}, Neon::Vec2f{1, 0}},
{Neon::Vec3f{-1, -1, 1.0}, Neon::Vec3f{-1, 0, 0}, Neon::Vec2f{1, 1}},
{Neon::Vec3f{-1, -1, -1.0}, Neon::Vec3f{-1, 0, 0}, Neon::Vec2f{0, 1}},
// Right face
{Neon::Vec3f{1, 1, -1.0}, Neon::Vec3f{1, 0, 0}, Neon::Vec2f{1, 0}},
{Neon::Vec3f{1, 1, 1.0}, Neon::Vec3f{1, 0, 0}, Neon::Vec2f{0, 0}},
{Neon::Vec3f{1, -1, 1.0}, Neon::Vec3f{1, 0, 0}, Neon::Vec2f{0, 1}},
{Neon::Vec3f{1, -1, -1.0}, Neon::Vec3f{1, 0, 0}, Neon::Vec2f{1, 1}},
// Top face
{Neon::Vec3f{-1, 1, -1.0}, Neon::Vec3f{0, 1, 0}, Neon::Vec2f{0, 0}},
{Neon::Vec3f{1, 1, -1.0}, Neon::Vec3f{0, 1, 0}, Neon::Vec2f{1, 0}},
{Neon::Vec3f{1, 1, 1.0}, Neon::Vec3f{0, 1, 0}, Neon::Vec2f{1, 1}},
{Neon::Vec3f{-1, 1, 1.0}, Neon::Vec3f{0, 1, 0}, Neon::Vec2f{0, 1}},
// Bottom face
{Neon::Vec3f{-1, -1, -1.0}, Neon::Vec3f{0, -1, 0}, Neon::Vec2f{1, 0}},
{Neon::Vec3f{1, -1, -1.0}, Neon::Vec3f{0, -1, 0}, Neon::Vec2f{0, 0}},
{Neon::Vec3f{1, -1, 1.0}, Neon::Vec3f{0, -1, 0}, Neon::Vec2f{0, 1}},
{Neon::Vec3f{-1, -1, 1.0}, Neon::Vec3f{0, -1, 0}, Neon::Vec2f{1, 1}},
};
std::vector<unsigned int> indices {
3, 1, 0,
3, 2, 1,
4, 5, 7,
5, 6, 7,
11, 9, 8,
11, 10, 9,
12, 13, 15,
13, 14, 15,
19, 17, 16,
19, 18, 17,
20, 21, 23,
21, 22, 23
};
mesh->vertices.assign(vertices.begin(), vertices.end());
mesh->indices.assign(indices.begin(), indices.end());
return mesh;
}
GpuMesh GpuMesh::createGpuMesh(const Mesh& mesh,
GLuint positionAttribuIndex,
GLuint normalAttribuIndex,
GLuint uvAttribuIndex)
{
GpuMesh gpuMesh;
// Vao setup.
CHECK_GL_ERROR(glGenVertexArrays(1, &gpuMesh.vao));
CHECK_GL_ERROR(glBindVertexArray(gpuMesh.vao));
// Setup vertex buffer.
CHECK_GL_ERROR(glGenBuffers(1, &gpuMesh.vbo));
CHECK_GL_ERROR(glBindBuffer(GL_ARRAY_BUFFER, gpuMesh.vbo));
const auto vertexBufferSize = mesh.vertices.size() * sizeof(Vertex);
CHECK_GL_ERROR(glBufferData(GL_ARRAY_BUFFER, vertexBufferSize, &mesh.vertices.at(0), GL_STATIC_DRAW));
// Setup index buffer.
CHECK_GL_ERROR(glGenBuffers(1, &gpuMesh.ebo));
CHECK_GL_ERROR(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gpuMesh.ebo));
const auto indexBufferSize = mesh.indices.size() * sizeof(std::uint32_t);
CHECK_GL_ERROR(glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBufferSize, &mesh.indices.at(0), GL_STATIC_DRAW));
// Specify vertex format.
CHECK_GL_ERROR(glBindBuffer(GL_ARRAY_BUFFER, gpuMesh.vbo));
CHECK_GL_ERROR(glVertexAttribPointer(positionAttribuIndex, 3, GL_FLOAT, false, sizeof(Vertex), (void*)(offsetof(Vertex, position))));
CHECK_GL_ERROR(glEnableVertexAttribArray(0));
CHECK_GL_ERROR(glVertexAttribPointer(normalAttribuIndex, 3, GL_FLOAT, false, sizeof(Vertex), (void*)(offsetof(Vertex, normal))));
CHECK_GL_ERROR(glEnableVertexAttribArray(1));
CHECK_GL_ERROR(glVertexAttribPointer(uvAttribuIndex, 2, GL_FLOAT, false, sizeof(Vertex), (void*)(offsetof(Vertex, uv))));
CHECK_GL_ERROR(glEnableVertexAttribArray(2));
CHECK_GL_ERROR(glBindVertexArray(0));
gpuMesh.indexCount = mesh.indices.size();
gpuMesh.drawMode = GL_TRIANGLES;
return gpuMesh;
}
void GpuMesh::releaseGpuMesh(GpuMesh& gpuMesh)
{
CHECK_GL_ERROR(glDeleteBuffers(1, &gpuMesh.vbo));
CHECK_GL_ERROR(glDeleteBuffers(1, &gpuMesh.ebo));
CHECK_GL_ERROR(glDeleteVertexArrays(1, &gpuMesh.vao));
gpuMesh.vbo = 0;
gpuMesh.ebo = 0;
gpuMesh.vao = 0;
}
void GpuMesh::draw() const
{
CHECK_GL_ERROR(glBindVertexArray(vao));
CHECK_GL_ERROR(glDrawElements(drawMode,
indexCount,
GL_UNSIGNED_INT,
nullptr));
}
}
| 36.456221 | 137 | 0.551511 | akoylasar |
c3c0b8d89474801267ed5e37059dfe1f44fc8778 | 730 | cpp | C++ | src/utils/InetUtils.cpp | GbaLog/wad_packer | 212af80a8e1e475221be4b5ec241bd77ec126899 | [
"MIT"
] | 4 | 2021-09-12T00:13:04.000Z | 2022-02-19T11:18:33.000Z | src/utils/InetUtils.cpp | GbaLog/wad_packer | 212af80a8e1e475221be4b5ec241bd77ec126899 | [
"MIT"
] | null | null | null | src/utils/InetUtils.cpp | GbaLog/wad_packer | 212af80a8e1e475221be4b5ec241bd77ec126899 | [
"MIT"
] | null | null | null | #include "InetUtils.h"
//-----------------------------------------------------------------------------
#ifdef _WIN32
#include <winsock2.h>
#else
#include <arpa/inet.h>
#endif
//-----------------------------------------------------------------------------
namespace ratel
{
//-----------------------------------------------------------------------------
uint16_t htons(uint16_t val)
{
return ::htons(val);
}
//-----------------------------------------------------------------------------
uint32_t htonl(uint32_t val)
{
return ::htonl(val);
}
//-----------------------------------------------------------------------------
}
//-----------------------------------------------------------------------------
| 30.416667 | 80 | 0.217808 | GbaLog |
c3cd2c2feb1535207804a141f2d25998822e240a | 993 | cpp | C++ | src/homework/tic_tac_toe/tic_tac_toe_manager.cpp | acc-cosc-1337-spring-2020/acc-cosc-1337-spring-2020-OMTut | aabedb5cb108513173951a5fc86ad589e7c8ccbc | [
"MIT"
] | null | null | null | src/homework/tic_tac_toe/tic_tac_toe_manager.cpp | acc-cosc-1337-spring-2020/acc-cosc-1337-spring-2020-OMTut | aabedb5cb108513173951a5fc86ad589e7c8ccbc | [
"MIT"
] | null | null | null | src/homework/tic_tac_toe/tic_tac_toe_manager.cpp | acc-cosc-1337-spring-2020/acc-cosc-1337-spring-2020-OMTut | aabedb5cb108513173951a5fc86ad589e7c8ccbc | [
"MIT"
] | null | null | null | #include "tic_tac_toe_manager.h"
TicTacToeManager::TicTacToeManager(TicTacToeData & data)
{
games = data.get_games();
for (auto& game : games)
{
update_winner_count(game->get_winner());
}
}
void TicTacToeManager::save_game(unique_ptr<TicTacToe> & game)
{
update_winner_count(game->get_winner());
games.push_back(std::move(game));
}
void TicTacToeManager::update_winner_count(string winner)
{
if (winner == "X") { x_win++; }
if (winner == "O") { o_win++; }
if (winner == "C") { ties++; }
}
void TicTacToeManager::get_winner_total(int & o, int & x, int & c)
{
x = x_win;
o = o_win;
c = ties;
}
TicTacToeManager::~TicTacToeManager()
{
data.save_games(games);
}
ostream & operator<<(ostream & out, const TicTacToeManager & manager)
{
for (auto &game : manager.games)
{
out << *game << "\n";
}
out << "\nX Win Count: " << manager.x_win << "\n";
out << "O Win Count: " << manager.o_win << "\n";
out << "Tie Count: " << manager.ties << "\n";
return out;
}
| 16.55 | 69 | 0.632427 | acc-cosc-1337-spring-2020 |
c3ce1e2623ad89e78d9d3b8d43b3f82b4a3530b8 | 1,809 | cpp | C++ | src/res/animation.cpp | crockeo/cpp-whatisthisgame | 90fe2f69f380635050aa746f280288aa0b7c5f54 | [
"MIT"
] | null | null | null | src/res/animation.cpp | crockeo/cpp-whatisthisgame | 90fe2f69f380635050aa746f280288aa0b7c5f54 | [
"MIT"
] | 1 | 2015-02-02T02:08:02.000Z | 2015-02-02T04:48:27.000Z | src/res/animation.cpp | crockeo/cpp-whatisthisgame | 90fe2f69f380635050aa746f280288aa0b7c5f54 | [
"MIT"
] | null | null | null | #include "animation.hpp"
//////////
// Code //
// Calculating the current frame index.
unsigned int Animation::calcCurrentFrameIndex() const {
int frame = this->timer->getTime() / frameLength;
if (frame >= this->textures.size())
return this->textures.size() - 1;
return frame;
}
// Creating a new animation with its frames, its frame length, and if it
// ought to loop.
Animation::Animation(std::vector<Texture> textures, float frameLength, bool doesLoop) {
this->textures = textures;
this->frameLength = frameLength;
this->isOriginal = true;
this->doesLoop = doesLoop;
if (this->doesLoop)
this->timer = std::make_shared<Timer>(this->textures.size() * this->frameLength);
else
this->timer = std::make_shared<Timer>();
}
// Creating a new animation with all of the above, assuming that it will
// want to loop.
Animation::Animation(std::vector<Texture> textures, float frameLength) :
Animation(textures, frameLength, true) { }
// Overriding the default copy constructor.
Animation::Animation(const Animation& anim) {
this->textures = anim.textures;
this->frameLength = anim.frameLength;
this->isOriginal = false;
this->doesLoop = anim.doesLoop;
this->timer = anim.timer;
}
// Getting the timer that exists
std::shared_ptr<Timer> Animation::getTimer() { return this->timer; }
// Getting the current frame of an animation.
Texture Animation::getCurrentFrame() const {
return this->textures.at(this->calcCurrentFrameIndex());
}
// Getting the current texture ID.
GLuint Animation::getID() const { return this->getCurrentFrame().getID(); }
// Getting the texture coordinates.
std::vector<GLfloat> Animation::getTextureCoords() const {
return this->getCurrentFrame().getTextureCoords();
}
| 31.736842 | 89 | 0.688778 | crockeo |
c3d326ab78155934dfa9180a0789d3b8f2f6b7c6 | 1,139 | cpp | C++ | src/erhe/scene/viewport.cpp | tksuoran/erhe | 07d1ea014e1675f6b09bff0d9d4f3568f187e0d8 | [
"Apache-2.0"
] | 36 | 2021-05-03T10:47:49.000Z | 2022-03-19T12:54:03.000Z | src/erhe/scene/viewport.cpp | tksuoran/erhe | 07d1ea014e1675f6b09bff0d9d4f3568f187e0d8 | [
"Apache-2.0"
] | 29 | 2020-05-17T08:26:31.000Z | 2022-03-27T08:52:47.000Z | src/erhe/scene/viewport.cpp | tksuoran/erhe | 07d1ea014e1675f6b09bff0d9d4f3568f187e0d8 | [
"Apache-2.0"
] | 2 | 2022-01-24T09:24:37.000Z | 2022-01-31T20:45:36.000Z | #include "erhe/scene/viewport.hpp"
#include "erhe/scene/log.hpp"
#include "erhe/toolkit/math_util.hpp"
namespace erhe::scene
{
auto Viewport::unproject(
const glm::mat4 world_from_clip,
const glm::vec3 window,
const float depth_range_near,
const float depth_range_far
) const -> std::optional<glm::vec3>
{
return erhe::toolkit::unproject(
world_from_clip,
window,
depth_range_near,
depth_range_far,
static_cast<float>(x),
static_cast<float>(y),
static_cast<float>(width),
static_cast<float>(height)
);
}
auto Viewport::project_to_screen_space(
const glm::mat4 clip_from_world,
const glm::vec3 position_in_world,
const float depth_range_near,
const float depth_range_far
) const -> glm::vec3
{
return erhe::toolkit::project_to_screen_space(
clip_from_world,
position_in_world,
depth_range_near,
depth_range_far,
static_cast<float>(x),
static_cast<float>(y),
static_cast<float>(width),
static_cast<float>(height)
);
}
} // namespace erhe::scene
| 24.234043 | 50 | 0.653205 | tksuoran |
c3daccd7cb4ce0df04859e39032c133934ccc4d2 | 77,794 | cpp | C++ | src/vm/vm8051.cpp | koalajack/koalachain | 84b5d5351072947f79f982ca24666047e955df3d | [
"MIT"
] | null | null | null | src/vm/vm8051.cpp | koalajack/koalachain | 84b5d5351072947f79f982ca24666047e955df3d | [
"MIT"
] | null | null | null | src/vm/vm8051.cpp | koalajack/koalachain | 84b5d5351072947f79f982ca24666047e955df3d | [
"MIT"
] | null | null | null | // ComDirver.cpp: implementation of the CComDirver class.
//
//////////////////////////////////////////////////////////////////////
#include "vm8051.h"
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "hash.h"
#include "key.h"
#include "main.h"
#include <openssl/des.h>
#include <vector>
#include "vmrunevn.h"
#include "tx.h"
//#include "Typedef.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
void CVm8051::InitalReg() {
memset(m_ChipRam, 0, sizeof(m_ChipRam));
memset(m_ChipSfr, 0, sizeof(m_ChipSfr));
memset(m_ExRam, 0, sizeof(m_ExRam));
memset(m_ExeFile, 0, sizeof(m_ExeFile));
Sys.a.SetAddr(a_addr);
Sys.b.SetAddr(b_addr);
Sys.dptr.SetAddr(dptrl);
Sys.psw.SetAddr(psw_addr);
Sys.sp.SetAddr(sp_addr);
Rges.R0.SetAddr(0x00);
Rges.R1.SetAddr(0x01);
Rges.R2.SetAddr(0x02);
Rges.R3.SetAddr(0x03);
Rges.R4.SetAddr(0x04);
Rges.R5.SetAddr(0x05);
Rges.R6.SetAddr(0x06);
Rges.R7.SetAddr(0x07);
SetRamData(0x80, 0xFF);
SetRamData(0x90, 0xFF);
SetRamData(0xa0, 0xFF);
SetRamData(0xb0, 0xFF);
Sys.sp = 0x07;
}
CVm8051::CVm8051(const vector<unsigned char> & vRom, const vector<unsigned char> &InputData) :
Sys(this), Rges(this) {
InitalReg();
//INT16U addr = 0xFC00;
memcpy(m_ExeFile, &vRom[0], vRom.size());
unsigned char *ipara = (unsigned char *) GetExRamAddr(VM_SHARE_ADDR);
int count = InputData.size();
memcpy(ipara, &count, 2);
memcpy(&ipara[2], &InputData[0],count);
}
CVm8051::~CVm8051() {
}
typedef tuple<int,int64_t,std::shared_ptr < std::vector< vector<unsigned char> > > > RET_DEFINE;
typedef tuple<int,int64_t,std::shared_ptr < std::vector< vector<unsigned char> > > > (*pFun)(unsigned char *,void *);
struct __MapExterFun {
INT16U method;
pFun fun;
};
static bool GetKeyId(const CAccountViewCache &view, vector<unsigned char> &ret,
CKeyID &KeyId) {
if (ret.size() == 6) {
CRegID reg(ret);
KeyId = reg.getKeyID(view);
} else if (ret.size() == 34) {
string addr(ret.begin(), ret.end());
KeyId = CKeyID(addr);
}else{
return false;
}
if (KeyId.IsEmpty())
return false;
return true;
}
static inline RET_DEFINE RetFalse(const string reason )
{
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
return std::make_tuple (false,0, tem);
}
static unsigned short GetParaLen(unsigned char * &pbuf) {
unsigned short ret = 0;
memcpy(&ret, pbuf, 2);
pbuf += 2;
return ret;
}
static bool GetData(unsigned char * ipara, vector<std::shared_ptr < std::vector<unsigned char> > > &ret) {
int totallen = GetParaLen(ipara);
//assert(totallen >= 0);
if(totallen <= 0)
{
return false;
}
if(totallen>= CVm8051::MAX_SHARE_RAM)
{
LogPrint("vm","%s\r\n","data over flaw");
return false;
}
while (totallen > 0) {
unsigned short length = GetParaLen(ipara);
if ((length <= 0) || (length + 2 > totallen)) {
LogPrint("vm","%s\r\n","data over flaw");
return false;
}
totallen -= (length + 2);
ret.insert(ret.end(),std::make_shared<vector<unsigned char>>(ipara, ipara + length));
ipara += length;
}
return true;
}
static RET_DEFINE ExInt64CompFunc(unsigned char *ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) || retdata.size() != 2||
retdata.at(0).get()->size() != sizeof(int64_t)||retdata.at(1).get()->size() != sizeof(int64_t))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
int64_t m1, m2;
unsigned char rslt;
memcpy(&m1, &retdata.at(0).get()->at(0), sizeof(m1));
memcpy(&m2, &retdata.at(1).get()->at(0), sizeof(m2));
if (m1 > m2) {
rslt = 2;
} else if (m1 == m2) {
rslt = 0;
} else {
rslt = 1;
}
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << rslt;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExInt64MullFunc(unsigned char *ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 2||
retdata.at(0).get()->size() != sizeof(int64_t)||retdata.at(1).get()->size() != sizeof(int64_t))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
int64_t m1, m2, m3;
memcpy(&m1, &retdata.at(0).get()->at(0), sizeof(m1));
memcpy(&m2, &retdata.at(1).get()->at(0), sizeof(m2));
m3 = m1 * m2;
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << m3;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExInt64AddFunc(unsigned char *ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 2||
retdata.at(0).get()->size() != sizeof(int64_t)||retdata.at(1).get()->size() != sizeof(int64_t))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
int64_t m1, m2, m3;
memcpy(&m1, &retdata.at(0).get()->at(0), sizeof(m1));
memcpy(&m2, &retdata.at(1).get()->at(0), sizeof(m2));
m3 = m1 + m2;
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << m3;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExInt64SubFunc(unsigned char *ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 2||
retdata.at(0).get()->size() != sizeof(int64_t)||retdata.at(1).get()->size() != sizeof(int64_t))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
int64_t m1, m2, m3;
memcpy(&m1, &retdata.at(0).get()->at(0), sizeof(m1));
memcpy(&m2, &retdata.at(1).get()->at(0), sizeof(m2));
m3 = m1 - m2;
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << m3;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExInt64DivFunc(unsigned char *ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 2||
retdata.at(0).get()->size() != sizeof(int64_t)||retdata.at(1).get()->size() != sizeof(int64_t))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
int64_t m1, m2, m3;
memcpy(&m1, &retdata.at(0).get()->at(0), sizeof(m1));
memcpy(&m2, &retdata.at(1).get()->at(0), sizeof(m2));
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if( m2 == 0)
{
return std::make_tuple (false,0, tem);
}
m3 = m1 / m2;
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << m3;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExSha256Func(unsigned char *ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
uint256 rslt = Hash(&retdata.at(0).get()->at(0), &retdata.at(0).get()->at(0) + retdata.at(0).get()->size());
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << rslt;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExDesFunc(unsigned char *ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 3)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
DES_key_schedule deskey1, deskey2, deskey3;
vector<unsigned char> desdata;
vector<unsigned char> desout;
unsigned char datalen_rest = retdata.at(0).get()->size() % sizeof(DES_cblock);
desdata.assign(retdata.at(0).get()->begin(), retdata.at(0).get()->end());
if (datalen_rest) {
desdata.insert(desdata.end(), sizeof(DES_cblock) - datalen_rest, 0);
}
const_DES_cblock in;
DES_cblock out, key;
desout.resize(desdata.size());
unsigned char flag = retdata.at(2).get()->at(0);
if (flag == 1) {
if (retdata.at(1).get()->size() == 8) {
// printf("the des encrypt\r\n");
memcpy(key, &retdata.at(1).get()->at(0), sizeof(DES_cblock));
DES_set_key_unchecked(&key, &deskey1);
for (unsigned int ii = 0; ii < desdata.size() / sizeof(DES_cblock); ii++) {
memcpy(&in, &desdata[ii * sizeof(DES_cblock)], sizeof(in));
// printf("in :%s\r\n", HexStr(in, in + 8, true).c_str());
DES_ecb_encrypt(&in, &out, &deskey1, DES_ENCRYPT);
// printf("out :%s\r\n", HexStr(out, out + 8, true).c_str());
memcpy(&desout[ii * sizeof(DES_cblock)], &out, sizeof(out));
}
}
else if(retdata.at(1).get()->size() == 16)
{
// printf("the 3 des encrypt\r\n");
memcpy(key, &retdata.at(1).get()->at(0), sizeof(DES_cblock));
DES_set_key_unchecked(&key, &deskey1);
DES_set_key_unchecked(&key, &deskey3);
memcpy(key, &retdata.at(1).get()->at(0) + sizeof(DES_cblock), sizeof(DES_cblock));
DES_set_key_unchecked(&key, &deskey2);
for (unsigned int ii = 0; ii < desdata.size() / sizeof(DES_cblock); ii++) {
memcpy(&in, &desdata[ii * sizeof(DES_cblock)], sizeof(in));
DES_ecb3_encrypt(&in, &out, &deskey1, &deskey2, &deskey3, DES_ENCRYPT);
memcpy(&desout[ii * sizeof(DES_cblock)], &out, sizeof(out));
}
}
else
{
//error
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
return std::make_tuple (false,0, tem);
}
} else {
if (retdata.at(1).get()->size() == 8) {
// printf("the des decrypt\r\n");
memcpy(key, &retdata.at(1).get()->at(0), sizeof(DES_cblock));
DES_set_key_unchecked(&key, &deskey1);
for (unsigned int ii = 0; ii < desdata.size() / sizeof(DES_cblock); ii++) {
memcpy(&in, &desdata[ii * sizeof(DES_cblock)], sizeof(in));
// printf("in :%s\r\n", HexStr(in, in + 8, true).c_str());
DES_ecb_encrypt(&in, &out, &deskey1, DES_DECRYPT);
// printf("out :%s\r\n", HexStr(out, out + 8, true).c_str());
memcpy(&desout[ii * sizeof(DES_cblock)], &out, sizeof(out));
}
}
else if(retdata.at(1).get()->size() == 16)
{
// printf("the 3 des decrypt\r\n");
memcpy(key, &retdata.at(1).get()->at(0), sizeof(DES_cblock));
DES_set_key_unchecked(&key, &deskey1);
DES_set_key_unchecked(&key, &deskey3);
memcpy(key, &retdata.at(1).get()->at(0) + sizeof(DES_cblock), sizeof(DES_cblock));
DES_set_key_unchecked(&key, &deskey2);
for (unsigned int ii = 0; ii < desdata.size() / sizeof(DES_cblock); ii++) {
memcpy(&in, &desdata[ii * sizeof(DES_cblock)], sizeof(in));
DES_ecb3_encrypt(&in, &out, &deskey1, &deskey2, &deskey3, DES_DECRYPT);
memcpy(&desout[ii * sizeof(DES_cblock)], &out, sizeof(out));
}
}
else
{
//error
return RetFalse(string(__FUNCTION__)+"para err !");
}
}
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
(*tem.get()).push_back(desout);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExVerifySignatureFunc(unsigned char *ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 3||
retdata.at(1).get()->size() != 33||
retdata.at(2).get()->size() !=32)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
CPubKey pk(retdata.at(1).get()->begin(), retdata.at(1).get()->end());
uint256 hash(*retdata.at(2).get());
auto tem = std::make_shared<std::vector<vector<unsigned char> > >();
bool rlt = CheckSignScript(hash, *retdata.at(0), pk);
if (!rlt) {
LogPrint("INFO", "ExVerifySignatureFunc call CheckSignScript verify signature failed!\n");
return std::make_tuple(false, 0, tem);
}
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << rlt;
vector<unsigned char> tep1(tep.begin(), tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple(true, 0, tem);
}
static RET_DEFINE ExSignatureFunc(unsigned char *ipara,void * pVmScriptRun) {
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExLogPrintFunc(unsigned char *ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 2)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
CDataStream tep1(*retdata.at(0), SER_DISK, CLIENT_VERSION);
bool flag ;
tep1 >> flag;
string pdata((*retdata[1]).begin(), (*retdata[1]).end());
if(flag)
{
LogPrint("vm","%s\r\n", HexStr(pdata).c_str());
// LogPrint("INFO","%s\r\n", HexStr(pdata).c_str());
}else
{
LogPrint("vm","%s\r\n",pdata.c_str());
// LogPrint("INFO","%s\r\n",pdata.c_str());
}
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
return std::make_tuple (true, 0,tem);
}
static RET_DEFINE ExGetTxContractsFunc(unsigned char * ipara,void * pVmScriptRun) {
CVmRunEvn *pVmScript = (CVmRunEvn *)pVmScriptRun;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1 || retdata.at(0).get()->size() != 32)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
uint256 hash1(*retdata.at(0));
// LogPrint("vm","ExGetTxContractsFunc1:%s\n",hash1.GetHex().c_str());
bool flag = false;
std::shared_ptr<CBaseTransaction> pBaseTx;
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if (GetTransaction(pBaseTx, hash1, *pVmScript->GetScriptDB(), false)) {
CTransaction *tx = static_cast<CTransaction*>(pBaseTx.get());
(*tem.get()).push_back(tx->vContract);
flag = true;
}
return std::make_tuple (flag, 0,tem);
}
static RET_DEFINE ExGetTxAccountsFunc(unsigned char * ipara, void * pVmScriptRun) {
CVmRunEvn *pVmScript = (CVmRunEvn *)pVmScriptRun;
vector<std::shared_ptr<vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1|| retdata.at(0).get()->size() != 32)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
CDataStream tep1(*retdata.at(0), SER_DISK, CLIENT_VERSION);
uint256 hash1;
tep1 >>hash1;
// LogPrint("vm","ExGetTxAccountsFunc:%s",hash1.GetHex().c_str());
bool flag = false;
std::shared_ptr<CBaseTransaction> pBaseTx;
auto tem = std::make_shared<std::vector<vector<unsigned char> > >();
if (GetTransaction(pBaseTx, hash1, *pVmScript->GetScriptDB(), false)) {
CTransaction *tx = static_cast<CTransaction*>(pBaseTx.get());
vector<unsigned char> item = boost::get<CRegID>(tx->srcRegId).GetVec6();
(*tem.get()).push_back(item);
flag = true;
}
return std::make_tuple(flag,0, tem);
}
static RET_DEFINE ExGetAccountPublickeyFunc(unsigned char * ipara,void * pVmScriptRun) {
CVmRunEvn *pVmScript = (CVmRunEvn *)pVmScriptRun;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1
|| !(retdata.at(0).get()->size() == 6 || retdata.at(0).get()->size() == 34))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
CKeyID addrKeyId;
if (!GetKeyId(*(pVmScript->GetCatchView()),*retdata.at(0).get(), addrKeyId)) {
return RetFalse(string(__FUNCTION__)+"para err !");
}
CUserID userid(addrKeyId);
CAccount aAccount;
if (!pVmScript->GetCatchView()->GetAccount(userid, aAccount)) {
return RetFalse(string(__FUNCTION__)+"GetAccount err !");
}
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
vector<char> te;
tep << aAccount.PublicKey;
assert(aAccount.PublicKey.IsFullyValid());
tep >>te;
vector<unsigned char> tep1(te.begin(),te.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExQueryAccountBalanceFunc(unsigned char * ipara,void * pVmScriptRun) {
CVmRunEvn *pVmScript = (CVmRunEvn *)pVmScriptRun;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1
|| !(retdata.at(0).get()->size() == 6 || retdata.at(0).get()->size() == 34))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
bool flag = true;
CKeyID addrKeyId;
if (!GetKeyId(*pVmScript->GetCatchView(),*retdata.at(0).get(), addrKeyId)) {
return RetFalse(string(__FUNCTION__)+"para err !");
}
CUserID userid(addrKeyId);
CAccount aAccount;
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if (!pVmScript->GetCatchView()->GetAccount(userid, aAccount)) {
flag = false;
}
else
{
uint64_t nbalance = aAccount.GetRawBalance();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << nbalance;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
}
return std::make_tuple (flag ,0, tem);
}
static RET_DEFINE ExGetTxConFirmHeightFunc(unsigned char * ipara,void * pVmScriptRun) {
CVmRunEvn *pVmScript = (CVmRunEvn *)pVmScriptRun;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1|| retdata.at(0).get()->size() != 32)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
uint256 hash1(*retdata.at(0));
// LogPrint("vm","ExGetTxContractsFunc1:%s",hash1.GetHex().c_str());
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
int nHeight = GetTxComfirmHigh(hash1, *pVmScript->GetScriptDB());
if(-1 == nHeight)
{
return std::make_tuple (false,0, tem);
}
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << nHeight;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExGetBlockHashFunc(unsigned char * ipara,void * pVmScriptRun) {
vector<std::shared_ptr < vector<unsigned char> > > retdata;
CVmRunEvn *pVmScript = (CVmRunEvn *)pVmScriptRun;
if(!GetData(ipara,retdata) ||retdata.size() != 1 || retdata.at(0).get()->size() != sizeof(int))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
int height = 0;
memcpy(&height, &retdata.at(0).get()->at(0), sizeof(int));
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if (height <= 0 || height >= pVmScript->GetComfirHeight())
{
return std::make_tuple (false,0, tem);
}
if(chainActive.Height() < height){
return std::make_tuple (false, 0,tem);
}
CBlockIndex *pindex = chainActive[height];
uint256 blockHash = pindex->GetBlockHash();
// LogPrint("vm","ExGetBlockHashFunc:%s",HexStr(blockHash).c_str());
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << blockHash;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExGetCurRunEnvHeightFunc(unsigned char * ipara,void * pVmEvn) {
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
int height = pVmRunEvn->GetComfirHeight();
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << height;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExWriteDataDBFunc(unsigned char * ipara,void * pVmEvn) {
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 2)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
const CRegID scriptid = pVmRunEvn->GetScriptRegID();
bool flag = true;
CScriptDBViewCache* scriptDB = pVmRunEvn->GetScriptDB();
CScriptDBOperLog operlog;
int64_t step = (*retdata.at(1)).size() -1;
if (!scriptDB->SetScriptData(scriptid, *retdata.at(0), *retdata.at(1),operlog)) {
flag = false;
} else {
shared_ptr<vector<CScriptDBOperLog> > m_dblog = pVmRunEvn->GetDbLog();
(*m_dblog.get()).push_back(operlog);
}
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << flag;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,step, tem);
}
static RET_DEFINE ExDeleteDataDBFunc(unsigned char * ipara,void * pVmEvn) {
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1)
{
LogPrint("vm", "GetData return error!\n");
return RetFalse(string(__FUNCTION__)+"para err !");
}
CRegID scriptid = pVmRunEvn->GetScriptRegID();
bool flag = true;
CScriptDBViewCache* scriptDB = pVmRunEvn->GetScriptDB();
CScriptDBOperLog operlog;
int64_t nstep = 0;
vector<unsigned char> vValue;
if(scriptDB->GetScriptData(pVmRunEvn->GetComfirHeight(),scriptid, *retdata.at(0), vValue)){
nstep = nstep - (int64_t)(vValue.size()+1);
}
if (!scriptDB->EraseScriptData(scriptid, *retdata.at(0), operlog)) {
LogPrint("vm", "ExDeleteDataDBFunc error key:%s!\n",HexStr(*retdata.at(0)));
flag = false;
} else {
shared_ptr<vector<CScriptDBOperLog> > m_dblog = pVmRunEvn->GetDbLog();
m_dblog.get()->push_back(operlog);
}
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << flag;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,nstep, tem);
}
static RET_DEFINE ExReadDataValueDBFunc(unsigned char * ipara,void * pVmEvn) {
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
CRegID scriptid = pVmRunEvn->GetScriptRegID();
vector_unsigned_char vValue;
CScriptDBViewCache* scriptDB = pVmRunEvn->GetScriptDB();
bool flag =true;
// LogPrint("INFO", "script run read data:%s\n", HexStr(*retdata.at(0)));
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if(!scriptDB->GetScriptData(pVmRunEvn->GetComfirHeight(),scriptid, *retdata.at(0), vValue))
{
flag = false;
}
else
{
(*tem.get()).push_back(vValue);
}
return std::make_tuple (flag,0, tem);
}
static RET_DEFINE ExGetDBSizeFunc(unsigned char * ipara,void * pVmEvn) {
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
CRegID scriptid = pVmRunEvn->GetScriptRegID();
int count = 0;
bool flag = true;
CScriptDBViewCache* scriptDB = pVmRunEvn->GetScriptDB();
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if(!scriptDB->GetScriptDataCount(scriptid,count))
{
flag = false;
}
else
{
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << count;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
}
return std::make_tuple (flag,0, tem);
}
static RET_DEFINE ExGetDBValueFunc(unsigned char * ipara,void * pVmEvn) {
if (SysCfg().GetArg("-isdbtraversal", 0) == 0) {
LogPrint("INFO","%s","ExGetDBValueFunc can't use\n");
return RetFalse(string(__FUNCTION__)+"para err !");
}
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||(retdata.size() != 2 && retdata.size() != 1))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
int index = 0;
bool flag = true;
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
memcpy(&index,&retdata.at(0).get()->at(0),sizeof(int));
if(!(index == 0 ||(index == 1 && retdata.size() == 2)))
{
flag = false;
return std::make_tuple (flag,0, tem);
}
CRegID scriptid = pVmRunEvn->GetScriptRegID();
vector_unsigned_char vValue;
vector<unsigned char> vScriptKey;
if(index == 1)
{
vScriptKey.assign(retdata.at(1).get()->begin(),retdata.at(1).get()->end());
}
CScriptDBViewCache* scriptDB = pVmRunEvn->GetScriptDB();
flag = scriptDB->GetScriptData(pVmRunEvn->GetComfirHeight(),scriptid,index,vScriptKey,vValue);
if(flag){
LogPrint("vm", "Read key:%s,value:%s!\n",HexStr(vScriptKey),HexStr(vValue));
(*tem.get()).push_back(vScriptKey);
(*tem.get()).push_back(vValue);
}
return std::make_tuple (flag,0, tem);
}
static RET_DEFINE ExGetCurTxHash(unsigned char * ipara,void * pVmEvn) {
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
uint256 hash = pVmRunEvn->GetCurTxHash();
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << hash;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
// LogPrint("vm","ExGetCurTxHash:%s",HexStr(hash).c_str());
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExModifyDataDBVavleFunc(unsigned char * ipara,void * pVmEvn)
{
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 2 )
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
CRegID scriptid = pVmRunEvn->GetScriptRegID();
vector_unsigned_char vValue;
bool flag = false;
CScriptDBViewCache* scriptDB = pVmRunEvn->GetScriptDB();
int64_t step = 0;
CScriptDBOperLog operlog;
vector_unsigned_char vTemp;
if(scriptDB->GetScriptData(pVmRunEvn->GetComfirHeight(),scriptid, *retdata.at(0), vTemp)) {
if(scriptDB->SetScriptData(scriptid,*retdata.at(0),*retdata.at(1).get(),operlog))
{
shared_ptr<vector<CScriptDBOperLog> > m_dblog = pVmRunEvn->GetDbLog();
m_dblog.get()->push_back(operlog);
flag = true;
}
}
step =(((int64_t)(*retdata.at(1)).size())- (int64_t)(vTemp.size()) -1);
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << flag;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (flag ,step, tem);
}
static RET_DEFINE ExWriteOutputFunc(unsigned char * ipara,void * pVmEvn)
{
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1 )
{
return RetFalse("para err");
}
vector<CVmOperate> source;
CVmOperate temp;
int Size = ::GetSerializeSize(temp, SER_NETWORK, PROTOCOL_VERSION);
int datadsize = retdata.at(0)->size();
int count = datadsize/Size;
if(datadsize%Size != 0)
{
// assert(0);
return RetFalse("para err");
}
CDataStream ss(*retdata.at(0),SER_DISK, CLIENT_VERSION);
while(count--)
{
ss >> temp;
source.push_back(temp);
}
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if(!pVmRunEvn->InsertOutputData(source)) {
// return RetFalse("InsertOutput err");
return std::make_tuple (-1 ,0, tem);
}
return std::make_tuple (true ,0, tem);
}
static RET_DEFINE ExGetScriptDataFunc(unsigned char * ipara,void * pVmEvn)
{
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 2 || retdata.at(0).get()->size() != 6)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
vector_unsigned_char vValue;
bool flag =true;
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
CScriptDBViewCache* scriptDB = pVmRunEvn->GetScriptDB();
CRegID scriptid(*retdata.at(0));
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if(!scriptDB->GetScriptData(pVmRunEvn->GetComfirHeight(), scriptid, *retdata.at(1), vValue))
{
flag = false;
}
else
{
(*tem.get()).push_back(vValue);
}
return std::make_tuple (flag,0, tem);
}
static RET_DEFINE ExGetScriptIDFunc(unsigned char * ipara,void * pVmEvn)
{
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector_unsigned_char scriptid = pVmRunEvn->GetScriptRegID().GetVec6();
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
(*tem.get()).push_back(scriptid);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExGetCurTxAccountFunc(unsigned char * ipara,void * pVmEvn)
{
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector_unsigned_char vUserId =pVmRunEvn->GetTxAccount().GetVec6();
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
(*tem.get()).push_back(vUserId);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExGetCurTxContactFunc(unsigned char * ipara, void *pVmEvn)
{
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector<unsigned char> contact =pVmRunEvn->GetTxContact();
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
(*tem.get()).push_back(contact);
return std::make_tuple (true,0, tem);
}
enum COMPRESS_TYPE {
U16_TYPE = 0, // U16_TYPE
I16_TYPE = 1, // I16_TYPE
U32_TYPE = 2, // U32_TYPE
I32_TYPE = 3, // I32_TYPE
U64_TYPE = 4, // U64_TYPE
I64_TYPE = 5, // I64_TYPE
NO_TYPE = 6, // NO_TYPE +n (tip char)
};
static bool Decompress(vector<unsigned char>& format,vector<unsigned char> &contact,std::vector<unsigned char> &ret){
try {
CDataStream ds(contact,SER_DISK, CLIENT_VERSION);
CDataStream retdata(SER_DISK, CLIENT_VERSION);
for (auto item = format.begin(); item != format.end();item++) {
switch(*item) {
case U16_TYPE: {
unsigned short i = 0;
ds >> VARINT(i);
retdata<<i;
break;
}
case I16_TYPE:
{
short i = 0;
ds >> VARINT(i);
retdata<<i;
break;
}
case U32_TYPE:
{
short i = 0;
ds >> VARINT(i);
retdata<<i;
break;
}
case I32_TYPE:
{
unsigned int i = 0;
ds >> VARINT(i);
retdata<<i;
break;
}
case U64_TYPE:
{
uint64_t i = 0;
ds >> VARINT(i);
retdata<<i;
break;
}
case I64_TYPE:
{
int64_t i = 0;
ds >> VARINT(i);
retdata<<i;
break;
}
case NO_TYPE:
{
unsigned char temp = 0;
item++;
int te = *item;
while (te--) {
ds >> VARINT(temp);
retdata<<temp;
}
break;
}
default:
{
return ERRORMSG("%s\r\n",__FUNCTION__);
}
}
}
ret.insert(ret.begin(),retdata.begin(),retdata.end());
} catch (...) {
LogPrint("vm","seseril err in funciton:%s",__FUNCTION__);
return false;
}
return true;
}
static RET_DEFINE ExCurDeCompressContactFunc(unsigned char *ipara,void *pVmEvn){
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1 )
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
vector<unsigned char> contact =((CVmRunEvn *)pVmEvn)->GetTxContact();
std::vector<unsigned char> outContact;
if(!Decompress(*retdata.at(0),contact,outContact))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
(*tem.get()).push_back(outContact);
return std::make_tuple (true,0, tem);
}
static RET_DEFINE ExDeCompressContactFunc(unsigned char *ipara,void *pVmEvn){
CVmRunEvn *pVmScript = (CVmRunEvn *)pVmEvn;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 2 || retdata.at(1).get()->size() != 32)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
uint256 hash1(*retdata.at(1));
// LogPrint("vm","ExGetTxContractsFunc1:%s\n",hash1.GetHex().c_str());
bool flag = false;
std::shared_ptr<CBaseTransaction> pBaseTx;
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if (GetTransaction(pBaseTx, hash1, *pVmScript->GetScriptDB(), false)) {
CTransaction *tx = static_cast<CTransaction*>(pBaseTx.get());
std::vector<unsigned char> outContact;
if (!Decompress(*retdata.at(0), tx->vContract, outContact)) {
return RetFalse(string(__FUNCTION__) + "para err !");
}
(*tem.get()).push_back(outContact);
flag = true;
}
return std::make_tuple (flag,0, tem);
}
static RET_DEFINE GetCurTxPayAmountFunc(unsigned char *ipara,void *pVmEvn){
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
uint64_t lvalue =pVmRunEvn->GetValue();
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << lvalue;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
return std::make_tuple (true,0, tem);
}
struct S_APP_ID
{
unsigned char idlen; //!the len of the tag
unsigned char ID[CAppCFund::MAX_TAG_SIZE]; //! the ID for the
const vector<unsigned char> GetIdV() const {
assert(sizeof(ID) >= idlen);
vector<unsigned char> Id(&ID[0], &ID[idlen]);
return (Id);
}
}__attribute((aligned (1)));
static RET_DEFINE GetUserAppAccValue(unsigned char * ipara,void * pVmScript){
CVmRunEvn *pVmScriptRun = (CVmRunEvn *)pVmScript;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1
|| retdata.at(0).get()->size() != sizeof(S_APP_ID))
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
S_APP_ID accid;
memcpy(&accid, &retdata.at(0).get()->at(0), sizeof(S_APP_ID));
bool flag = false;
shared_ptr<CAppUserAccout> sptrAcc;
uint64_t value = 0 ;
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
if(pVmScriptRun->GetAppUserAccout(accid.GetIdV(),sptrAcc))
{
value = sptrAcc->getllValues();
// cout<<"read:"<<endl;
// cout<<sptrAcc->toString()<<endl;
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << value;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
flag = true;
}
return std::make_tuple (flag,0, tem);
}
static RET_DEFINE GetUserAppAccFoudWithTag(unsigned char * ipara,void * pVmScript){
CVmRunEvn *pVmScriptRun = (CVmRunEvn *)pVmScript;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
unsigned int Size(0);
CAppFundOperate temp;
Size = ::GetSerializeSize(temp, SER_NETWORK, PROTOCOL_VERSION);
if(!GetData(ipara,retdata) ||retdata.size() != 1
|| retdata.at(0).get()->size() !=Size)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
CDataStream ss(*retdata.at(0),SER_DISK, CLIENT_VERSION);
CAppFundOperate userfund;
ss>>userfund;
shared_ptr<CAppUserAccout> sptrAcc;
bool flag = false;
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
CAppCFund fund;
if(pVmScriptRun->GetAppUserAccout(userfund.GetAppUserV(),sptrAcc))
{
if(!sptrAcc->GetAppCFund(fund,userfund.GetFundTagV(),userfund.outheight)) {
return RetFalse(string(__FUNCTION__)+"tag err !");
}
CDataStream tep(SER_DISK, CLIENT_VERSION);
tep << fund.getvalue() ;
vector<unsigned char> tep1(tep.begin(),tep.end());
(*tem.get()).push_back(tep1);
flag = true;
}
return std::make_tuple (flag,0, tem);
}
static RET_DEFINE ExWriteOutAppOperateFunc(unsigned char * ipara,void * pVmEvn)
{
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
CAppFundOperate temp;
unsigned int Size = ::GetSerializeSize(temp, SER_NETWORK, PROTOCOL_VERSION);
if(!GetData(ipara,retdata) ||retdata.size() != 1 || (retdata.at(0).get()->size()%Size) != 0 )
{
return RetFalse("para err");
}
int count = retdata.at(0).get()->size()/Size;
CDataStream ss(*retdata.at(0),SER_DISK, CLIENT_VERSION);
int64_t step =-1;
while(count--)
{
ss >> temp;
if(temp.mMoney < 0)
{
return RetFalse("para err");
}
pVmRunEvn->InsertOutAPPOperte(temp.GetAppUserV(),temp);
step +=Size;
}
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
return std::make_tuple (true ,step, tem);
}
static RET_DEFINE ExGetBase58AddrFunc(unsigned char * ipara,void * pVmEvn){
CVmRunEvn *pVmRunEvn = (CVmRunEvn *)pVmEvn;
vector<std::shared_ptr < vector<unsigned char> > > retdata;
if(!GetData(ipara,retdata) ||retdata.size() != 1 || retdata.at(0).get()->size() != 6)
{
return RetFalse(string(__FUNCTION__)+"para err !");
}
CKeyID addrKeyId;
if (!GetKeyId(*pVmRunEvn->GetCatchView(),*retdata.at(0).get(), addrKeyId)) {
return RetFalse(string(__FUNCTION__)+"para err !");
}
string addr = addrKeyId.ToAddress();
auto tem = std::make_shared<std::vector< vector<unsigned char> > >();
vector<unsigned char> vTemp;
vTemp.assign(addr.c_str(),addr.c_str()+addr.length());
(*tem.get()).push_back(vTemp);
return std::make_tuple (true,0, tem);
}
enum CALL_API_FUN {
COMP_FUNC = 0, //!< COMP_FUNC
MULL_MONEY, //!< MULL_MONEY
ADD_MONEY, //!< ADD_MONEY
SUB_MONEY, //!< SUB_MONEY
DIV_MONEY, //!< DIV_MONEY
SHA256_FUNC, //!< SHA256_FUNC
DES_FUNC, //!< DES_FUNC
VERFIY_SIGNATURE_FUNC, //!< VERFIY_SIGNATURE_FUNC
SIGNATURE_FUNC, //!< SIGNATURE_FUNC
PRINT_FUNC, //!< PRINT_FUNC
GETTX_CONTRACT_FUNC, //!< GETTX_CONTRACT_FUNC
GETTX_ACCOUNT_FUNC, //!< GETTX_ACCOUNT_FUNC
GETACCPUB_FUNC, //!< GETACCPUB_FUNC
QUEYACCBALANCE_FUNC, //!< QUEYACCBALANCE_FUNC
GETTXCONFIRH_FUNC, //!< GETTXCONFIRH_FUNC
GETBLOCKHASH_FUNC, //!< GETBLOCKHASH_FUNC
//// tx api
GETCTXCONFIRMH_FUNC, //!< GETCTXCONFIRMH_FUNC
WRITEDB_FUNC, //!< WRITEDB_FUNC
DELETEDB_FUNC, //!< DELETEDB_FUNC
READDB_FUNC, //!< READDB_FUNC
GETDBSIZE_FUNC, //!< GETDBSIZE_FUNC
GETDBVALUE_FUNC, //!< GETDBVALUE_FUNC
GetCURTXHASH_FUNC, //!< GetCURTXHASH_FUNC
MODIFYDBVALUE_FUNC, //!< MODIFYDBVALUE_FUNC
WRITEOUTPUT_FUNC, //!<WRITEOUTPUT_FUNC
GETSCRIPTDATA_FUNC, //!<GETSCRIPTDATA_FUNC
GETSCRIPTID_FUNC, //!<GETSCRIPTID_FUNC
GETCURTXACCOUNT_FUNC, //!<GETCURTXACCOUNT_FUNC
GETCURTXCONTACT_FUNC, //!<GETCURTXCONTACT_FUNC
GETCURDECOMPRESSCONTACR_FUNC, //!<GETCURDECOMPRESSCONTACR_FUNC
GETDECOMPRESSCONTACR_FUNC, //!<GETDECOMPRESSCONTACR_FUNC
GETCURPAYMONEY_FUN, //!<GETCURPAYMONEY_FUN
GET_APP_USER_ACC_VALUE_FUN, //!<GET_APP_USER_ACC_FUN
GET_APP_USER_ACC_FUND_WITH_TAG_FUN, //!<GET_APP_USER_ACC_FUND_WITH_TAG_FUN
GET_WIRITE_OUT_APP_OPERATE_FUN, //!<GET_WIRITE_OUT_APP_OPERATE_FUN
GET_KOALA_ADDRESS_FUN,
};
const static string API_METOHD[] =
{
"COMP_FUNC",
"MULL_MONEY",
"ADD_MONEY",
"SUB_MONEY",
"DIV_MONEY",
"SHA256_FUNC",
"DES_FUNC",
"VERFIY_SIGNATURE_FUNC",
"SIGNATURE_FUNC",
"PRINT_FUNC",
"GETTX_CONTRACT_FUNC",
"GETTX_ACCOUNT_FUNC",
"GETACCPUB_FUNC",
"QUEYACCBALANCE_FUNC",
"GETTXCONFIRH_FUNC",
"GETBLOCKHASH_FUNC",
"GETCTXCONFIRMH_FUNC",
"WRITEDB_FUNC",
"DELETEDB_FUNC",
"READDB_FUNC",
"GETDBSIZE_FUNC",
"GETDBVALUE_FUNC",
"GetCURTXHASH_FUNC",
"MODIFYDBVALUE_FUNC",
"WRITEOUTPUT_FUNC",
"GETSCRIPTDATA_FUNC",
"GETSCRIPTID_FUNC",
"GETCURTXACCOUNT_FUNC",
"GETCURTXCONTACT_FUNC",
"GETCURDECOMPRESSCONTACR_FUNC",
"GETDECOMPRESSCONTACR_FUNC",
"GETCURPAYMONEY_FUN",
"GET_APP_USER_ACC_VALUE_FUN",
"GET_APP_USER_ACC_FUND_WITH_TAG_FUN",
"GET_WIRITE_OUT_APP_OPERATE_FUN",
"GET_KOALA_ADDRESS_FUN" };
const static struct __MapExterFun FunMap[] = { //
{ COMP_FUNC, ExInt64CompFunc }, //
{ MULL_MONEY, ExInt64MullFunc }, //
{ ADD_MONEY, ExInt64AddFunc }, //
{ SUB_MONEY, ExInt64SubFunc }, //
{ DIV_MONEY, ExInt64DivFunc }, //
{ SHA256_FUNC, ExSha256Func }, //
{ DES_FUNC, ExDesFunc }, //
{ VERFIY_SIGNATURE_FUNC, ExVerifySignatureFunc }, //
{ SIGNATURE_FUNC, ExSignatureFunc }, //
{ PRINT_FUNC, ExLogPrintFunc }, //
{GETTX_CONTRACT_FUNC,ExGetTxContractsFunc}, //
{GETTX_ACCOUNT_FUNC,ExGetTxAccountsFunc},
{GETACCPUB_FUNC,ExGetAccountPublickeyFunc},
{QUEYACCBALANCE_FUNC,ExQueryAccountBalanceFunc},
{GETTXCONFIRH_FUNC,ExGetTxConFirmHeightFunc},
{GETBLOCKHASH_FUNC,ExGetBlockHashFunc},
{GETCTXCONFIRMH_FUNC,ExGetCurRunEnvHeightFunc},
{WRITEDB_FUNC,ExWriteDataDBFunc},
{DELETEDB_FUNC,ExDeleteDataDBFunc},
{READDB_FUNC,ExReadDataValueDBFunc},
{GETDBSIZE_FUNC,ExGetDBSizeFunc},
{GETDBVALUE_FUNC,ExGetDBValueFunc},
{GetCURTXHASH_FUNC,ExGetCurTxHash},
{MODIFYDBVALUE_FUNC,ExModifyDataDBVavleFunc},
{WRITEOUTPUT_FUNC,ExWriteOutputFunc},
{GETSCRIPTDATA_FUNC,ExGetScriptDataFunc},
{GETSCRIPTID_FUNC,ExGetScriptIDFunc},
{GETCURTXACCOUNT_FUNC,ExGetCurTxAccountFunc },
{GETCURTXCONTACT_FUNC,ExGetCurTxContactFunc },
{GETCURDECOMPRESSCONTACR_FUNC,ExCurDeCompressContactFunc },
{GETDECOMPRESSCONTACR_FUNC,ExDeCompressContactFunc },
{GETCURPAYMONEY_FUN,GetCurTxPayAmountFunc},
{GET_APP_USER_ACC_VALUE_FUN,GetUserAppAccValue},
{GET_APP_USER_ACC_FUND_WITH_TAG_FUN,GetUserAppAccFoudWithTag},
{GET_WIRITE_OUT_APP_OPERATE_FUN,ExWriteOutAppOperateFunc},
{GET_KOALA_ADDRESS_FUN,ExGetBase58AddrFunc},
};
RET_DEFINE CallExternalFunc(INT16U method, unsigned char *ipara,CVmRunEvn *pVmEvn) {
return FunMap[method].fun(ipara, pVmEvn);
}
int64_t CVm8051::run(uint64_t maxstep, CVmRunEvn *pVmEvn) {
INT8U code = 0;
int64_t step = 0; //uint64_t
if((maxstep == 0) || (NULL == pVmEvn)){
return -1;
}
while (1) {
code = GetOpcode();
StepRun(code);
step++;
//call func out of 8051
if (Sys.PC == 0x0012) {
//get what func will be called
INT16U methodID = ((INT16U) GetExRam(VM_FUN_CALL_ADDR) | ((INT16U) GetExRam(VM_FUN_CALL_ADDR+1) << 8));
unsigned char *ipara = (unsigned char *) GetExRamAddr(VM_SHARE_ADDR); //input para
RET_DEFINE retdata = CallExternalFunc(methodID, ipara, pVmEvn);
memset(ipara, 0, MAX_SHARE_RAM);
step += std::get<1>(retdata) - 1;
if (std::get<0>(retdata) == 1) {
auto tem = std::get<2>(retdata);
int pos = 0;
int totalsize = 0;
for (auto& it : *tem.get()) {
totalsize += it.size() + 2;
}
if (totalsize + 2 < MAX_SHARE_RAM) { //if data not over
for (auto& it : *tem.get()) {
int size = it.size();
memcpy(&ipara[pos], &size, 2);
memcpy(&ipara[pos + 2], &it.at(0), size);
pos += size + 2;
}
}
}
else if(std::get<0>(retdata) == -1){
LogPrint("CONTRACT_TX", "call method id:%d methodName:%s\n", methodID, API_METOHD[methodID]);
return -1;
}
else
{
}
} else if (Sys.PC == 0x0008) {
INT8U result = GetExRam(0xEFFD);
if (result == 0x01) {
return step;
}
return 0;
}
if (step >= (int64_t)MAX_BLOCK_RUN_STEP || step >= (int64_t)maxstep){
LogPrint("CONTRACT_TX", "failed step:%ld\n", step);
return -1; //force return
}
}
return 1;
}
bool CVm8051::run() {
INT8U code = 0;
// INT16U flag;
while (1) {
code = GetOpcode();
StepRun(code);
// UpDataDebugInfo();
//call func out of 8051
if (Sys.PC == 0x0012) {
//get what func will be called
INT16U method = ((INT16U) GetExRam(VM_FUN_CALL_ADDR) | ((INT16U) GetExRam(VM_FUN_CALL_ADDR+1) << 8));
// flag = method;
unsigned char *ipara = (unsigned char *) GetExRamAddr(VM_SHARE_ADDR); //input para
CVmRunEvn *pVmScript = NULL;
RET_DEFINE retdata = CallExternalFunc(method, ipara, pVmScript);
//memset(ipara, 0, MAX_SHARE_RAM);
memset(ipara, 0, 8);
if (std::get<0>(retdata)) {
auto tem = std::get<2>(retdata);
int pos = 0;
int totalsize = 0;
for (auto& it : *tem.get()) {
totalsize += it.size() + 2;
}
if (totalsize + 2 < MAX_SHARE_RAM) {
for (auto& it : *tem.get()) {
int size = it.size();
memcpy(&ipara[pos], &size, 2);
memcpy(&ipara[pos + 2], &it.at(0), size);
pos += size + 2;
}
}
}
}else if (Sys.PC == 0x0008) {
INT8U result=GetExRam(0xEFFD);
if(result == 0x01)
{
return 1;
}
return 0;
}
}
return 1;
}
void CVm8051::SetExRamData(INT16U addr, const vector<unsigned char> data) {
memcpy(&m_ExRam[addr], &data[0], data.size());
}
void CVm8051::StepRun(INT8U code) {
switch (code) {
case 0x00: {
Opcode_00_NOP();
break;
}
case 0x01: {
Opcode_01_AJMP_Addr11();
break;
}
case 0x02: {
Opcode_02_LJMP_Addr16();
break;
}
case 0x03: {
Opcode_03_RR_A();
break;
}
case 0x04: {
Opcode_04_INC_A();
break;
}
case 0x05: {
Opcode_05_INC_Direct();
break;
}
case 0x06: {
Opcode_06_INC_R0_1();
break;
}
case 0x07: {
Opcode_07_INC_R1_1();
break;
}
case 0x08: {
Opcode_08_INC_R0();
break;
}
case 0x09: {
Opcode_09_INC_R1();
break;
}
case 0x0A: {
Opcode_0A_INC_R2();
break;
}
case 0x0B: {
Opcode_0B_INC_R3();
break;
}
case 0x0C: {
Opcode_0C_INC_R4();
break;
}
case 0x0D: {
Opcode_0D_INC_R5();
break;
}
case 0x0E: {
Opcode_0E_INC_R6();
break;
}
case 0x0F: {
Opcode_0F_INC_R7();
break;
}
case 0x10: {
Opcode_10_JBC_Bit_Rel();
break;
}
case 0x11: {
Opcode_11_ACALL_Addr11();
break;
}
case 0x12: {
Opcode_12_LCALL_Addr16();
break;
}
case 0x13: {
Opcode_13_RRC_A();
break;
}
case 0x14: {
Opcode_14_DEC_A();
break;
}
case 0x15: {
Opcode_15_DEC_Direct();
break;
}
case 0x16: {
Opcode_16_DEC_R0_1();
break;
}
case 0x17: {
Opcode_17_DEC_R1_1();
break;
}
case 0x18: {
Opcode_18_DEC_R0();
break;
}
case 0x19: {
Opcode_19_DEC_R1();
break;
}
case 0x1A: {
Opcode_1A_DEC_R2();
break;
}
case 0x1B: {
Opcode_1B_DEC_R3();
break;
}
case 0x1C: {
Opcode_1C_DEC_R4();
break;
}
case 0x1D: {
Opcode_1D_DEC_R5();
break;
}
case 0x1E: {
Opcode_1E_DEC_R6();
break;
}
case 0x1F: {
Opcode_1F_DEC_R7();
break;
}
case 0x20: {
Opcode_20_JB_Bit_Rel();
break;
}
case 0x21: {
Opcode_21_AJMP_Addr11();
break;
}
case 0x22: {
Opcode_22_RET();
break;
}
case 0x23: {
Opcode_23_RL_A();
break;
}
case 0x24: {
Opcode_24_ADD_A_Data();
break;
}
case 0x25: {
Opcode_25_ADD_A_Direct();
break;
}
case 0x26: {
Opcode_26_ADD_A_R0_1();
break;
}
case 0x27: {
Opcode_27_ADD_A_R1_1();
break;
}
case 0x28: {
Opcode_28_ADD_A_R0();
break;
}
case 0x29: {
Opcode_29_ADD_A_R1();
break;
}
case 0x2A: {
Opcode_2A_ADD_A_R2();
break;
}
case 0x2B: {
Opcode_2B_ADD_A_R3();
break;
}
case 0x2C: {
Opcode_2C_ADD_A_R4();
break;
}
case 0x2D: {
Opcode_2D_ADD_A_R5();
break;
}
case 0x2E: {
Opcode_2E_ADD_A_R6();
break;
}
case 0x2F: {
Opcode_2F_ADD_A_R7();
break;
}
case 0x30: {
Opcode_30_JNB_Bit_Rel();
break;
}
case 0x31: {
Opcode_31_ACALL_Addr11();
break;
}
case 0x32: {
Opcode_32_RETI();
break;
}
case 0x33: {
Opcode_33_RLC_A();
break;
}
case 0x34: {
Opcode_34_ADDC_A_Data();
break;
}
case 0x35: {
Opcode_35_ADDC_A_Direct();
break;
}
case 0x36: {
Opcode_36_ADDC_A_R0_1();
break;
}
case 0x37: {
Opcode_37_ADDC_A_R1_1();
break;
}
case 0x38: {
Opcode_38_ADDC_A_R0();
break;
}
case 0x39: {
Opcode_39_ADDC_A_R1();
break;
}
case 0x3A: {
Opcode_3A_ADDC_A_R2();
break;
}
case 0x3B: {
Opcode_3B_ADDC_A_R3();
break;
}
case 0x3C: {
Opcode_3C_ADDC_A_R4();
break;
}
case 0x3D: {
Opcode_3D_ADDC_A_R5();
break;
}
case 0x3E: {
Opcode_3E_ADDC_A_R6();
break;
}
case 0x3F: {
Opcode_3F_ADDC_A_R7();
break;
}
case 0x40: {
Opcode_40_JC_Rel();
break;
}
case 0x41: {
Opcode_41_AJMP_Addr11();
break;
}
case 0x42: {
Opcode_42_ORL_Direct_A();
break;
}
case 0x43: {
Opcode_43_ORL_Direct_Data();
break;
}
case 0x44: {
Opcode_44_ORL_A_Data();
break;
}
case 0x45: {
Opcode_45_ORL_A_Direct();
break;
}
case 0x46: {
Opcode_46_ORL_A_R0_1();
break;
}
case 0x47: {
Opcode_47_ORL_A_R1_1();
break;
}
case 0x48: {
Opcode_48_ORL_A_R0();
break;
}
case 0x49: {
Opcode_49_ORL_A_R1();
break;
}
case 0x4A: {
Opcode_4A_ORL_A_R2();
break;
}
case 0x4B: {
Opcode_4B_ORL_A_R3();
break;
}
case 0x4C: {
Opcode_4C_ORL_A_R4();
break;
}
case 0x4D: {
Opcode_4D_ORL_A_R5();
break;
}
case 0x4E: {
Opcode_4E_ORL_A_R6();
break;
}
case 0x4F: {
Opcode_4F_ORL_A_R7();
break;
}
case 0x50: {
Opcode_50_JNC_Rel();
break;
}
case 0x51: {
Opcode_51_ACALL_Addr11();
break;
}
case 0x52: {
Opcode_52_ANL_Direct_A();
break;
}
case 0x53: {
Opcode_53_ANL_Direct_Data();
break;
}
case 0x54: {
Opcode_54_ANL_A_Data();
break;
}
case 0x55: {
Opcode_55_ANL_A_Direct();
break;
}
case 0x56: {
Opcode_56_ANL_A_R0_1();
break;
}
case 0x57: {
Opcode_57_ANL_A_R1_1();
break;
}
case 0x58: {
Opcode_58_ANL_A_R0();
break;
}
case 0x59: {
Opcode_59_ANL_A_R1();
break;
}
case 0x5A: {
Opcode_5A_ANL_A_R2();
break;
}
case 0x5B: {
Opcode_5B_ANL_A_R3();
break;
}
case 0x5C: {
Opcode_5C_ANL_A_R4();
break;
}
case 0x5D: {
Opcode_5D_ANL_A_R5();
break;
}
case 0x5E: {
Opcode_5E_ANL_A_R6();
break;
}
case 0x5F: {
Opcode_5F_ANL_A_R7();
break;
}
case 0x60: {
Opcode_60_JZ_Rel();
break;
}
case 0x61: {
Opcode_61_AJMP_Addr11();
break;
}
case 0x62: {
Opcode_62_XRL_Direct_A();
break;
}
case 0x63: {
Opcode_63_XRL_Direct_Data();
break;
}
case 0x64: {
Opcode_64_XRL_A_Data();
break;
}
case 0x65: {
Opcode_65_XRL_A_Direct();
break;
}
case 0x66: {
Opcode_66_XRL_A_R0_1();
break;
}
case 0x67: {
Opcode_67_XRL_A_R1_1();
break;
}
case 0x68: {
Opcode_68_XRL_A_R0();
break;
}
case 0x69: {
Opcode_69_XRL_A_R1();
break;
}
case 0x6A: {
Opcode_6A_XRL_A_R2();
break;
}
case 0x6B: {
Opcode_6B_XRL_A_R3();
break;
}
case 0x6C: {
Opcode_6C_XRL_A_R4();
break;
}
case 0x6D: {
Opcode_6D_XRL_A_R5();
break;
}
case 0x6E: {
Opcode_6E_XRL_A_R6();
break;
}
case 0x6F: {
Opcode_6F_XRL_A_R7();
break;
}
case 0x70: {
Opcode_70_JNZ_Rel();
break;
}
case 0x71: {
Opcode_71_ACALL_Addr11();
break;
}
case 0x72: {
Opcode_72_ORL_C_Direct();
break;
}
case 0x73: {
Opcode_73_JMP_A_DPTR();
break;
}
case 0x74: {
Opcode_74_MOV_A_Data();
break;
}
case 0x75: {
Opcode_75_MOV_Direct_Data();
break;
}
case 0x76: {
Opcode_76_MOV_R0_1_Data();
break;
}
case 0x77: {
Opcode_77_MOV_R1_1_Data();
break;
}
case 0x78: {
Opcode_78_MOV_R0_Data();
break;
}
case 0x79: {
Opcode_79_MOV_R1_Data();
break;
}
case 0x7A: {
Opcode_7A_MOV_R2_Data();
break;
}
case 0x7B: {
Opcode_7B_MOV_R3_Data();
break;
}
case 0x7C: {
Opcode_7C_MOV_R4_Data();
break;
}
case 0x7D: {
Opcode_7D_MOV_R5_Data();
break;
}
case 0x7E: {
Opcode_7E_MOV_R6_Data();
break;
}
case 0x7F: {
Opcode_7F_MOV_R7_Data();
break;
}
case 0x80: {
Opcode_80_SJMP_Rel();
break;
}
case 0x81: {
Opcode_81_AJMP_Addr11();
break;
}
case 0x82: {
Opcode_82_ANL_C_Bit();
break;
}
case 0x83: {
Opcode_83_MOVC_A_PC();
break;
}
case 0x84: {
Opcode_84_DIV_AB();
break;
}
case 0x85: {
Opcode_85_MOV_Direct_Direct();
break;
}
case 0x86: {
Opcode_86_MOV_Direct_R0_1();
break;
}
case 0x87: {
Opcode_87_MOV_Direct_R1_1();
break;
}
case 0x88: {
Opcode_88_MOV_Direct_R0();
break;
}
case 0x89: {
Opcode_89_MOV_Direct_R1();
break;
}
case 0x8A: {
Opcode_8A_MOV_Direct_R2();
break;
}
case 0x8B: {
Opcode_8B_MOV_Direct_R3();
break;
}
case 0x8C: {
Opcode_8C_MOV_Direct_R4();
break;
}
case 0x8D: {
Opcode_8D_MOV_Direct_R5();
break;
}
case 0x8E: {
Opcode_8E_MOV_Direct_R6();
break;
}
case 0x8F: {
Opcode_8F_MOV_Direct_R7();
break;
}
case 0x90: {
Opcode_90_MOV_DPTR_Data();
break;
}
case 0x91: {
Opcode_91_ACALL_Addr11();
break;
}
case 0x92: {
Opcode_92_MOV_Bit_C();
break;
}
case 0x93: {
Opcode_93_MOVC_A_DPTR();
break;
}
case 0x94: {
Opcode_94_SUBB_A_Data();
break;
}
case 0x95: {
Opcode_95_SUBB_A_Direct();
break;
}
case 0x96: {
Opcode_96_SUBB_A_R0_1();
break;
}
case 0x97: {
Opcode_97_SUBB_A_R1_1();
break;
}
case 0x98: {
Opcode_98_SUBB_A_R0();
break;
}
case 0x99: {
Opcode_99_SUBB_A_R1();
break;
}
case 0x9A: {
Opcode_9A_SUBB_A_R2();
break;
}
case 0x9B: {
Opcode_9B_SUBB_A_R3();
break;
}
case 0x9C: {
Opcode_9C_SUBB_A_R4();
break;
}
case 0x9D: {
Opcode_9D_SUBB_A_R5();
break;
}
case 0x9E: {
Opcode_9E_SUBB_A_R6();
break;
}
case 0x9F: {
Opcode_9F_SUBB_A_R7();
break;
}
case 0xA0: {
Opcode_A0_ORL_C_Bit();
break;
}
case 0xA1: {
Opcode_A1_AJMP_Addr11();
break;
}
case 0xA2: {
Opcode_A2_MOV_C_Bit();
break;
}
case 0xA3: {
Opcode_A3_INC_DPTR();
break;
}
case 0xA4: {
Opcode_A4_MUL_AB();
break;
}
case 0xA5: {
Opcode_A5();
break;
}
case 0xA6: {
Opcode_A6_MOV_R0_1_Direct();
break;
}
case 0xA7: {
Opcode_A7_MOV_R1_1_Direct();
break;
}
case 0xA8: {
Opcode_A8_MOV_R0_Direct();
break;
}
case 0xA9: {
Opcode_A9_MOV_R1_Direct();
break;
}
case 0xAA: {
Opcode_AA_MOV_R2_Direct();
break;
}
case 0xAB: {
Opcode_AB_MOV_R3_Direct();
break;
}
case 0xAC: {
Opcode_AC_MOV_R4_Direct();
break;
}
case 0xAD: {
Opcode_AD_MOV_R5_Direct();
break;
}
case 0xAE: {
Opcode_AE_MOV_R6_Direct();
break;
}
case 0xAF: {
Opcode_AF_MOV_R7_Direct();
break;
}
case 0xB0: {
Opcode_B0_ANL_C_Bit_1();
break;
}
case 0xB1: {
Opcode_B1_ACALL_Addr11();
break;
}
case 0xB2: {
Opcode_B2_CPL_Bit();
break;
}
case 0xB3: {
Opcode_B3_CPL_C();
break;
}
case 0xB4: {
Opcode_B4_CJNE_A_Data_Rel();
break;
}
case 0xB5: {
Opcode_B5_CJNE_A_Direct_Rel();
break;
}
case 0xB6: {
Opcode_B6_CJNE_R0_1_Data_Rel();
break;
}
case 0xB7: {
Opcode_B7_CJNE_R1_1_Data_Rel();
break;
}
case 0xB8: {
Opcode_B8_CJNE_R0_Data_Rel();
break;
}
case 0xB9: {
Opcode_B9_CJNE_R1_Data_Rel();
break;
}
case 0xBA: {
Opcode_BA_CJNE_R2_Data_Rel();
break;
}
case 0xBB: {
Opcode_BB_CJNE_R3_Data_Rel();
break;
}
case 0xBC: {
Opcode_BC_CJNE_R4_Data_Rel();
break;
}
case 0xBD: {
Opcode_BD_CJNE_R5_Data_Rel();
break;
}
case 0xBE: {
Opcode_BE_CJNE_R6_Data_Rel();
break;
}
case 0xBF: {
Opcode_BF_CJNE_R7_Data_Rel();
break;
}
case 0xC0: {
Opcode_C0_PUSH_Direct();
break;
}
case 0xC1: {
Opcode_C1_AJMP_Addr11();
break;
}
case 0xC2: {
Opcode_C2_CLR_Bit();
break;
}
case 0xC3: {
Opcode_C3_CLR_C();
break;
}
case 0xC4: {
Opcode_C4_SWAP_A();
break;
}
case 0xC5: {
Opcode_C5_XCH_A_Direct();
break;
}
case 0xC6: {
Opcode_C6_XCH_A_R0_1();
break;
}
case 0xC7: {
Opcode_C7_XCH_A_R1_1();
break;
}
case 0xC8: {
Opcode_C8_XCH_A_R0();
break;
}
case 0xC9: {
Opcode_C9_XCH_A_R1();
break;
}
case 0xCA: {
Opcode_CA_XCH_A_R2();
break;
}
case 0xCB: {
Opcode_CB_XCH_A_R3();
break;
}
case 0xCC: {
Opcode_CC_XCH_A_R4();
break;
}
case 0xCD: {
Opcode_CD_XCH_A_R5();
break;
}
case 0xCE: {
Opcode_CE_XCH_A_R6();
break;
}
case 0xCF: {
Opcode_CF_XCH_A_R7();
break;
}
case 0xD0: {
Opcode_D0_POP_Direct();
break;
}
case 0xD1: {
Opcode_D1_ACALL_Addr11();
break;
}
case 0xD2: {
Opcode_D2_SETB_Bit();
break;
}
case 0xD3: {
Opcode_D3_SETB_C();
break;
}
case 0xD4: {
Opcode_D4_DA_A();
break;
}
case 0xD5: {
Opcode_D5_DJNZ_Direct_Rel();
break;
}
case 0xD6: {
Opcode_D6_XCHD_A_R0_1();
break;
}
case 0xD7: {
Opcode_D7_XCHD_A_R1_1();
break;
}
case 0xD8: {
Opcode_D8_DJNZ_R0_Rel();
break;
}
case 0xD9: {
Opcode_D9_DJNZ_R1_Rel();
break;
}
case 0xDA: {
Opcode_DA_DJNZ_R2_Rel();
break;
}
case 0xDB: {
Opcode_DB_DJNZ_R3_Rel();
break;
}
case 0xDC: {
Opcode_DC_DJNZ_R4_Rel();
break;
}
case 0xDD: {
Opcode_DD_DJNZ_R5_Rel();
break;
}
case 0xDE: {
Opcode_DE_DJNZ_R6_Rel();
break;
}
case 0xDF: {
Opcode_DF_DJNZ_R7_Rel();
break;
}
case 0xE0: {
Opcode_E0_MOVX_A_DPTR();
break;
}
case 0xE1: {
Opcode_E1_AJMP_Addr11();
break;
}
case 0xE2: {
Opcode_E2_MOVX_A_R0_1();
break;
}
case 0xE3: {
Opcode_E3_MOVX_A_R1_1();
break;
}
case 0xE4: {
Opcode_E4_CLR_A();
break;
}
case 0xE5: {
Opcode_E5_MOV_A_Direct();
break;
}
case 0xE6: {
Opcode_E6_MOV_A_R0_1();
break;
}
case 0xE7: {
Opcode_E7_MOV_A_R1_1();
break;
}
case 0xE8: {
Opcode_E8_MOV_A_R0();
break;
}
case 0xE9: {
Opcode_E9_MOV_A_R1();
break;
}
case 0xEA: {
Opcode_EA_MOV_A_R2();
break;
}
case 0xEB: {
Opcode_EB_MOV_A_R3();
break;
}
case 0xEC: {
Opcode_EC_MOV_A_R4();
break;
}
case 0xED: {
Opcode_ED_MOV_A_R5();
break;
}
case 0xEE: {
Opcode_EE_MOV_A_R6();
break;
}
case 0xEF: {
Opcode_EF_MOV_A_R7();
break;
}
case 0xF0: {
Opcode_F0_MOVX_DPTR_A();
break;
}
case 0xF1: {
Opcode_F1_ACALL_Addr11();
break;
}
case 0xF2: {
Opcode_F2_MOVX_R0_1_A();
break;
}
case 0xF3: {
Opcode_F3_MOVX_R1_1_A();
break;
}
case 0xF4: {
Opcode_F4_CPL_A();
break;
}
case 0xF5: {
Opcode_F5_MOV_Direct_A();
break;
}
case 0xF6: {
Opcode_F6_MOV_R0_1_A();
break;
}
case 0xF7: {
Opcode_F7_MOV_R1_1_A();
break;
}
case 0xF8: {
Opcode_F8_MOV_R0_A();
break;
}
case 0xF9: {
Opcode_F9_MOV_R1_A();
break;
}
case 0xFA: {
Opcode_FA_MOV_R2_A();
break;
}
case 0xFB: {
Opcode_FB_MOV_R3_A();
break;
}
case 0xFC: {
Opcode_FC_MOV_R4_A();
break;
}
case 0xFD: {
Opcode_FD_MOV_R5_A();
break;
}
case 0xFE: {
Opcode_FE_MOV_R6_A();
break;
}
case 0xFF: {
Opcode_FF_MOV_R7_A();
break;
}
default:
// assert(0);
break;
}
}
bool CVm8051::GetBitFlag(INT8U addr) {
return (GetBitRamRef(addr) & (BIT0 << (addr % 8))) != 0;
}
void CVm8051::SetBitFlag(INT8U addr) {
GetBitRamRef(addr) |= (BIT0 << (addr % 8));
if (addr >= 0xe0 && addr <= 0xe7) {
Updata_A_P_Flag();
}
}
void CVm8051::ClrBitFlag(INT8U addr) {
GetBitRamRef(addr) &= (~(BIT0 << (addr % 8)));
if (addr >= 0xe0 && addr <= 0xe7)
{
Updata_A_P_Flag();
}
}
INT8U CVm8051::GetOpcode(void) const {
return m_ExeFile[Sys.PC];
}
INT8U& CVm8051::GetRamRef(INT8U addr) {
if (addr > 0x7F) {
return m_ChipSfr[addr];
} else {
return m_ChipRam[addr];
}
}
INT16U CVm8051::GetDebugOpcode(void) const {
INT16U temp = 0;
memcpy(&temp, &m_ExeFile[Sys.PC], 2);
return temp;
}
bool CVm8051::GetDebugPC(INT16U pc) const {
return (pc == Sys.PC);
}
void CVm8051::GetOpcodeData(void * const p, INT8U len) const {
memcpy(p, &m_ExeFile[Sys.PC + 1], len);
}
void CVm8051::AJMP(INT8U opCode, INT8U data) {
INT16U tmppc = Sys.PC + 2;
tmppc &= 0xF800;
tmppc |= ((((((INT16U) opCode) >> 5) & 0x7) << 8) | ((INT16U) data));
Sys.PC = tmppc;
}
void CVm8051::ACALL(INT8U opCode) {
INT8U data = Get1Opcode();
Sys.PC += 2;
Sys.sp = Sys.sp() + 1;
SetRamDataAt(Sys.sp(), (INT8U) (Sys.PC & 0x00ff));
Sys.sp = Sys.sp() + 1;
SetRamDataAt(Sys.sp(), (INT8U) (Sys.PC >> 8));
Sys.PC = ((Sys.PC & 0xF800) | (((((INT16U) opCode) >> 5) << 8) | (INT16U) data));
}
void CVm8051::UpDataDebugInfo(void) {
d_Rges.R0 = Rges.R0();
d_Rges.R1 = Rges.R1();
d_Rges.R2 = Rges.R2();
d_Rges.R3 = Rges.R3();
d_Rges.R4 = Rges.R4();
d_Rges.R5 = Rges.R5();
d_Rges.R6 = Rges.R6();
d_Rges.R7 = Rges.R7();
d_Sys.a = Sys.a();
d_Sys.b = Sys.b();
d_Sys.sp = Sys.sp();
d_Sys.dptr = Sys.dptr();
d_Sys.psw = Sys.psw();
d_Sys.PC = Sys.PC;
}
void * CVm8051::GetExRamAddr(INT16U addr) const {
// Assert(addr < sizeof(m_ExRam));
return (void *) &m_ExRam[addr];
}
INT8U CVm8051::GetExRam(INT16U addr) const {
// Assert(addr < sizeof(m_ExRam));
return m_ExRam[addr];
}
INT8U CVm8051::SetExRam(INT16U addr, INT8U data) {
// Assert(addr < sizeof(m_ExRam));
return m_ExRam[addr] = data;
}
void * CVm8051::GetPointRamAddr(INT16U addr) const {
// Assert(addr < sizeof(m_ChipRam));
return (void *) &m_ChipRam[addr];
}
INT8U CVm8051::GetRamDataAt(INT8U addr) {
return m_ChipRam[addr];
}
INT8U CVm8051::SetRamDataAt(INT8U addr, INT8U data) {
return m_ChipRam[addr] = data;
}
INT8U CVm8051::GetRamData(INT8U addr) {
return GetRamRef(addr);
}
INT8U CVm8051::SetRamData(INT8U addr, INT8U data) {
GetRamRef(addr) = data;
return data;
}
void* CVm8051::GetPointFileAddr(INT16U addr) const {
Assert(addr < sizeof(m_ExeFile));
return (void*) &m_ExeFile[addr];
}
void CVm8051::Opcode_02_LJMP_Addr16(void) {
INT8U temp[2];
INT16U data;
GetOpcodeData(temp, 2);
data = (((INT16U) (temp[0])) << 8);
Sys.PC = data | temp[1];
}
void CVm8051::Opcode_03_RR_A(void) {
INT8U temp = (Sys.a() & 0x1);
Sys.a = Sys.a() >> 1;
Sys.a = Sys.a() | (temp << 7);
++Sys.PC;
}
void CVm8051::Opcode_05_INC_Direct(void) {
INT8U temp = 0;
INT8U addr = Get1Opcode();
temp = GetRamData(addr);
++temp;
SetRamData(addr, temp);
Sys.PC = Sys.PC + 2;
}
void CVm8051::Opcode_06_INC_R0_1(void) {
INT8U data = 0;
INT8U addr = Rges.R0();
data = GetRamDataAt(addr);
++data;
SetRamDataAt(addr, data);
++Sys.PC;
}
void CVm8051::Opcode_07_INC_R1_1(void) {
INT8U data = 0;
INT8U addr = Rges.R1();
data = GetRamDataAt(addr);
++data;
SetRamDataAt(addr, data);
++Sys.PC;
}
void CVm8051::Opcode_10_JBC_Bit_Rel(void) {
INT8U temp[2];
char tem2;
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
// Assert(temp[0]<=0xF7);
// if (temp[0] <= 0x7F) {
if (GetBitFlag((temp[0]))) {
ClrBitFlag(temp[0]);
memcpy(&tem2, &temp[1], sizeof(temp[1]));
Sys.PC += tem2;
}
}
INT16U CVm8051::GetLcallAddr(void) {
INT16U addr = 0;
GetOpcodeData((INT8U*) &addr, 2);
Assert(GetOpcode() == 0x12);
return (addr >> 8) | (addr << 8);
}
void CVm8051::Opcode_12_LCALL_Addr16(void) {
// INT8U temp = 0;
INT16U addr = 0;
// void *p = NULL;
GetOpcodeData((INT8U*) &addr, 2);
Sys.PC += 3;
Sys.sp = Sys.sp() + 1;
SetRamDataAt(Sys.sp(), (INT8U) (Sys.PC & 0x00ff));
Sys.sp = Sys.sp() + 1;
SetRamDataAt(Sys.sp(), (INT8U) (Sys.PC >> 8));
// GetOpcodeData(&Sys.PC,2);
Sys.PC = (addr >> 8) | (addr << 8);
}
void CVm8051::Opcode_13_RRC_A(void) {
INT8U temp = Sys.a() & BIT0;
Sys.a = ((Sys.a() >> 1) | (Sys.psw().cy << 7));
Sys.psw().cy = (temp == 0) ? 0 : 1;
++Sys.PC;
}
void CVm8051::Opcode_14_DEC_A(void) {
Sys.a = Sys.a() - 1;
++Sys.PC;
}
void CVm8051::Opcode_15_DEC_Direct(void) {
INT8U temp = 0;
INT8U addr = Get1Opcode();
temp = GetRamData(addr);
--temp;
SetRamData(addr, temp);
Sys.PC = Sys.PC + 2;
}
void CVm8051::Opcode_16_DEC_R0_1(void) {
INT8U temp = 0;
INT8U addr = Rges.R0();
temp = GetRamDataAt(addr);
--temp;
SetRamDataAt(addr, temp);
++Sys.PC;
}
void CVm8051::Opcode_17_DEC_R1_1(void) {
INT8U temp = 0;
INT8U addr = Rges.R1();
temp = GetRamDataAt(addr);
temp--;
SetRamDataAt(addr, temp);
++Sys.PC;
}
void CVm8051::Opcode_20_JB_Bit_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (GetBitFlag((temp[0]))) {
char tem2;
memcpy(&tem2, &temp[1], sizeof(temp[1]));
Sys.PC += tem2;
// Sys.PC = GetTargPC(temp[1]);
}
}
void CVm8051::Opcode_22_RET(void) {
INT8U temp = 0;
temp = GetRamDataAt(Sys.sp());
Sys.PC = (Sys.PC & 0x00FF) | (((INT16U) temp) << 8);
Sys.sp = Sys.sp() - 1;
temp = GetRamDataAt(Sys.sp());
Sys.PC = (Sys.PC & 0xFF00) | temp;
Sys.sp = Sys.sp() - 1;
}
void CVm8051::Opcode_23_RL_A(void) {
INT8U temp = Sys.a() & 0x80;
INT8U tem2 = Sys.a();
Sys.a = (INT8U) ((tem2 << 1) | (temp >> 7));
++Sys.PC;
}
void CVm8051::MD_ADDC(INT8U data) {
INT8U flagAC = Sys.psw().cy;
if (flagAC > 1) {
// assert(0);
flagAC = 1;
}
INT16U tep = (INT16U) Sys.a() + (INT16U) data + flagAC;
INT16U tep2 = ((INT16U) (Sys.a() & 0x7F) + (INT16U) (data & 0x7F)) + flagAC;
if ((Sys.a() & 0x0f) + (data & 0x0f) + flagAC > 0x0F) {
Sys.psw().ac = 1;
} else {
Sys.psw().ac = 0;
}
if (tep > 0xFF) {
Sys.psw().cy = 1;
} else {
Sys.psw().cy = 0;
}
flagAC = 0;
if (tep > 0xFF) {
flagAC++;
}
if (tep2 > 0x7F) {
flagAC++;
}
Sys.psw().ov = flagAC == 1 ? 1 : 0;
Sys.a = (INT8U) tep;
}
void CVm8051::MD_SUBB(INT8U data) {
INT16U tepa = Sys.a();
INT8U bcy = Sys.psw().cy;
// data += Sys.psw().cy;
if ((tepa & 0x0f) < (data & 0x0f) + Sys.psw().cy) {
Sys.psw().ac = 1;
} else {
Sys.psw().ac = 0;
}
if (tepa < data + bcy) {
Sys.psw().cy = 1;
} else {
Sys.psw().cy = 0;
}
INT8U flagac = 0;
if (tepa < data + bcy) {
flagac++;
}
if ((tepa & 0x7F) < (data & 0x7F) + bcy) {
flagac++;
}
Sys.psw().ov = flagac == 1 ? 1 : 0;
Sys.a = (INT8U) (tepa - data - bcy);
}
void CVm8051::MD_ADD(INT8U data) {
INT16U tep = (INT16U) Sys.a() + (INT16U) data;
INT16U tep2 = ((INT16U) (Sys.a() & 0x7F) + (INT16U) (data & 0x7F));
if ((Sys.a() & 0x0f) + (data & 0x0f) > 0x0F) {
Sys.psw().ac = 1;
} else {
Sys.psw().ac = 0;
}
if (tep > 0xFF) {
Sys.psw().cy = 1;
} else {
Sys.psw().cy = 0;
}
INT8U flagAC = 0;
if (tep > 0xFF) {
flagAC++;
}
if (tep2 > 0x7F) {
flagAC++;
}
Sys.psw().ov = flagAC == 1 ? 1 : 0;
Sys.a = (INT8U) tep;
}
void CVm8051::Opcode_30_JNB_Bit_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
// Assert(temp[0]<0xF7);
Sys.PC += 3;
if (!GetBitFlag((temp[0]))) {
char tem2;
memcpy(&tem2, &temp[1], sizeof(temp[1]));
Sys.PC += tem2;
// Sys.PC = GetTargPC(temp[1]);
}
}
void CVm8051::Opcode_32_RETI(void) {
INT8U temp = 0;
temp = GetRamData(Sys.sp());
Sys.PC = (Sys.PC & 0x00FF) | (((INT16U) temp) << 8);
Sys.sp = Sys.sp() - 1;
temp = GetRamData(Sys.sp());
Sys.PC = (Sys.PC & 0xFF00) | temp;
Sys.sp = Sys.sp() - 1;
++Sys.PC;
}
void CVm8051::Opcode_33_RLC_A(void) {
INT8U temp = Sys.a() & 0x80;
Sys.a = ((Sys.a() << 1) | Sys.psw().cy);
Sys.psw().cy = temp == 0 ? 0 : 1;
++Sys.PC;
}
void CVm8051::Opcode_40_JC_Rel(void) {
char tem2= Get1Opcode();
// GetOpcodeData(&tem2, 1);
Sys.PC += 2;
if (Sys.psw().cy) {
memcpy(&tem2, &tem2, sizeof(tem2));
Sys.PC += tem2;
// Sys.PC = GetTargPC(temp);
}
}
void CVm8051::Opcode_42_ORL_Direct_A(void) {
INT8U temp;
INT8U addr = Get1Opcode();
temp = GetRamData(addr);
temp |= Sys.a();
SetRamData(addr, temp);
Sys.PC += 2;
}
void CVm8051::Opcode_43_ORL_Direct_Data(void) {
INT8U temp[2] = { 0 };
INT8U data;
// void *p = NULL;
GetOpcodeData(&temp[0], 2); //direct ~{JG~}1~{8vWV=Z~}
data = GetRamData(temp[0]);
data |= temp[1];
// memcpy(p, &data, 1);
SetRamData(temp[0], data);
Sys.PC += 3;
}
void CVm8051::Updata_A_P_Flag(void) {
INT8U a = Sys.a();
a ^= a >> 4;
a ^= a >> 2;
a ^= a >> 1;
Sys.psw().p = (a & 1);
}
void CVm8051::Opcode_44_ORL_A_Data(void) {
INT8U temp = Get1Opcode();
Sys.a = Sys.a() | temp;
Sys.PC += 2;
}
void CVm8051::Opcode_45_ORL_A_Direct(void) {
INT8U data;
INT8U addr = Get1Opcode();
// GetOpcodeData(&addr, 1);
data = GetRamData(addr);
Sys.a = Sys.a() | data;
Sys.PC += 2;
}
void CVm8051::Opcode_50_JNC_Rel(void) {
char tem2 = Get1Opcode();
// GetOpcodeData(&tem2, 1);
Sys.PC += 2;
if (Sys.psw().cy == 0) {
Sys.PC += tem2;
}
}
void CVm8051::Opcode_52_ANL_Direct_A(void) {
INT8U temp;
INT8U addr =Get1Opcode();
// void *p = NULL;
GetOpcodeData(&addr, 1);
temp = GetRamData(addr);
temp &= Sys.a();
SetRamData(addr, temp);
Sys.PC += 2;
}
void CVm8051::Opcode_53_ANL_Direct_Data(void) {
INT8U temp[2] = { 0 };
INT8U data;
GetOpcodeData(&temp[0], 2);
data = GetRamData(temp[0]);
data &= temp[1];
SetRamData(temp[0], data);
Sys.PC += 3;
}
void CVm8051::Opcode_60_JZ_Rel(void) {
char temp= Get1Opcode();
// GetOpcodeData(&temp, 1);
Sys.PC += 2;
if (Sys.a() == 0) {
// Sys.PC = GetTargPC(temp);
Sys.PC += temp;
}
}
void CVm8051::Opcode_62_XRL_Direct_A(void) {
INT8U temp;
INT8U addr = Get1Opcode();
temp = GetRamData(addr);
temp ^= Sys.a();
SetRamData(addr, temp);
Sys.PC += 2;
}
void CVm8051::Opcode_63_XRL_Direct_Data(void) {
INT8U temp[2] = { 0 };
INT8U data;
GetOpcodeData(&temp[0], 2);
data = GetRamData(temp[0]);
data ^= temp[1];
SetRamData(temp[0], data);
Sys.PC += 3;
}
void CVm8051::Opcode_70_JNZ_Rel(void) {
char temp = Get1Opcode();
Sys.PC += 2;
if (Sys.a() != 0) {
Sys.PC += temp;
}
}
void CVm8051::Opcode_75_MOV_Direct_Data(void) {
INT8U temp[2] = { 0 };
GetOpcodeData(&temp[0], 2);
SetRamData(temp[0], temp[1]);
Sys.PC += 3;
}
void CVm8051::Opcode_80_SJMP_Rel(void) {
char temp= Get1Opcode();
Sys.PC += 2;
Sys.PC += temp;
}
void CVm8051::Opcode_83_MOVC_A_PC(void) {
// INT8U temp;
INT16U addr;
// void*p = NULL;
++Sys.PC;
addr = (INT16U) (Sys.PC + Sys.a());
Sys.a = (Sys.PC > CVm8051::MAX_ROM - Sys.a()) ? (0x00) : (m_ExeFile[addr]);
}
void CVm8051::Opcode_84_DIV_AB(void) {
INT8U data1, data2;
data1 = Sys.a();
data2 = Sys.b();
if (data2 == 0) {
Sys.psw().ov = 1;
goto Ret;
}
Sys.a = data1 / data2;
Sys.b = data1 % data2;
Sys.psw().ov = 0;
Ret: Sys.psw().cy = 0;
++Sys.PC;
}
void CVm8051::Opcode_85_MOV_Direct_Direct(void) {
INT8U temp[2];
INT8U tem;
GetOpcodeData(&temp[0], 2);
tem = GetRamData(temp[0]);
SetRamData(temp[1], tem);
Sys.PC += 3;
}
void CVm8051::Opcode_90_MOV_DPTR_Data(void) {
INT16U temp;
GetOpcodeData(&temp, 2);
temp = (temp >> 8) | (temp << 8);
Sys.dptr = temp;
Sys.PC += 3;
}
void CVm8051::Opcode_92_MOV_Bit_C(void) {
INT8U temp = Get1Opcode();
if (Sys.psw().cy) {
SetBitFlag(temp);
} else {
ClrBitFlag(temp);
}
Sys.PC += 2;
}
void CVm8051::Opcode_93_MOVC_A_DPTR(void) {
INT8U temp;
void *p = NULL;
p = GetPointFileAddr((INT16U) (Sys.a() + Sys.dptr()));
memcpy(&temp, p, sizeof(temp));
Sys.a = (Sys.dptr() > CVm8051::MAX_ROM - Sys.a()) ? (0x00) : (temp);
++Sys.PC;
}
void CVm8051::Opcode_A4_MUL_AB(void) {
INT16U temp;
temp = (INT16U) Sys.a() * (INT16U) Sys.b();
Sys.psw().ov = (temp > 255) ? 1 : 0;
Sys.a = (INT8U) temp;
Sys.b = (INT8U) (temp >> 8);
++Sys.PC;
}
void CVm8051::Opcode_B2_CPL_Bit(void) {
INT8U temp=Get1Opcode();
if (GetBitFlag(temp)) {
ClrBitFlag(temp);
} else {
SetBitFlag(temp);
}
Sys.PC += 2;
}
void CVm8051::Opcode_B4_CJNE_A_Data_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (Sys.a() != temp[0]) {
char tem;
memcpy(&tem, &temp[1], 1);
Sys.PC += tem;
}
if ((Sys.a() < temp[0])) {
Sys.psw().cy = 1;
} else {
Sys.psw().cy = 0;
}
}
void CVm8051::Opcode_B5_CJNE_A_Direct_Rel(void) {
INT8U temp[2];
INT8U data;
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
data = GetRamData(temp[0]);
if (Sys.a() != data) {
char tem;
memcpy(&tem, &temp[1], 1);
Sys.PC += tem;
}
Sys.psw().cy = (Sys.a() < data) ? 1 : 0;
}
void CVm8051::Opcode_B6_CJNE_R0_1_Data_Rel(void) {
INT8U temp[2];
INT8U data;
GetOpcodeData(&temp[0], sizeof(temp));
data = GetRamDataAt(Rges.R0());
Sys.PC += 3;
if (data != temp[0]) {
char tem;
memcpy(&tem, &temp[1], 1);
Sys.PC += tem;
}
Sys.psw().cy = (data < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_B7_CJNE_R1_1_Data_Rel(void) {
INT8U temp[2];
INT8U data;
GetOpcodeData(&temp[0], sizeof(temp));
data = GetRamDataAt(Rges.R1());
Sys.PC += 3;
if (data != temp[0]) {
Sys.PC += (char)temp[1];
}
Sys.psw().cy = (data < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_B8_CJNE_R0_Data_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (Rges.R0() != temp[0]) {
Sys.PC += (char)temp[1];
}
Sys.psw().cy = (Rges.R0() < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_B9_CJNE_R1_Data_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (Rges.R1() != temp[0]) {
Sys.PC += (char)temp[1];
}
Sys.psw().cy = (Rges.R1() < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_BA_CJNE_R2_Data_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (Rges.R2() != temp[0]) {
Sys.PC += (char)temp[1];
}
Sys.psw().cy = (Rges.R2() < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_BB_CJNE_R3_Data_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (Rges.R3() != temp[0]) {
Sys.PC += (char)temp[1];
}
Sys.psw().cy = (Rges.R3() < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_BC_CJNE_R4_Data_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (Rges.R4() != temp[0]) {
Sys.PC += (char)temp[1];
}
Sys.psw().cy = (Rges.R4() < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_BD_CJNE_R5_Data_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (Rges.R5() != temp[0]) {
Sys.PC += (char)temp[1];
}
Sys.psw().cy = (Rges.R5() < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_BE_CJNE_R6_Data_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (Rges.R6() != temp[0]) {
Sys.PC += (char)temp[1];
}
Sys.psw().cy = (Rges.R6() < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_BF_CJNE_R7_Data_Rel(void) {
INT8U temp[2];
GetOpcodeData(&temp[0], sizeof(temp));
Sys.PC += 3;
if (Rges.R7() != temp[0]) {
Sys.PC += (char)temp[1];
}
Sys.psw().cy = (Rges.R7() < temp[0]) ? 1 : 0;
}
void CVm8051::Opcode_C5_XCH_A_Direct(void) {
INT8U addr;
INT8U data;
INT8U TT;
GetOpcodeData(&addr, sizeof(addr));
data = GetRamData(addr);
TT = Sys.a();
Sys.a = data;
SetRamData(addr, TT);
Sys.PC += 2;
}
void CVm8051::Opcode_C6_XCH_A_R0_1(void) {
INT8U TT;
TT = Sys.a();
Sys.a = GetRamDataAt(Rges.R0());
SetRamDataAt(Rges.R0(), TT);
++Sys.PC;
}
void CVm8051::Opcode_C7_XCH_A_R1_1(void) {
INT8U TT;
TT = Sys.a();
Sys.a = GetRamDataAt(Rges.R1());
SetRamDataAt(Rges.R1(), TT);
++Sys.PC;
}
void CVm8051::Opcode_C8_XCH_A_R0(void) {
INT8U temp;
temp = Sys.a();
Sys.a = Rges.R0();
Rges.R0 = temp;
++Sys.PC;
}
void CVm8051::Opcode_C9_XCH_A_R1(void) {
INT8U temp;
temp = Sys.a();
Sys.a = Rges.R1();
Rges.R1 = temp;
++Sys.PC;
}
void CVm8051::Opcode_CA_XCH_A_R2(void) {
INT8U temp;
temp = Sys.a();
Sys.a = Rges.R2();
Rges.R2 = temp;
++Sys.PC;
}
void CVm8051::Opcode_CB_XCH_A_R3(void) {
INT8U temp;
temp = Sys.a();
Sys.a = Rges.R3();
Rges.R3 = temp;
++Sys.PC;
}
void CVm8051::Opcode_CC_XCH_A_R4(void) {
INT8U temp;
temp = Sys.a();
Sys.a = Rges.R4();
Rges.R4 = temp;
++Sys.PC;
}
void CVm8051::Opcode_CD_XCH_A_R5(void) {
INT8U temp;
temp = Sys.a();
Sys.a = Rges.R5();
Rges.R5 = temp;
++Sys.PC;
}
void CVm8051::Opcode_CE_XCH_A_R6(void) {
INT8U temp;
temp = Sys.a();
Sys.a = Rges.R6();
Rges.R6 = temp;
++Sys.PC;
}
void CVm8051::Opcode_CF_XCH_A_R7(void) {
INT8U temp;
temp = Sys.a();
Sys.a = Rges.R7();
Rges.R7 = temp;
++Sys.PC;
}
void CVm8051::Opcode_D0_POP_Direct(void) {
SetRamData(Get1Opcode(), GetRamDataAt(Sys.sp()));
Sys.sp = Sys.sp() - 1;
Sys.PC += 2;
}
void CVm8051::Opcode_D4_DA_A(void) {
INT8U temp;
if (((Sys.a() & 0x0f) > 9) || (Sys.psw().ac == 1)) {
temp = ((Sys.a() & 0x0f) + 6) % 16;
Sys.a = Sys.a() & 0xF0;
Sys.a = Sys.a() | temp;
}
temp = ((Sys.a() & 0xF0) >> 4);
if ((temp > 9) || (Sys.psw().cy == 1)) {
temp = (temp + 6) % 16;
Sys.a = Sys.a() & 0x0F;
Sys.a = Sys.a() | (temp << 4);
}
++Sys.PC;
}
void CVm8051::Opcode_D5_DJNZ_Direct_Rel(void) {
INT8U temp[2];
INT8U data;
GetOpcodeData(&temp[0], sizeof(temp));
data = GetRamData(temp[0]);
data--;
SetRamData(temp[0], data);
Sys.PC += 3;
if (data != 0) {
char tem;
memcpy(&tem, &temp[1], 1);
Sys.PC += tem;
}
}
void CVm8051::Opcode_D6_XCHD_A_R0_1(void) {
INT8U temp = 0;
INT8U data = GetRamDataAt(Rges.R0());
temp = Sys.a() & 0x0F;
Sys.a = Sys.a() & 0xF0;
Sys.a = Sys.a() | (data & 0x0F);
data &= 0xF0;
data |= temp;
SetRamDataAt(Rges.R0(), data);
++Sys.PC;
}
void CVm8051::Opcode_D7_XCHD_A_R1_1(void) {
INT8U temp = 0;
INT8U data;
data = GetRamDataAt(Rges.R1());
temp = Sys.a() & 0x0F;
Sys.a = Sys.a() & 0xF0;
Sys.a = Sys.a() | (data & 0x0F);
data &= 0xF0;
data |= temp;
SetRamDataAt(Rges.R1(), data);
++Sys.PC;
}
void CVm8051::Opcode_D8_DJNZ_R0_Rel(void) {
char temp = Get1Opcode();
Sys.PC += 2;
Rges.R0 = Rges.R0() - 1;
if (Rges.R0() != 0) {
Sys.PC += temp;
}
}
void CVm8051::Opcode_D9_DJNZ_R1_Rel(void) {
char temp = Get1Opcode();
Sys.PC += 2;
Rges.R1 = Rges.R1() - 1;
if (Rges.R1() != 0) {
Sys.PC += temp;
}
}
void CVm8051::Opcode_DA_DJNZ_R2_Rel(void) {
char temp = Get1Opcode();
Sys.PC += 2;
Rges.R2 = Rges.R2() - 1;
if (Rges.R2() != 0) {
Sys.PC += temp;
}
}
void CVm8051::Opcode_DB_DJNZ_R3_Rel(void) {
char temp = Get1Opcode();
Sys.PC += 2;
Rges.R3 = Rges.R3() - 1;
if (Rges.R3() != 0) {
Sys.PC += temp;
}
}
void CVm8051::Opcode_DC_DJNZ_R4_Rel(void) {
char temp = Get1Opcode();
Sys.PC += 2;
Rges.R4 = Rges.R4() - 1;
if (Rges.R4() != 0) {
Sys.PC += temp;
}
}
void CVm8051::Opcode_DD_DJNZ_R5_Rel(void) {
char temp = Get1Opcode();
Sys.PC += 2;
Rges.R5 = Rges.R5() - 1;
if (Rges.R5() != 0) {
Sys.PC += temp;
}
}
void CVm8051::Opcode_DE_DJNZ_R6_Rel(void) {
char temp = Get1Opcode();
Sys.PC += 2;
Rges.R6 = Rges.R6() - 1;
if (Rges.R6() != 0) {
Sys.PC += temp;
}
}
void CVm8051::Opcode_DF_DJNZ_R7_Rel(void) {
char temp = Get1Opcode();
Sys.PC += 2;
Rges.R7 = Rges.R7() - 1;
if (Rges.R7() != 0) {
Sys.PC += temp;
}
}
void CVm8051::Opcode_E0_MOVX_A_DPTR(void) {
Sys.a = m_ExRam[Sys.dptr()];
++Sys.PC;
}
shared_ptr<vector<unsigned char>> CVm8051::GetRetData(void) const {
auto tem = std::make_shared<vector<unsigned char>>();
char buffer[1024] = { 0 };
memcpy(buffer, &m_ExRam[0xFC00], 1023);
tem.get()->assign(buffer, buffer + 1023);
return tem;
}
template<class T2>
T2& CUPReg<T2>::GetRegRe(void) {
assert(m_Addr != 255);
return *((T2*) (&pmcu->m_ChipRam[m_Addr]));
}
INT8U& CUPReg_a::GetRegRe(void) {
assert(m_Addr != 255);
return pmcu->m_ChipSfr[m_Addr];
}
INT8U& CUPSfr::GetRegRe(void) {
assert(m_Addr != 255);
return pmcu->m_ChipSfr[m_Addr];
}
INT16U& CUPSfr16::GetRegRe(void) {
assert(m_Addr != 255);
return *((INT16U*) &pmcu->m_ChipSfr[m_Addr]);
}
template<class T2>
T2 CUPReg<T2>::getValue() {
return GetRegRe();
}
void CUPReg_a::Updataflag() {
pmcu->Updata_A_P_Flag();
}
PSW& CUPPSW_8::operator()(void) {
return *((PSW*) &(GetRegRe()));
}
| 22.138304 | 117 | 0.639098 | koalajack |
c3debfa947362fdc46cb23f328eb5e9f0e5ce3cf | 3,561 | cpp | C++ | src/CoordinateAxes.cpp | sosswald/gpu-coverage | da36062272244573abd938996d8cb6ecd25a55e7 | [
"BSD-3-Clause"
] | 2 | 2018-09-17T15:21:06.000Z | 2020-03-27T11:57:04.000Z | src/CoordinateAxes.cpp | sosswald/gpu-coverage | da36062272244573abd938996d8cb6ecd25a55e7 | [
"BSD-3-Clause"
] | null | null | null | src/CoordinateAxes.cpp | sosswald/gpu-coverage | da36062272244573abd938996d8cb6ecd25a55e7 | [
"BSD-3-Clause"
] | null | null | null | /*
* Copyright (c) 2018, Stefan Osswald
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <gpu_coverage/CoordinateAxes.h>
#include <gpu_coverage/Mesh.h>
#include GLEXT_INCLUDE
#ifndef GLM_FORCE_RADIANS
#define GLM_FORCE_RADIANS true
#endif
#include <glm/gtc/type_ptr.hpp>
namespace gpu_coverage {
CoordinateAxes::CoordinateAxes()
: modelMatrix(glm::mat4()) {
const float points[] = {
-1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
0.0f, -1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, -1.0f,
0.0f, 0.0f, 1.0f
};
const float colors[] = {
1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f,
1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f
};
const unsigned int indices[] = { 0, 1, 2, 3, 4, 5 };
glGenBuffers(3, vbo);
enum {
POINTS = 0, COLORS = 1, INDICES = 2
};
vao = 0;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo[POINTS]);
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
glVertexAttribPointer(Mesh::VERTEX_BUFFER, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(Mesh::VERTEX_BUFFER);
glBindBuffer(GL_ARRAY_BUFFER, vbo[COLORS]);
glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
glVertexAttribPointer(Mesh::COLOR_BUFFER, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(Mesh::COLOR_BUFFER);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo[INDICES]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(vbo[INDICES]), indices, GL_STATIC_DRAW);
glVertexAttribPointer(Mesh::INDEX_BUFFER, 1, GL_UNSIGNED_INT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(Mesh::INDEX_BUFFER);
}
CoordinateAxes::~CoordinateAxes() {
glDeleteVertexArrays(1, &vao);
glDeleteBuffers(3, vbo);
}
void CoordinateAxes::display() const {
glBindVertexArray(vao);
glDrawArrays(GL_LINES, 0, 6);
}
} /* namespace gpu_coverage */
| 35.969697 | 89 | 0.693906 | sosswald |
c3ef135143b457c16bc80960ba3b059435f2efb5 | 6,127 | cpp | C++ | src/burner/win32/memcard.cpp | tt-arcade/fba-pi | 10407847a98f0d315b05e44f0ecf01824f4558aa | [
"Apache-2.0"
] | null | null | null | src/burner/win32/memcard.cpp | tt-arcade/fba-pi | 10407847a98f0d315b05e44f0ecf01824f4558aa | [
"Apache-2.0"
] | null | null | null | src/burner/win32/memcard.cpp | tt-arcade/fba-pi | 10407847a98f0d315b05e44f0ecf01824f4558aa | [
"Apache-2.0"
] | null | null | null | // Memory card support module
#include "burner.h"
static TCHAR szMemoryCardFile[MAX_PATH];
int nMemoryCardStatus = 0;
int nMemoryCardSize;
static int nMinVersion;
static bool bMemCardFC1Format;
static int MakeOfn()
{
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hScrnWnd;
ofn.lpstrFile = szMemoryCardFile;
ofn.nMaxFile = sizeof(szMemoryCardFile);
ofn.lpstrInitialDir = _T(".");
ofn.Flags = OFN_NOCHANGEDIR | OFN_HIDEREADONLY;
ofn.lpstrDefExt = _T("fc");
return 0;
}
static int MemCardRead(TCHAR* szFilename, unsigned char* pData, int nSize)
{
const char* szHeader = "FB1 FC1 "; // File + chunk identifier
char szReadHeader[8] = "";
bMemCardFC1Format = false;
FILE* fp = _tfopen(szFilename, _T("rb"));
if (fp == NULL) {
return 1;
}
fread(szReadHeader, 1, 8, fp); // Read identifiers
if (memcmp(szReadHeader, szHeader, 8) == 0) {
// FB Alpha memory card file
int nChunkSize = 0;
int nVersion = 0;
bMemCardFC1Format = true;
fread(&nChunkSize, 1, 4, fp); // Read chunk size
if (nSize < nChunkSize - 32) {
fclose(fp);
return 1;
}
fread(&nVersion, 1, 4, fp); // Read version
if (nVersion < nMinVersion) {
fclose(fp);
return 1;
}
fread(&nVersion, 1, 4, fp);
#if 0
if (nVersion < nBurnVer) {
fclose(fp);
return 1;
}
#endif
fseek(fp, 0x0C, SEEK_CUR); // Move file pointer to the start of the data block
fread(pData, 1, nChunkSize - 32, fp); // Read the data
} else {
// MAME or old FB Alpha memory card file
unsigned char* pTemp = (unsigned char*)malloc(nSize >> 1);
memset(pData, 0, nSize);
fseek(fp, 0x00, SEEK_SET);
if (pTemp) {
fread(pTemp, 1, nSize >> 1, fp);
for (int i = 1; i < nSize; i += 2) {
pData[i] = pTemp[i >> 1];
}
free(pTemp);
pTemp = NULL;
}
}
fclose(fp);
return 0;
}
static int MemCardWrite(TCHAR* szFilename, unsigned char* pData, int nSize)
{
FILE* fp = _tfopen(szFilename, _T("wb"));
if (fp == NULL) {
return 1;
}
if (bMemCardFC1Format) {
// FB Alpha memory card file
const char* szFileHeader = "FB1 "; // File identifier
const char* szChunkHeader = "FC1 "; // Chunk identifier
const int nZero = 0;
int nChunkSize = nSize + 32;
fwrite(szFileHeader, 1, 4, fp);
fwrite(szChunkHeader, 1, 4, fp);
fwrite(&nChunkSize, 1, 4, fp); // Chunk size
fwrite(&nBurnVer, 1, 4, fp); // Version of FBA this was saved from
fwrite(&nMinVersion, 1, 4, fp); // Min version of FBA data will work with
fwrite(&nZero, 1, 4, fp); // Reserved
fwrite(&nZero, 1, 4, fp); //
fwrite(&nZero, 1, 4, fp); //
fwrite(pData, 1, nSize, fp);
} else {
// MAME or old FB Alpha memory card file
unsigned char* pTemp = (unsigned char*)malloc(nSize >> 1);
if (pTemp) {
for (int i = 1; i < nSize; i += 2) {
pTemp[i >> 1] = pData[i];
}
fwrite(pTemp, 1, nSize >> 1, fp);
free(pTemp);
pTemp = NULL;
}
}
fclose(fp);
return 0;
}
static int __cdecl MemCardDoGetSize(struct BurnArea* pba)
{
nMemoryCardSize = pba->nLen;
return 0;
}
static int MemCardGetSize()
{
BurnAcb = MemCardDoGetSize;
BurnAreaScan(ACB_MEMCARD, &nMinVersion);
return 0;
}
int MemCardCreate()
{
TCHAR szFilter[1024];
int nRet;
_stprintf(szFilter, FBALoadStringEx(hAppInst, IDS_DISK_FILE_CARD, true), _T(APP_TITLE));
memcpy(szFilter + _tcslen(szFilter), _T(" (*.fc)\0*.fc\0\0"), 14 * sizeof(TCHAR));
_stprintf (szMemoryCardFile, _T("memorycard"));
MakeOfn();
ofn.lpstrTitle = FBALoadStringEx(hAppInst, IDS_MEMCARD_CREATE, true);
ofn.lpstrFilter = szFilter;
ofn.Flags |= OFN_OVERWRITEPROMPT;
int bOldPause = bRunPause;
bRunPause = 1;
nRet = GetSaveFileName(&ofn);
bRunPause = bOldPause;
if (nRet == 0) {
return 1;
}
{
unsigned char* pCard;
MemCardGetSize();
pCard = (unsigned char*)malloc(nMemoryCardSize);
memset(pCard, 0, nMemoryCardSize);
bMemCardFC1Format = true;
if (MemCardWrite(szMemoryCardFile, pCard, nMemoryCardSize)) {
return 1;
}
if (pCard) {
free(pCard);
pCard = NULL;
}
}
nMemoryCardStatus = 1;
MenuEnableItems();
return 0;
}
int MemCardSelect()
{
TCHAR szFilter[1024];
TCHAR* pszTemp = szFilter;
int nRet;
pszTemp += _stprintf(pszTemp, FBALoadStringEx(hAppInst, IDS_DISK_ALL_CARD, true));
memcpy(pszTemp, _T(" (*.fc, MEMCARD.\?\?\?)\0*.fc;MEMCARD.\?\?\?\0"), 38 * sizeof(TCHAR));
pszTemp += 38;
pszTemp += _stprintf(pszTemp, FBALoadStringEx(hAppInst, IDS_DISK_FILE_CARD, true), _T(APP_TITLE));
memcpy(pszTemp, _T(" (*.fc)\0*.fc\0"), 13 * sizeof(TCHAR));
pszTemp += 13;
pszTemp += _stprintf(pszTemp, FBALoadStringEx(hAppInst, IDS_DISK_FILE_CARD, true), _T("MAME"));
memcpy(pszTemp, _T(" (MEMCARD.\?\?\?)\0MEMCARD.\?\?\?\0\0"), 28 * sizeof(TCHAR));
MakeOfn();
ofn.lpstrTitle = FBALoadStringEx(hAppInst, IDS_MEMCARD_SELECT, true);
ofn.lpstrFilter = szFilter;
int bOldPause = bRunPause;
bRunPause = 1;
nRet = GetOpenFileName(&ofn);
bRunPause = bOldPause;
if (nRet == 0) {
return 1;
}
MemCardGetSize();
if (nMemoryCardSize <= 0) {
return 1;
}
nMemoryCardStatus = 1;
MenuEnableItems();
return 0;
}
static int __cdecl MemCardDoInsert(struct BurnArea* pba)
{
if (MemCardRead(szMemoryCardFile, (unsigned char*)pba->Data, pba->nLen)) {
return 1;
}
nMemoryCardStatus |= 2;
MenuEnableItems();
return 0;
}
int MemCardInsert()
{
if ((nMemoryCardStatus & 1) && (nMemoryCardStatus & 2) == 0) {
BurnAcb = MemCardDoInsert;
BurnAreaScan(ACB_WRITE | ACB_MEMCARD, &nMinVersion);
}
return 0;
}
static int __cdecl MemCardDoEject(struct BurnArea* pba)
{
if (MemCardWrite(szMemoryCardFile, (unsigned char*)pba->Data, pba->nLen) == 0) {
nMemoryCardStatus &= ~2;
MenuEnableItems();
return 0;
}
return 1;
}
int MemCardEject()
{
if ((nMemoryCardStatus & 1) && (nMemoryCardStatus & 2)) {
BurnAcb = MemCardDoEject;
nMinVersion = 0;
BurnAreaScan(ACB_READ | ACB_MEMCARD, &nMinVersion);
}
return 0;
}
int MemCardToggle()
{
if (nMemoryCardStatus & 1) {
if (nMemoryCardStatus & 2) {
return MemCardEject();
} else {
return MemCardInsert();
}
}
return 1;
}
| 19.764516 | 99 | 0.651053 | tt-arcade |
c3f73f9cba29aeb9b9bb27693805d0b332995276 | 2,933 | hpp | C++ | include/jbr/reg/var/perm/Rights.hpp | j-bruel/Register | 4fa991ed86fedb3883514031e51dc62057d0abd0 | [
"MIT"
] | null | null | null | include/jbr/reg/var/perm/Rights.hpp | j-bruel/Register | 4fa991ed86fedb3883514031e51dc62057d0abd0 | [
"MIT"
] | null | null | null | include/jbr/reg/var/perm/Rights.hpp | j-bruel/Register | 4fa991ed86fedb3883514031e51dc62057d0abd0 | [
"MIT"
] | 1 | 2019-05-06T14:12:44.000Z | 2019-05-06T14:12:44.000Z | //!
//! @file jbr/reg/var/perm/Rights.hpp
//! @author jbruel
//! @date 30/07/19
//!
#ifndef JBR_CREGISTER_REGISTER_VAR_PERM_RIGHTS_HPP
# define JBR_CREGISTER_REGISTER_VAR_PERM_RIGHTS_HPP
# include <jbr/reg/Permission.hpp>
//!
//! @namespace jbr::reg::var::perm
//!
namespace jbr::reg::var::perm
{
//!
//! @struct Rights
//! @brief All variables rights.
//!
struct Rights final : public jbr::reg::Permission
{
bool mUpdate; //!< Allow to update a variable.
bool mRename; //!< Allow to rename a variable.
bool mCopy; //!< Allow to copy a variable.
bool mRemove; //!< Allow to remove a variable.
//!
//! @brief Structure initializer. All rights are true by default.
//!
Rights() : jbr::reg::Permission(), mUpdate(true), mRename(true), mCopy(true), mRemove(true) {}
//!
//! @brief Structure initializer with custom rights initialization.
//! @param rd Reading rights.
//! @param wr Writing rights.
//! @param up Allow to update a variable.
//! @param rn Allow to rename a variable.
//! @param cp Allow to copy a variable.
//! @param rm Allow to remove a variable.
//!
explicit Rights(bool rd, bool wr, bool up, bool rn, bool cp, bool rm) : jbr::reg::Permission(rd, wr), mUpdate(up),
mRename(rn), mCopy(cp), mRemove(rm) {}
//!
//! @brief Equal operator overload.
//! @param rights New rights to overload.
//! @return New rights structure.
//!
Rights &operator=(const jbr::reg::var::perm::Rights &rights) noexcept
{
mRead = rights.mRead;
mWrite = rights.mWrite;
mUpdate = rights.mUpdate;
mRename = rights.mRename;
mCopy = rights.mCopy;
mRemove = rights.mRemove;
return (*this);
}
//!
//! @brief Equality overload operator.
//! @param rights Rights to check.
//! @return Status if rights are equals.
//!
inline bool operator==(const jbr::reg::var::perm::Rights &rights) noexcept { return (mRead == rights.mRead &&
mWrite == rights.mWrite &&
mUpdate == rights.mUpdate &&
mRename == rights.mRename &&
mCopy == rights.mCopy &&
mRemove == rights.mRemove); }
};
}
#endif //JBR_CREGISTER_REGISTER_VAR_PERM_RIGHTS_HPP
| 38.592105 | 122 | 0.475963 | j-bruel |
c3fa7a9f74907ae5ec230fd9742c729e637b4c31 | 446 | cpp | C++ | solutions/leetcode/944. Delete Columns to Make Sorted.cpp | MohanedAshraf/competitive-programming | 234dc6113b39462c64a2719cd1071f3d99655508 | [
"MIT"
] | 1 | 2021-08-12T14:53:37.000Z | 2021-08-12T14:53:37.000Z | solutions/leetcode/944. Delete Columns to Make Sorted.cpp | MohanedAshraf/competitive-programming | 234dc6113b39462c64a2719cd1071f3d99655508 | [
"MIT"
] | null | null | null | solutions/leetcode/944. Delete Columns to Make Sorted.cpp | MohanedAshraf/competitive-programming | 234dc6113b39462c64a2719cd1071f3d99655508 | [
"MIT"
] | null | null | null | static int __=[](){std::ios::sync_with_stdio(false);return 1000;}();
class Solution {
public:
int minDeletionSize(vector<string>& strs) {
int c = 0 , n = strs.size() , m = strs[0].size() ;
for(int i= 0 ; i<m ; i++)
for(int j = 0; j<n-1 ; j++ )
if(strs[j][i] > strs[j+1][i]){
c++;
break;
}
return c ;
}
};
| 24.777778 | 68 | 0.392377 | MohanedAshraf |
7f0adede716cb763e559b3e8d4533efb7a003b74 | 524 | cpp | C++ | Payoffs.cpp | ThibaultLacharme/tddc_pde_solver | c735ff4aff8a9cba33ed86c59b1fcd569745b74f | [
"BSD-3-Clause"
] | null | null | null | Payoffs.cpp | ThibaultLacharme/tddc_pde_solver | c735ff4aff8a9cba33ed86c59b1fcd569745b74f | [
"BSD-3-Clause"
] | null | null | null | Payoffs.cpp | ThibaultLacharme/tddc_pde_solver | c735ff4aff8a9cba33ed86c59b1fcd569745b74f | [
"BSD-3-Clause"
] | null | null | null | #include "Payoffs.hpp"
#include <algorithm>
namespace dauphine
{
Payoffs::Payoffs()
{
}
// For other products add the corresponding function at maturity, if there are more arguments than the spot and strike adjust the function in Boundaries too
double Payoffs::call(double spot, double strike)
{
return std::max(spot - strike, 0.);
};
double Payoffs::put(double spot, double strike)
{
return std::max(strike - spot, 0.);
};
Payoffs::~Payoffs()
{
}
}
| 22.782609 | 160 | 0.627863 | ThibaultLacharme |
7f17e6c64789dd102403d3119f4f4374d892b6c0 | 250 | cpp | C++ | Programs/14 Recursion/basics/power.cpp | Lord-Lava/DSA-CPP-Apna-College | 077350c2aa900bb0cdb137ece2b95be58ccd76a8 | [
"MIT"
] | 5 | 2021-04-04T18:39:14.000Z | 2021-12-18T09:31:55.000Z | Programs/14 Recursion/basics/power.cpp | Lord-Lava/DSA-CPP-Apna-College | 077350c2aa900bb0cdb137ece2b95be58ccd76a8 | [
"MIT"
] | null | null | null | Programs/14 Recursion/basics/power.cpp | Lord-Lava/DSA-CPP-Apna-College | 077350c2aa900bb0cdb137ece2b95be58ccd76a8 | [
"MIT"
] | 1 | 2021-09-26T11:01:26.000Z | 2021-09-26T11:01:26.000Z | #include<iostream>
using namespace std;
int power(int n, int p){
if(p==0){
return 1;
}
int prevPower= power(n,p-1);
return n*prevPower;
}
int main(){
int n,p;
cin>>n>>p;
cout<<power(n,p)<<endl;
return 0;
} | 12.5 | 32 | 0.536 | Lord-Lava |
7f1e039ff387c51c40d914d25c573aef36a51a2b | 24,259 | cpp | C++ | Source/AllProjects/CQCIGKit/CQCIGKit_DriverClient.cpp | MarkStega/CQC | c1d0e01ec2abcaa5b8eb1899b9f0522fecee4b07 | [
"MIT"
] | 51 | 2020-12-26T18:17:16.000Z | 2022-03-15T04:29:35.000Z | Source/AllProjects/CQCIGKit/CQCIGKit_DriverClient.cpp | MarkStega/CQC | c1d0e01ec2abcaa5b8eb1899b9f0522fecee4b07 | [
"MIT"
] | null | null | null | Source/AllProjects/CQCIGKit/CQCIGKit_DriverClient.cpp | MarkStega/CQC | c1d0e01ec2abcaa5b8eb1899b9f0522fecee4b07 | [
"MIT"
] | 4 | 2020-12-28T07:24:39.000Z | 2021-12-29T12:09:37.000Z | //
// FILE NAME: CQCIGKit_DriverClient.cpp
//
// AUTHOR: Dean Roddey
//
// CREATED: 11/16/2001
//
// COPYRIGHT: Charmed Quark Systems, Ltd @ 2020
//
// This software is copyrighted by 'Charmed Quark Systems, Ltd' and
// the author (Dean Roddey.) It is licensed under the MIT Open Source
// license:
//
// https://opensource.org/licenses/MIT
//
// DESCRIPTION:
//
// Implements the standard CQC client side driver window, from which all
// client drivers derive.
//
// CAVEATS/GOTCHAS:
//
// LOG:
//
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include "CQCIGKit_.hpp"
// ----------------------------------------------------------------------------
// Do our RTTI macros
// ----------------------------------------------------------------------------
RTTIDecls(TCQCDriverClient,TGenericWnd)
// ---------------------------------------------------------------------------
// CLASS: TCQCDriverClient
// PREFIX: wnd
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// TCQCDriverClient: Constructors and Destructor
// ---------------------------------------------------------------------------
TCQCDriverClient::TCQCDriverClient( const TCQCDriverObjCfg& cqcdcThis
, const TString& strDriverClass
, const tCQCKit::EActLevels eActivityLevel
, const TCQCUserCtx& cuctxToUse) :
TGenericWnd()
, m_bCleanupDone(kCIDLib::False)
, m_bFirstTimer(kCIDLib::True)
, m_c4PollChanges(0)
, m_cuctxToUse(cuctxToUse)
, m_eActivityLevel(eActivityLevel)
, m_eConnState(tCQCGKit::EConnStates::SrvOffline)
, m_ePrevState(tCQCGKit::EConnStates::SrvOffline)
, m_cqcdcThis(cqcdcThis)
, m_thrPoll
(
facCIDLib().strNextThreadName(strDriverClass + TString(L"Poll"))
, TMemberFunc<TCQCDriverClient>(this, &TCQCDriverClient::ePollThread)
)
, m_tmidUpdate(kCIDCtrls::tmidInvalid)
{
}
TCQCDriverClient::~TCQCDriverClient()
{
}
// ---------------------------------------------------------------------------
// TCQCDriverClient: Public, non-virtual methods
// ---------------------------------------------------------------------------
const TCQCDriverObjCfg& TCQCDriverClient::cqcdcThis() const
{
return m_cqcdcThis;
}
const TCQCUserCtx& TCQCDriverClient::cuctxToUse() const
{
return m_cuctxToUse;
}
tCIDLib::TVoid
TCQCDriverClient::CreateClDrvWnd(const TWindow& wndParent
, const TArea& areaInit
, const tCIDCtrls::TWndId widToUse)
{
//
// And now call down to create the window. We are initially invisible and our parent
// will show us once he's got us sized/positioned appropriately.
//
TWindow::CreateWnd
(
wndParent.hwndSafe()
, kCIDCtrls::pszCustClass
, L""
, areaInit
, tCIDCtrls::EWndStyles::ClippingChild
, tCIDCtrls::EExWndStyles::ControlParent
, widToUse
);
}
tCQCGKit::EConnStates TCQCDriverClient::eConnState() const
{
return m_eConnState;
}
// Just a convenience wrapper that we pass on to the user context
tCQCKit::EUserRoles TCQCDriverClient::eUserRole() const
{
return m_cuctxToUse.eUserRole();
}
tCQCKit::TCQCSrvProxy& TCQCDriverClient::orbcServer()
{
return m_orbcServer;
}
TMutex* TCQCDriverClient::pmtxSync() const
{
return &m_mtxSync;
}
const TCQCSecToken& TCQCDriverClient::sectUser() const
{
return m_cuctxToUse.sectUser();
}
const TString& TCQCDriverClient::strMoniker() const
{
return m_cqcdcThis.strMoniker();
}
// The client program will call this after the windows are all created and ready
tCIDLib::TVoid TCQCDriverClient::StartDriver()
{
// If we have already been run and stopped, then that's an error
if (m_bCleanupDone)
{
facCQCGKit().LogMsg
(
CID_FILE
, CID_LINE
, kIGKitErrs::errcDrv_AlreadyStopped
, tCIDLib::ESeverities::Failed
, tCIDLib::EErrClasses::Already
, m_cqcdcThis.strMoniker()
);
}
// Start the poll thread
m_thrPoll.Start();
//
// Start the update timer. Initially we set a kind of long time, to
// give the client time to come up and get displayed. The first time
// the timer gets called, he will reset the period to the appropriate
// period.
//
// <TBD> Later on, we can use the m_eActivityLevel setting to adjust
// these to optimize overhead to match the rate that the device's data
// is likely to change.
//
m_tmidUpdate = tmidStartTimer(3000);
}
//
// The client program will call this top stop the driver (before it destroys our
// parent window of course!)
//
tCIDLib::TVoid TCQCDriverClient::StopDriver()
{
// Stop our update time if running
try
{
if (m_tmidUpdate != kCIDCtrls::tmidInvalid)
{
StopTimer(m_tmidUpdate);
m_tmidUpdate = kCIDCtrls::tmidInvalid;
}
}
catch(TError& errToCatch)
{
if (facCQCGKit().bShouldLog(errToCatch))
{
errToCatch.AddStackLevel(CID_FILE, CID_LINE);
TModule::LogEventObj(errToCatch);
}
if (facCQCGKit().bLogFailures())
{
facCQCGKit().LogMsg
(
CID_FILE
, CID_LINE
, kGKitMsgs::midStatus_StopTimer
, tCIDLib::ESeverities::Failed
, tCIDLib::EErrClasses::Internal
, m_cqcdcThis.strMoniker()
);
}
}
catch(...)
{
if (facCQCGKit().bLogFailures())
{
facCQCGKit().LogMsg
(
CID_FILE
, CID_LINE
, kGKitMsgs::midStatus_StopTimer
, tCIDLib::ESeverities::Failed
, tCIDLib::EErrClasses::Internal
, m_cqcdcThis.strMoniker()
);
}
}
// Stop the poll thread
try
{
if (m_thrPoll.bIsRunning())
{
m_thrPoll.ReqShutdownSync(10000);
m_thrPoll.eWaitForDeath(5000);
}
}
catch(TError& errToCatch)
{
if (facCQCGKit().bShouldLog(errToCatch))
{
errToCatch.AddStackLevel(CID_FILE, CID_LINE);
TModule::LogEventObj(errToCatch);
}
if (facCQCGKit().bLogFailures())
{
facCQCGKit().LogMsg
(
CID_FILE
, CID_LINE
, kGKitMsgs::midStatus_StopClientDrvPollThr
, tCIDLib::ESeverities::Failed
, tCIDLib::EErrClasses::Internal
, m_cqcdcThis.strMoniker()
);
}
}
catch(...)
{
if (facCQCGKit().bLogFailures())
{
facCQCGKit().LogMsg
(
CID_FILE
, CID_LINE
, kGKitMsgs::midStatus_StopClientDrvPollThr
, tCIDLib::ESeverities::Failed
, tCIDLib::EErrClasses::Internal
, m_cqcdcThis.strMoniker()
);
}
}
// Let the derived class do its cleanup
try
{
if (!m_bCleanupDone)
{
m_bCleanupDone = kCIDLib::True;
DoCleanup();
}
}
catch(TError& errToCatch)
{
errToCatch.AddStackLevel(CID_FILE, CID_LINE);
TModule::LogEventObj(errToCatch);
}
// Drop the server admin client proxy, if we have one
try
{
m_orbcServer.DropRef();
}
catch(TError& errToCatch)
{
if (facCQCGKit().bShouldLog(errToCatch))
{
errToCatch.AddStackLevel(CID_FILE, CID_LINE);
TModule::LogEventObj(errToCatch);
}
if (facCQCGKit().bLogFailures())
{
facCQCGKit().LogMsg
(
CID_FILE
, CID_LINE
, kGKitMsgs::midStatus_CleanupProxy
, tCIDLib::ESeverities::Failed
, tCIDLib::EErrClasses::Internal
, m_cqcdcThis.strMoniker()
);
}
}
catch(...)
{
if (facCQCGKit().bLogFailures())
{
facCQCGKit().LogMsg
(
CID_FILE
, CID_LINE
, kGKitMsgs::midStatus_CleanupProxy
, tCIDLib::ESeverities::Status
, tCIDLib::EErrClasses::Internal
, m_cqcdcThis.strMoniker()
);
}
}
}
// ---------------------------------------------------------------------------
// TCQCDriverClient: Protected, inherited methods
// ---------------------------------------------------------------------------
// Do it all in the paint, where we are clipped to our children
tCIDLib::TBoolean TCQCDriverClient::bEraseBgn(TGraphDrawDev&)
{
return kCIDLib::True;
}
tCIDLib::TBoolean TCQCDriverClient::bPaint(TGraphDrawDev& gdevToUse, const TArea& areaUpdate)
{
gdevToUse.Fill(areaUpdate, rgbBgnFill());
return kCIDLib::True;
}
tCIDLib::TVoid TCQCDriverClient::Destroyed()
{
// Just in case...
StopDriver();
TParent::Destroyed();
}
tCIDLib::TVoid TCQCDriverClient::Timer(const tCIDCtrls::TTimerId tmidToDo)
{
// If the first timer, reset the period now
if (m_bFirstTimer)
{
m_bFirstTimer = kCIDLib::False;
ResetTimer(m_tmidUpdate, 1000);
}
//
// We have to lock out the poll thread during this. Use the form that let's us
// conditionally lock. If the poll thread should hang up for some reason, we
// don't want to lock up the interface. We use a short timeout so that, if the
// poll thread is straining because the remote servers are down, we won't make
// the interface overly spongy.
//
TLocker lockrSync(&m_mtxSync, kCIDLib::False);
if (!lockrSync.bLock(1))
return;
try
{
//
// If we have no changes, then just return, cause there is nothing to do.
// Else, reset the counter and let the derived class update itself with this
// new data.
//
if (!m_c4PollChanges)
return;
m_c4PollChanges = 0;
//
// See if the connection state has changed from the last one the bgn thread
// left us.
//
if (m_eConnState != m_ePrevState)
{
//
// Remember the previous state, then get it into sync with the current state.
// We want to do this before we make any call, in case it throws.
//
const tCQCGKit::EConnStates eOldState = m_ePrevState;
m_ePrevState = m_eConnState;
//
// If we have connected or disconnected, then let the derived class know so
// that he can update current status display stuff.
//
if ((eOldState != tCQCGKit::EConnStates::Connected)
&& (m_eConnState == tCQCGKit::EConnStates::Connected))
{
// Tell the parent tab window that we are not in error state
TTabWindow* pwndPar = dynamic_cast<TTabWindow*>(pwndParent());
if (pwndPar)
pwndPar->SetState(tCIDCtrls::ETabStates::Normal, kCIDLib::True);
Connected();
}
else if ((eOldState == tCQCGKit::EConnStates::Connected)
&& (m_eConnState != tCQCGKit::EConnStates::Connected))
{
// Tell the parent tab window that we are in error state
TTabWindow* pwndPar = dynamic_cast<TTabWindow*>(pwndParent());
if (pwndPar)
pwndPar->SetState(tCIDCtrls::ETabStates::Errors, kCIDLib::True);
LostConnection();
}
}
else if (m_eConnState == tCQCGKit::EConnStates::Connected)
{
//
// Its just a normal scenario. We are connected so let the driver display
// new data if it has any, left for it by the polling thread.
//
UpdateDisplayData();
}
}
catch(TError& errToCatch)
{
//
// Eat it, since there isn't much we can do, but log a message if
// debugging is on.
//
#if CID_DEBUG_ON
if (facCQCGKit().bShouldLog(errToCatch))
{
errToCatch.AddStackLevel(CID_FILE, CID_LINE);
TModule::LogEventObj(errToCatch);
}
#endif
}
catch(...)
{
//
// Eat it, since there isn't much we can do, but log a message if
// debugging is on.
//
#if CID_DEBUG_ON
#endif
}
}
// ---------------------------------------------------------------------------
// Private, non-virtual methods
// ---------------------------------------------------------------------------
//
// This method is called from the poll thread when its time to do another poll cycle.
// We just break it out in order to keep that method from getting messy and bloated.
//
tCIDLib::TVoid TCQCDriverClient::DoPollCycle()
{
// Lock during this
TLocker lockrSync(&m_mtxSync);
//
// Ok, we get called here from the poll thread (and once from the main thread on
// startup to kickstart things.) We are responsible for either getting ourself up
// to the 'connected' state, or if already there for polling data and backing our
// state off if something goes awry.
//
try
{
//
// We'll start with being completely disconnected from the server, in which case
// we need to try to get a client proxy. If this fails, it'll throw and we'll
// catch below and stay off line. If it works ok, then update to assuming the
// device is offline, and indicate that state changes have happened.
//
if (m_eConnState == tCQCGKit::EConnStates::SrvOffline)
{
// Drop any old reference if we have one
if (m_orbcServer.pobjData())
m_orbcServer.DropRef();
//
// Try to get a new client proxy. If it works, then move our state up.
// Catch exceptions since we are going to get them if the server isn't up,
// and we just want to eat those and stay offline.
//
try
{
m_orbcServer = facCQCKit().orbcCQCSrvAdminProxy(m_cqcdcThis.strMoniker());
m_eConnState = tCQCGKit::EConnStates::DevOffline;
m_c4PollChanges++;
}
catch(TError& errToCatch)
{
// If it anything besides the driver not being loaded, rethrow
if (!errToCatch.bCheckEvent(facCQCKit().strName()
, kKitErrs::errcRem_DrvNotFound))
{
errToCatch.AddStackLevel(CID_FILE, CID_LINE);
throw;
}
}
}
//
// Ok, we are now connected to the server, but it might not be connected to
// its device. So if we last saw it offline, let's ask it for status. If it
// now shows connected, we get tell the driver to do one time on connect
// stuff, and move to connected state. We bump our changes counter to make
// sure the GUI thread updates in responses.
//
if (m_eConnState == tCQCGKit::EConnStates::DevOffline)
{
tCIDLib::TCard4 c4ThreadId;
tCQCKit::EDrvStates eState;
tCQCKit::EVerboseLvls eVerbose;
m_orbcServer->QueryDriverState
(
m_cqcdcThis.strMoniker(), eState, eVerbose, c4ThreadId
);
if (eState == tCQCKit::EDrvStates::Connected)
{
//
// Ask the derived class to get any 'one time' info that it gets from
// it's server driver upon connect. If the driver class doesn't throw
// an error, we'll update our status.
//
if (bGetConnectData(m_orbcServer))
{
m_eConnState = tCQCGKit::EConnStates::Connected;
m_c4PollChanges++;
}
}
}
//
// And if we are current fully connected, we just want to ask the derived class
// to poll for data. Its return value tells us if new data has showed up, or if
// he cannot talk to his device or server, in which case we update the status
// accordingly.
//
if (m_eConnState == tCQCGKit::EConnStates::Connected)
{
if (bDoPoll(m_orbcServer))
m_c4PollChanges++;
}
}
catch(const TError& errToCatch)
{
if (!m_orbcServer.pobjData() || m_orbcServer->bCheckForLostConnection())
{
// We lost connection to the server
m_eConnState = tCQCGKit::EConnStates::SrvOffline;
m_c4PollChanges++;
m_orbcServer.DropRef();
}
else if (errToCatch.bCheckEvent(facCQCKit().strName(), kKitErrs::errcDrv_NotOnline)
|| errToCatch.bCheckEvent(facCQCKit().strName(), kKitErrs::errcDrv_NotFound))
{
if (m_eConnState != tCQCGKit::EConnStates::DevOffline)
{
// The device isn't there for some reason
m_eConnState = tCQCGKit::EConnStates::DevOffline;
m_c4PollChanges++;
}
}
else if (errToCatch.bCheckEvent(facCIDOrbUC().strName()
, kOrbUCErrs::errcSrv_NSNotFound))
{
// We couldn't find the server in the name server
if (m_eConnState != tCQCGKit::EConnStates::SrvOffline)
{
m_eConnState = tCQCGKit::EConnStates::SrvOffline;
m_c4PollChanges++;
}
}
else
{
// Not something obvious, so log it if logging warnings
if (facCQCGKit().bLogWarnings() && !errToCatch.bLogged())
TModule::LogEventObj(errToCatch);
if (m_eConnState == tCQCGKit::EConnStates::Connected)
{
// We think we are connected, so try to make a call to the driver
try
{
tCIDLib::TCard4 c4Tmp;
m_orbcServer->c4QueryDriverId(m_cqcdcThis.strMoniker(), c4Tmp);
//
// It worked, so just assume it was some dumb error in the
// driver's GUI code.
//
}
catch(const TError& errToCatch)
{
//
// If it's not found, then we just lost the device,
// else assume we lost the server.
//
if (errToCatch.eClass() == tCIDLib::EErrClasses::NotFound)
m_eConnState = tCQCGKit::EConnStates::DevOffline;
else
m_eConnState = tCQCGKit::EConnStates::SrvOffline;
m_c4PollChanges++;
}
catch(...)
{
// Assume we lost the connection
m_eConnState = tCQCGKit::EConnStates::SrvOffline;
m_c4PollChanges++;
}
}
else if (m_eConnState != tCQCGKit::EConnStates::SrvOffline)
{
m_eConnState = tCQCGKit::EConnStates::SrvOffline;
m_c4PollChanges++;
}
}
}
catch(...)
{
//
// We don't have an exception to go by, so we have to just manually
// try the link and see if this happened becasue we lost the
// connection or not. We'll just try to get the driver id, which
// is a simple call that will check for out driver being there.
//
// If we aren't connected, just assume the worst case and say the
// server is offline and force us to completely reconnect.
//
if (m_eConnState == tCQCGKit::EConnStates::Connected)
{
try
{
tCIDLib::TCard4 c4Tmp;
m_orbcServer->c4QueryDriverId(m_cqcdcThis.strMoniker(), c4Tmp);
//
// It worked, so just assume it was some dumb error in the
// driver's GUI code.
//
}
catch(const TError& errToCatch)
{
//
// If it's not found, then we just lost the device,
// else assume we lost the server.
//
if (errToCatch.eClass() == tCIDLib::EErrClasses::NotFound)
m_eConnState = tCQCGKit::EConnStates::DevOffline;
else
m_eConnState = tCQCGKit::EConnStates::SrvOffline;
m_c4PollChanges++;
}
catch(...)
{
// Assume we lost the connection
m_eConnState = tCQCGKit::EConnStates::SrvOffline;
m_c4PollChanges++;
}
}
else if (m_eConnState != tCQCGKit::EConnStates::SrvOffline)
{
m_eConnState = tCQCGKit::EConnStates::SrvOffline;
m_c4PollChanges++;
}
}
}
//
// This is the polling thread. This is started up when the window is created,
// and runs until the window is closed. It keeps up with our current connect
// state and does what is necessary to run the show wrt to staying connected
// to the server and polling it for new data.
//
tCIDLib::EExitCodes
TCQCDriverClient::ePollThread(TThread& thrThis, tCIDLib::TVoid*)
{
// Let the thread that started us go now
thrThis.Sync();
//
// To avoid setting a try block on every round, we use a double loop.
// That lets us catch exceptions and restart.
//
tCIDLib::TBoolean bExit = kCIDLib::False;
while (!bExit)
{
try
{
while (!bExit)
{
if (m_eConnState == tCQCGKit::EConnStates::Connected)
{
if (!thrThis.bSleep(2000))
{
bExit = kCIDLib::True;
continue;
}
}
else
{
if (!thrThis.bSleep(4000))
{
bExit = kCIDLib::True;
continue;
}
}
//
// Call our method that does a standard poll cycle. According
// to our current connect status, this guy does what is
// necessary to keep things moving along and will update our
// state accordingly.
//
DoPollCycle();
}
}
catch(TError& errToCatch)
{
if (facCQCGKit().bLogWarnings())
{
errToCatch.AddStackLevel(CID_FILE, CID_LINE);
TModule::LogEventObj(errToCatch);
}
}
catch(...)
{
if (facCQCGKit().bLogFailures())
{
facCQCGKit().LogMsg
(
CID_FILE
, CID_LINE
, kGKitMsgs::midStatus_PollThreadExcept
, tCIDLib::ESeverities::Failed
, tCIDLib::EErrClasses::Internal
, m_cqcdcThis.strMoniker()
);
}
}
}
return tCIDLib::EExitCodes::Normal;
}
| 30.668774 | 93 | 0.513294 | MarkStega |
7f205320f9c7145eca5fbd3fc58c41693d413567 | 20,948 | cpp | C++ | libraries/plugins/chain/chain_plugin_full.cpp | SophiaTX/SophiaTx-Blockchain | c964691c020962ad1aba8263c0d8a78a9fa27e45 | [
"MIT"
] | 8 | 2018-07-25T20:42:43.000Z | 2019-03-11T03:14:09.000Z | libraries/plugins/chain/chain_plugin_full.cpp | SophiaTX/SophiaTx-Blockchain | c964691c020962ad1aba8263c0d8a78a9fa27e45 | [
"MIT"
] | 13 | 2018-07-25T17:41:28.000Z | 2019-01-25T13:38:11.000Z | libraries/plugins/chain/chain_plugin_full.cpp | SophiaTX/SophiaTx-Blockchain | c964691c020962ad1aba8263c0d8a78a9fa27e45 | [
"MIT"
] | 11 | 2018-07-25T14:34:13.000Z | 2019-05-03T13:29:37.000Z | #include <sophiatx/chain/database/database_exceptions.hpp>
#include <sophiatx/chain/genesis_state.hpp>
#include <sophiatx/plugins/chain/chain_plugin_full.hpp>
#include <sophiatx/chain/database/database.hpp>
#include <sophiatx/utilities/benchmark_dumper.hpp>
#include <sophiatx/chain/get_config.hpp>
#include <sophiatx/egenesis/egenesis.hpp>
#include <fc/string_utils.hpp>
#include <fc/io/fstream.hpp>
#include <boost/asio.hpp>
#include <boost/optional.hpp>
#include <boost/bind.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/thread/future.hpp>
#include <thread>
#include <memory>
#include <iostream>
namespace sophiatx { namespace plugins { namespace chain {
using namespace sophiatx;
using fc::flat_map;
using sophiatx::chain::block_id_type;
namespace asio = boost::asio;
chain_plugin_full::chain_plugin_full() : write_queue( 64 ) {
db_ = std::make_shared<database>();
}
chain_plugin_full::~chain_plugin_full() { stop_write_processing(); }
struct write_request_visitor
{
write_request_visitor() {}
std::shared_ptr<database> db;
uint32_t skip = 0;
std::optional< fc::exception >* except;
typedef bool result_type;
bool operator()( const signed_block* block )
{
bool result = false;
try
{
result = db->push_block( *block, skip );
}
catch( fc::exception& e )
{
*except = e;
}
catch( ... )
{
*except = fc::unhandled_exception( FC_LOG_MESSAGE( warn, "Unexpected exception while pushing block." ),
std::current_exception() );
}
return result;
}
bool operator()( const signed_transaction* trx )
{
bool result = false;
try
{
db->push_transaction( *trx );
result = true;
}
catch( fc::exception& e )
{
*except = e;
}
catch( ... )
{
*except = fc::unhandled_exception( FC_LOG_MESSAGE( warn, "Unexpected exception while pushing block." ),
std::current_exception() );
}
return result;
}
bool operator()( generate_block_request* req )
{
bool result = false;
try{
req->block = db->generate_block(
req->when,
req->witness_owner,
req->block_signing_private_key,
req->skip
);
result = true;
}catch( fc::exception& e ){
*except = e;
}
catch( ... )
{
*except = fc::unhandled_exception( FC_LOG_MESSAGE( warn, "Unexpected exception while pushing block." ),
std::current_exception() );
}
return result;
}
};
struct request_promise_visitor
{
request_promise_visitor(){}
typedef void result_type;
template< typename T >
void operator()( T* t )
{
t->set_value();
}
};
void chain_plugin_full::start_write_processing()
{
write_processor_thread = std::make_shared< std::thread >( [&](){
bool is_syncing = true;
write_context* cxt;
fc::time_point_sec start = fc::time_point::now();
write_request_visitor req_visitor;
req_visitor.db = std::static_pointer_cast<database>(db_);
request_promise_visitor prom_visitor;
/* This loop monitors the write request queue and performs writes to the database. These
* can be blocks or pending transactions. Because the caller needs to know the success of
* the write and any exceptions that are thrown, a write context is passed in the queue
* to the processing thread which it will use to store the results of the write. It is the
* caller's responsibility to ensure the pointer to the write context remains valid until
* the contained promise is complete.
*
* The loop has two modes, sync mode and live mode. In sync mode we want to process writes
* as quickly as possible with minimal overhead. The outer loop busy waits on the queue
* and the inner loop drains the queue as quickly as possible. We exit sync mode when the
* head block is within 1 minute of system time.
*
* Live mode needs to balance between processing pending writes and allowing readers access
* to the database. It will batch writes together as much as possible to minimize lock
* overhead but will willingly give up the write lock after 500ms. The thread then sleeps for
* 10ms. This allows time for readers to access the database as well as more writes to come
* in. When the node is live the rate at which writes come in is slower and busy waiting is
* not an optimal use of system resources when we could give CPU time to read threads.
*/
while( running )
{
if( !is_syncing )
start = fc::time_point::now();
if( write_queue.pop( cxt ) )
{
db_->with_write_lock( [&](){
while( true )
{
req_visitor.skip = cxt->skip;
req_visitor.except = &(cxt->except);
cxt->success = cxt->req_ptr.visit( req_visitor );
cxt->prom_ptr.visit( prom_visitor );
if( is_syncing && start - db_->head_block_time() < fc::minutes(1) )
{
start = fc::time_point::now();
is_syncing = false;
}
if( !is_syncing && write_lock_hold_time >= 0 && fc::time_point::now() - start > fc::milliseconds( write_lock_hold_time ) )
{
break;
}
if( !write_queue.pop( cxt ) )
{
break;
}
}
});
}
if( !is_syncing ) {
boost::this_thread::sleep_for(boost::chrono::milliseconds(10));
} else
boost::this_thread::sleep_for(boost::chrono::milliseconds(1));
}
});
}
void chain_plugin_full::stop_write_processing()
{
running = false;
if( write_processor_thread )
write_processor_thread->join();
write_processor_thread.reset();
}
void chain_plugin_full::set_program_options(options_description& cli, options_description& cfg)
{
cfg.add_options()
("genesis-json", bpo::value<bfs::path>(), "the location of the genesis file in JSON format")
("shared-file-size", bpo::value<string>()->default_value("24G"), "Size of the shared memory file. Default: 24G. If running a full node, increase this value to 200G.")
("shared-file-full-threshold", bpo::value<uint16_t>()->default_value(0),
"A 2 precision percentage (0-10000) that defines the threshold for when to autoscale the shared memory file. Setting this to 0 disables autoscaling. Recommended value for consensus node is 9500 (95%). Full node is 9900 (99%)" )
("shared-file-scale-rate", bpo::value<uint16_t>()->default_value(0),
"A 2 precision percentage (0-10000) that defines how quickly to scale the shared memory file. When autoscaling occurs the file's size will be increased by this percent. Setting this to 0 disables autoscaling. Recommended value is between 1000-2000 (10-20%)" )
("checkpoint,c", bpo::value<vector<string>>()->composing(), "Pairs of [BLOCK_NUM,BLOCK_ID] that should be enforced as checkpoints.")
("flush-state-interval", bpo::value<uint32_t>(),
"flush shared memory changes to disk every N blocks")
;
cli.add_options()
("replay-blockchain", bpo::bool_switch()->default_value(false), "clear chain database and replay all blocks" )
("resync-blockchain", bpo::bool_switch()->default_value(false), "clear chain database and block log" )
("stop-replay-at-block", bpo::value<uint32_t>(), "Stop and exit after reaching given block number")
("set-benchmark-interval", bpo::value<uint32_t>(), "Print time and memory usage every given number of blocks")
("dump-memory-details", bpo::bool_switch()->default_value(false), "Dump database objects memory usage info. Use set-benchmark-interval to set dump interval.")
("check-locks", bpo::bool_switch()->default_value(false), "Check correctness of chainbase locking" )
("validate-database-invariants", bpo::bool_switch()->default_value(false), "Validate all supply invariants check out" )
("initminer-mining-pubkey", bpo::value<std::string>(), "initminer public key for mining. Used only for private nets.")
("initminer-account-pubkey", bpo::value<std::string>(), "initminer public key for account operations. Used only for private nets.")
;
}
void chain_plugin_full::plugin_initialize(const variables_map& options) {
shared_memory_size = fc::parse_size( options.at( "shared-file-size" ).as< string >() );
if( options.count( "shared-file-full-threshold" ) )
shared_file_full_threshold = options.at( "shared-file-full-threshold" ).as< uint16_t >();
if( options.count( "shared-file-scale-rate" ) )
shared_file_scale_rate = options.at( "shared-file-scale-rate" ).as< uint16_t >();
bool private_net = false;
if (options.count("initminer-mining-pubkey") ) {
private_net = true;
}
auto initial_state = [&] {
if( (private_net && options.count("initminer-account-pubkey")) ||
(private_net && options.count("genesis-json") == 0 ) ){
genesis_state_type genesis;
genesis.genesis_time = time_point_sec::from_iso_string("2018-01-01T08:00:00");
genesis.initial_balace = 0;
genesis.initial_public_key = options.count("initminer-account-pubkey") ?
public_key_type(options.at( "initminer-account-pubkey" ).as< std::string >()) :
public_key_type(options.at( "initminer-mining-pubkey" ).as< std::string >());
genesis.initial_public_mining_key = public_key_type(options.at( "initminer-mining-pubkey" ).as< std::string >());
genesis.is_private_net = true;
fc::sha256::encoder enc;
fc::raw::pack( enc, genesis );
genesis.initial_chain_id = enc.result();
return genesis;
}
if( options.count("genesis-json") )
{
std::string genesis_str;
fc::read_file_contents( options.at("genesis-json").as<boost::filesystem::path>(), genesis_str );
genesis_state_type genesis = fc::json::from_string( genesis_str ).as<genesis_state_type>();
genesis.initial_chain_id = fc::sha256::hash( genesis_str);
genesis.is_private_net = private_net;
return genesis;
}
else
{
std::string egenesis_json;
sophiatx::egenesis::compute_egenesis_json( egenesis_json );
FC_ASSERT( !egenesis_json.empty() );
FC_ASSERT( sophiatx::egenesis::get_egenesis_json_hash() == fc::sha256::hash( egenesis_json ) );
auto genesis = fc::json::from_string( egenesis_json ).as<genesis_state_type>();
genesis.initial_chain_id = fc::sha256::hash( egenesis_json );
return genesis;
}
};
genesis = initial_state();
chain::sophiatx_config::init(genesis);
replay = options.at( "replay-blockchain").as<bool>();
resync = options.at( "resync-blockchain").as<bool>();
stop_replay_at =
options.count( "stop-replay-at-block" ) ? options.at( "stop-replay-at-block" ).as<uint32_t>() : 0;
benchmark_interval =
options.count( "set-benchmark-interval" ) ? options.at( "set-benchmark-interval" ).as<uint32_t>() : 0;
check_locks = options.at( "check-locks" ).as< bool >();
validate_invariants = options.at( "validate-database-invariants" ).as<bool>();
dump_memory_details = options.at( "dump-memory-details" ).as<bool>();
if( options.count( "flush-state-interval" ) )
flush_interval = options.at( "flush-state-interval" ).as<uint32_t>();
else
flush_interval = 10000;
if(options.count("checkpoint"))
{
auto cps = options.at("checkpoint").as<vector<string>>();
loaded_checkpoints.reserve(cps.size());
for(const auto& cp : cps)
{
auto item = fc::json::from_string(cp).as<std::pair<uint32_t,block_id_type>>();
loaded_checkpoints[item.first] = item.second;
}
}
}
#define BENCHMARK_FILE_NAME "replay_benchmark.json"
void chain_plugin_full::plugin_startup()
{
ilog( "Starting chain with shared_file_size: ${n} bytes", ("n", shared_memory_size) );
chain_id_type chain_id = genesis.compute_chain_id();
shared_memory_dir = app().data_dir() / chain_id.str() / "blockchain";
// correct directories, TODO can be removed after next HF2
if( ! genesis.is_private_net && bfs::exists( app().data_dir() / "blockchain" ) ){
bfs::create_directories ( shared_memory_dir );
bfs::rename( app().data_dir() / "blockchain", shared_memory_dir );
}
ilog("Starting node with chain id ${i}", ("i", chain_id));
start_write_processing();
if(resync)
{
wlog("resync requested: deleting block log and shared memory");
db_->wipe( shared_memory_dir, true );
}
db_->set_flush_interval( flush_interval );
db_->add_checkpoints( loaded_checkpoints );
db_->set_require_locking( check_locks );
bool dump_memory_details_ = dump_memory_details;
sophiatx::utilities::benchmark_dumper dumper;
const auto& abstract_index_cntr = db_->get_abstract_index_cntr();
typedef sophiatx::utilities::benchmark_dumper::index_memory_details_cntr_t index_memory_details_cntr_t;
auto get_indexes_memory_details = [dump_memory_details_, &abstract_index_cntr]
(index_memory_details_cntr_t& index_memory_details_cntr, bool onlyStaticInfo)
{
if (!dump_memory_details_)
return;
for (auto idx : abstract_index_cntr)
{
auto info = idx->get_statistics(onlyStaticInfo);
index_memory_details_cntr.emplace_back(std::move(info._value_type_name), info._item_count,
info._item_sizeof, info._item_additional_allocation, info._additional_container_allocation);
}
};
database::open_args db_open_args;
db_open_args.shared_mem_dir = shared_memory_dir;
db_open_args.shared_file_size = shared_memory_size;
db_open_args.shared_file_full_threshold = shared_file_full_threshold;
db_open_args.shared_file_scale_rate = shared_file_scale_rate;
db_open_args.do_validate_invariants = validate_invariants;
db_open_args.stop_replay_at = stop_replay_at;
auto benchmark_lambda = [&dumper, &get_indexes_memory_details, dump_memory_details_] ( uint32_t current_block_number,
const chainbase::database::abstract_index_cntr_t& abstract_index_cntr )
{
if( current_block_number == 0 ) // initial call
{
typedef sophiatx::utilities::benchmark_dumper::database_object_sizeof_cntr_t database_object_sizeof_cntr_t;
auto get_database_objects_sizeofs = [dump_memory_details_, &abstract_index_cntr]
(database_object_sizeof_cntr_t& database_object_sizeof_cntr)
{
if (!dump_memory_details_)
return;
for (auto idx : abstract_index_cntr)
{
auto info = idx->get_statistics(true);
database_object_sizeof_cntr.emplace_back(std::move(info._value_type_name), info._item_sizeof);
}
};
dumper.initialize(get_database_objects_sizeofs, BENCHMARK_FILE_NAME);
return;
}
const sophiatx::utilities::benchmark_dumper::measurement& measure =
dumper.measure(current_block_number, get_indexes_memory_details);
ilog( "Performance report at block ${n}. Elapsed time: ${rt} ms (real), ${ct} ms (cpu). Memory usage: ${cm} (current), ${pm} (peak) kilobytes.",
("n", current_block_number)
("rt", measure.real_ms)
("ct", measure.cpu_ms)
("cm", measure.current_mem)
("pm", measure.peak_mem) );
};
if(replay)
{
ilog("Replaying blockchain on user request.");
uint32_t last_block_number = 0;
db_open_args.benchmark = sophiatx::chain::database::TBenchmark(benchmark_interval, benchmark_lambda);
last_block_number = db_->reindex( db_open_args, genesis);
if( benchmark_interval > 0 )
{
const sophiatx::utilities::benchmark_dumper::measurement& total_data = dumper.dump(true, get_indexes_memory_details);
ilog( "Performance report (total). Blocks: ${b}. Elapsed time: ${rt} ms (real), ${ct} ms (cpu). Memory usage: ${cm} (current), ${pm} (peak) kilobytes.",
("b", total_data.block_number)
("rt", total_data.real_ms)
("ct", total_data.cpu_ms)
("cm", total_data.current_mem)
("pm", total_data.peak_mem) );
}
if( stop_replay_at > 0 && stop_replay_at == last_block_number )
{
ilog("Stopped blockchain replaying on user request. Last applied block number: ${n}.", ("n", last_block_number));
appbase::app().quit();
return;
}
}
else
{
db_open_args.benchmark = sophiatx::chain::database::TBenchmark(dump_memory_details_, benchmark_lambda);
try
{
ilog("Opening shared memory from ${path}", ("path",shared_memory_dir.generic_string()));
db_->open( db_open_args, genesis);
if( dump_memory_details_ )
dumper.dump( true, get_indexes_memory_details );
}
catch( const fc::exception& e )
{
wlog("Error opening database, attempting to replay blockchain. Error: ${e}", ("e", e));
try
{
db_->reindex( db_open_args, genesis);
}
catch( sophiatx::chain::block_log_exception& )
{
wlog( "Error opening block log. Having to resync from network..." );
db_->open( db_open_args, genesis);
}
}
}
ilog( "Started on blockchain with ${n} blocks", ("n", db_->head_block_num()) );
on_sync();
}
void chain_plugin_full::plugin_shutdown()
{
ilog("closing chain database");
stop_write_processing();
db_->close();
ilog("database closed successfully");
}
bool chain_plugin_full::accept_block( const sophiatx::chain::signed_block& block, bool currently_syncing, uint32_t skip )
{
if (currently_syncing && block.block_num() % 10000 == 0) {
ilog("Syncing Blockchain --- Got block: #${n} time: ${t} producer: ${p}",
("t", block.timestamp)
("n", block.block_num())
("p", block.witness) );
}
check_time_in_block( block );
boost::promise< void > prom;
write_context cxt;
cxt.req_ptr = █
cxt.skip = currently_syncing? skip | database::skip_validate_invariants : skip;
cxt.prom_ptr = &prom;
write_queue.push( &cxt );
prom.get_future().get();
if( cxt.except ) throw *(cxt.except);
return cxt.success;
}
void chain_plugin_full::accept_transaction( const sophiatx::chain::signed_transaction& trx )
{
boost::promise< void > prom;
write_context cxt;
cxt.req_ptr = &trx;
cxt.prom_ptr = &prom;
write_queue.push( &cxt );
prom.get_future().get();
if( cxt.except ) throw *(cxt.except);
return;
}
void chain_plugin_full::check_time_in_block( const sophiatx::chain::signed_block& block )
{
time_point_sec now = fc::time_point::now();
uint64_t max_accept_time = now.sec_since_epoch();
max_accept_time += allow_future_time;
FC_ASSERT( block.timestamp.sec_since_epoch() <= max_accept_time );
}
sophiatx::chain::signed_block chain_plugin_full::generate_block( const fc::time_point_sec& when, const account_name_type& witness_owner,
const fc::ecc::private_key& block_signing_private_key, uint32_t skip )
{
generate_block_request req( when, witness_owner, block_signing_private_key, skip );
boost::promise< void > prom;
write_context cxt;
cxt.req_ptr = &req;
cxt.prom_ptr = &prom;
write_queue.push( &cxt );
prom.get_future().get();
if( cxt.except ) throw *(cxt.except);
FC_ASSERT( cxt.success, "Block could not be generated" );
return req.block;
}
int16_t chain_plugin_full::set_write_lock_hold_time( int16_t new_time )
{
FC_ASSERT( get_state() == appbase::abstract_plugin::state::initialized,
"Can only change write_lock_hold_time while chain_plugin_full is initialized." );
int16_t old_time = write_lock_hold_time;
write_lock_hold_time = new_time;
return old_time;
}
} } } // namespace sophiatx::plugis::chain::chain_apis
| 36.880282 | 271 | 0.634142 | SophiaTX |
7f26a584009c9e5e484626852f8a51d27adebacd | 958 | cpp | C++ | C++/problem0922.cpp | 1050669722/LeetCode-Answers | c8f4d1ccaac09cda63b60d75144335347b06dc81 | [
"MIT"
] | null | null | null | C++/problem0922.cpp | 1050669722/LeetCode-Answers | c8f4d1ccaac09cda63b60d75144335347b06dc81 | [
"MIT"
] | null | null | null | C++/problem0922.cpp | 1050669722/LeetCode-Answers | c8f4d1ccaac09cda63b60d75144335347b06dc81 | [
"MIT"
] | null | null | null | #include <iostream>
#include <iomanip>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <windows.h>
#include <string>
#include <numeric>
using namespace std;
class Solution {
public:
vector<int> sortArrayByParityII(vector<int>& A) {
int j = 1;
for (int i = 0; i < A.size(); i += 2)
{
if (A[i]%2 == 1)
{
while (A[j]%2 == 1)
{
j += 2;
}
int tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
}
return A;
}
};
int main()
{
vector<int> A {4,2,5,7};
Solution solu;
vector<int> ans = solu.sortArrayByParityII(A);
vector<int>::iterator it;
for (it = ans.begin(); it < ans.end(); ++it)
{
cout << *it << '\t';
}
cout << endl;
return 0;
}
| 19.16 | 53 | 0.44572 | 1050669722 |
7f2ce710398c6aa5fc53cac0665671b65a6e8174 | 1,648 | cc | C++ | src/Gateway.cc | Swair/Function-Distributed-Network | 55c2c9caa2b6de6c06c99009b2063703601e7956 | [
"Apache-2.0"
] | null | null | null | src/Gateway.cc | Swair/Function-Distributed-Network | 55c2c9caa2b6de6c06c99009b2063703601e7956 | [
"Apache-2.0"
] | null | null | null | src/Gateway.cc | Swair/Function-Distributed-Network | 55c2c9caa2b6de6c06c99009b2063703601e7956 | [
"Apache-2.0"
] | null | null | null | #include "Gateway.h"
Gateway& Gateway::getInstance()
{
static Gateway gw;
return gw;
}
Gateway::Gateway()
{}
Gateway::~Gateway()
{}
void Gateway::reg(const std::string& method, std::function<void(std::string&, const std::string&)> func)
{
routeTable_[method] = func;
}
void Gateway::route(std::string& response, const std::string& request)
{
std::string failCode;
//log_write("%s\n", request.c_str());
std::string uri;
if(0 == getContent(uri, request, "POST", 1, " HTTP"))
{
failCode = R"({"code":400, "msg":"fail in get uri"})";
throw ExceptionPanic(failCode);
}
int ix = uri.rfind("/");
if(ix > 0)
{
std::string method = uri.substr(ix + 1);
//log_write("Gateway::route, %s\n", method.c_str());
try
{
auto f = routeTable_[method];
f(response, request);
}
catch(nlohmann::detail::exception& e)
{
std::string msg = e.what();
failCode = R"({"code":430, "msg":")" + msg + R"("})";
throw ExceptionPanic(failCode);
}
catch(std::exception& e)
{
failCode = R"({"code":431, "msg":"fail in route, check the web api"})";
throw ExceptionPanic(failCode);
}
catch(ExceptionPanic& e)
{
std::string msg = e.what();
failCode = R"({"code":432, "msg":")" + msg + R"("})";
throw ExceptionPanic(failCode);
}
catch(...)
{
failCode = R"({"code":433, "msg":"fail in route"})";
throw ExceptionPanic(failCode);
}
}
}
| 24.969697 | 105 | 0.508495 | Swair |
b5290f40d62908ad95681d974cbce979eb8641f5 | 252 | cpp | C++ | Game/Client/WXClient/Network/PacketHandler/GCMySelfEquipmentListHandler.cpp | hackerlank/SourceCode | b702c9e0a9ca5d86933f3c827abb02a18ffc9a59 | [
"MIT"
] | 4 | 2021-07-31T13:56:01.000Z | 2021-11-13T02:55:10.000Z | Game/Client/WXClient/Network/PacketHandler/GCDetailEquipmentListHandler.cpp | shacojx/SourceCodeGameTLBB | e3cea615b06761c2098a05427a5f41c236b71bf7 | [
"MIT"
] | null | null | null | Game/Client/WXClient/Network/PacketHandler/GCDetailEquipmentListHandler.cpp | shacojx/SourceCodeGameTLBB | e3cea615b06761c2098a05427a5f41c236b71bf7 | [
"MIT"
] | 7 | 2021-08-31T14:34:23.000Z | 2022-01-19T08:25:58.000Z | #include "StdAfx.h"
#include "GCDetailEquipmentList.h"
uint GCDetailEquipmentListHandler :: Execute( GCDetailEquipmentList* pPacket, Player* pPlayer )
{
__ENTER_FUNCTION
return PACKET_EXE_CONTINUE ;
__LEAVE_FUNCTION
return PACKET_EXE_ERROR ;
}
| 16.8 | 96 | 0.801587 | hackerlank |
b529f379479b6a73c191611f277d3980470cabd8 | 1,091 | cpp | C++ | usaco_practice/bronze/bronze_A/A4_array_two/Roll_cake.cpp | juneharold/USACO | a96b54f68e7247c61044f3c0d9e7260952c508e2 | [
"MIT"
] | null | null | null | usaco_practice/bronze/bronze_A/A4_array_two/Roll_cake.cpp | juneharold/USACO | a96b54f68e7247c61044f3c0d9e7260952c508e2 | [
"MIT"
] | null | null | null | usaco_practice/bronze/bronze_A/A4_array_two/Roll_cake.cpp | juneharold/USACO | a96b54f68e7247c61044f3c0d9e7260952c508e2 | [
"MIT"
] | null | null | null | // 롤 케이크
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main()
{
int L, N;
cin >> L;
cin >> N;
int ranges[2000] = {};
for (int i=0; i<2*N; i++)
{
cin >> ranges[i];
}
// number of cake
int max_expected=0;
int max_received=0;
// number of person
int num_ex=-1;
int num_re=-1;
int status[1000]={};
for (int j=0; j<N; j++)
{
int start=ranges[2*j], end=ranges[2*j+1];
// finding expectations
int range = end-start+1;
if (range>max_expected)
{
max_expected=range;
num_ex=j+1;
}
// looping through the range
int cake_received=0;
for (int c=start; c<=end; c++)
{
if (status[c]==0)
{
cake_received += 1;
status[c]=1;
}
}
if (cake_received>max_received)
{
max_received=cake_received;
num_re=j+1;
}
}
cout << num_ex << endl;
cout << num_re << endl;
}
| 20.584906 | 49 | 0.463795 | juneharold |
b52d3581cedf7fffe7a94047630d9129e71c264c | 137 | hh | C++ | Include/Luce/AI/Configuration.hh | kmc7468/luce | 6f71407f250dbc0428ceba33aeef345cc601db34 | [
"MIT"
] | 23 | 2017-02-09T11:48:01.000Z | 2017-04-08T10:19:21.000Z | Include/Luce/AI/Configuration.hh | kmc7468/luce | 6f71407f250dbc0428ceba33aeef345cc601db34 | [
"MIT"
] | null | null | null | Include/Luce/AI/Configuration.hh | kmc7468/luce | 6f71407f250dbc0428ceba33aeef345cc601db34 | [
"MIT"
] | null | null | null | #ifndef LUCE_HEADER_AI_CONFIGURATION_HH
#define LUCE_HEADER_AI_CONFIGURATION_HH
#include <Luce/AI/Configuration/ComputeByCpu.hh>
#endif | 22.833333 | 48 | 0.868613 | kmc7468 |
b531574b7fbbf60c47356dc23f1ef5ad56585873 | 5,537 | cpp | C++ | src/TowerEntity.cpp | Smokey1105/Strife.SingleplayerDemo | 586865f66e7b08a6e16385fe400c3dd2fe886489 | [
"NCSA"
] | null | null | null | src/TowerEntity.cpp | Smokey1105/Strife.SingleplayerDemo | 586865f66e7b08a6e16385fe400c3dd2fe886489 | [
"NCSA"
] | null | null | null | src/TowerEntity.cpp | Smokey1105/Strife.SingleplayerDemo | 586865f66e7b08a6e16385fe400c3dd2fe886489 | [
"NCSA"
] | null | null | null | #include "TowerEntity.hpp"
#include "Engine.hpp"
#include "PlayerEntity.hpp"
#include "FireballEntity.hpp"
#include "CastleEntity.hpp"
#include "ObstacleComponent.hpp"
#include "Components/RigidBodyComponent.hpp"
#include "Components/SpriteComponent.hpp"
#include "Physics/PathFinding.hpp"
#include "Net/ReplicationManager.hpp"
void TowerEntity::DoSerialize(EntitySerializer& serializer)
{
}
void TowerEntity::OnAdded()
{
spriteComponent = AddComponent<SpriteComponent>("towerSprite");
spriteComponent->scale = Vector2(5.0f);
Vector2 size{ 11 * 5, 32 * 5 };
SetDimensions(size);
obstacle = AddComponent<ObstacleComponent>();
auto rigidBody = AddComponent<RigidBodyComponent>(b2_staticBody);
rigidBody->CreateBoxCollider(size);
auto health = AddComponent<HealthBarComponent>();
health->offsetFromCenter = -size.YVector() / 2 - Vector2(0, 5);
health->maxHealth = 500;
health->health = 500;
team = AddComponent<TeamComponent>();
auto offset = size / 2 + Vector2(40, 40);
_light = AddComponent<LightComponent<PointLight>>();
_light->position = Center();
_light->intensity = 0.5;
_light->maxDistance = 500;
_light->maxDistance = 500;
region = rigidBody->CreateCircleCollider(reach, true);
}
void TowerEntity::Update(float deltaTime)
{
_light->color = playerId == 0
? Color::Green()
: Color::White();
if (_currentTarget.IsValid())
{
_fireballTimeout -= deltaTime;
}
OnUpdateState();
}
void TowerEntity::OnDestroyed()
{
for (auto base : scene->GetEntitiesOfType<CastleEntity>())
{
if (base->team->teamId == team->teamId)
{
base->SendEvent(TowerDestroyedEvent());
}
}
}
void TowerEntity::ReceiveEvent(const IEntityEvent& ev)
{
if (ev.Is<OutOfHealthEvent>())
{
Destroy();
}
else if (auto damageDealtEvent = ev.Is<DamageDealtEvent>())
{
Entity* currentTarget = nullptr;
if (_currentTarget.TryGetValue(currentTarget))
{
if (currentTarget != damageDealtEvent->dealer)
{
ChangeState(
{ TowerEntityAiState::AttackSelectedTarget,
EntityReference<Entity>(damageDealtEvent->dealer) });
}
}
}
else if (auto contactBeginEvent = ev.Is<ContactBeginEvent>())
{
if (contactBeginEvent->OtherIs<FireballEntity>())
{
return;
}
if (contactBeginEvent->self.GetFixture() == region && !contactBeginEvent->other.IsTrigger())
{
_targets.PushBackUniqueIfRoom(contactBeginEvent->other.OwningEntity());
}
}
else if (auto contactEndEvent = ev.Is<ContactEndEvent>())
{
auto other = contactEndEvent->other;
if (contactEndEvent->self.GetFixture() == region && !other.IsTrigger())
{
_targets.RemoveSingle(other.OwningEntity());
}
}
}
void TowerEntity::ChangeState(TowerEntityState state)
{
OnExitState();
OnEnterState(state);
_state = state;
}
void TowerEntity::OnEnterState(TowerEntityState& newState)
{
switch (newState.state)
{
case TowerEntityAiState::DoNothing:
case TowerEntityAiState::SearchForTarget:
break;
case TowerEntityAiState::AttackSelectedTarget:
{
_currentTarget = newState.newTarget;
}
break;
}
}
void TowerEntity::OnUpdateState()
{
switch (_state.state)
{
case TowerEntityAiState::DoNothing:
ChangeState({ TowerEntityAiState::SearchForTarget });
break;
case TowerEntityAiState::SearchForTarget:
{
float closestTargetDistance = reach * 2;
Entity* closestTarget = nullptr;
for (auto& target : _targets)
{
if (target == nullptr || target->isDestroyed)
{
continue;
}
TeamComponent* teamComponent;
if (target->TryGetComponent(teamComponent)) {
if (teamComponent->teamId == team->teamId)
{
continue;
}
if ((target->Center() - Center()).Length() <= closestTargetDistance)
{
closestTarget = target;
}
}
}
if (closestTarget != nullptr)
{
ChangeState({ TowerEntityAiState::AttackSelectedTarget, EntityReference<Entity>(closestTarget) });
}
}
break;
case TowerEntityAiState::AttackSelectedTarget:
{
Entity* target = _currentTarget.GetValueOrNull();
if (target == nullptr || (target->Center() - Center()).Length() >= reach)
{
_currentTarget.Invalidate();
ChangeState({ TowerEntityAiState::SearchForTarget });
}
else if (_fireballTimeout <= 0)
{
_fireballTimeout = FireballTimeoutLength;
ShootFireball(target);
}
}
break;
}
}
void TowerEntity::OnExitState()
{
switch (_state.state)
{
case TowerEntityAiState::DoNothing:
case TowerEntityAiState::SearchForTarget:
break;
case TowerEntityAiState::AttackSelectedTarget:
{
_currentTarget.Invalidate();
}
break;
}
}
void TowerEntity::ShootFireball(Entity* target)
{
auto direction = (target->Center() - Center()).Normalize();
auto fireball = scene->CreateEntity<FireballEntity>(Center(), direction * 400);
fireball->playerId = playerId;
} | 25.753488 | 110 | 0.609536 | Smokey1105 |
b5400e1794ee4d2bbfcf0b5fba231f428da08d3b | 4,401 | cpp | C++ | ilwiscoreui/models/workspacemodel.cpp | ridoo/IlwisCore | 9d9837507d804a4643545a03fd40d9b4d0eaee45 | [
"Apache-2.0"
] | null | null | null | ilwiscoreui/models/workspacemodel.cpp | ridoo/IlwisCore | 9d9837507d804a4643545a03fd40d9b4d0eaee45 | [
"Apache-2.0"
] | null | null | null | ilwiscoreui/models/workspacemodel.cpp | ridoo/IlwisCore | 9d9837507d804a4643545a03fd40d9b4d0eaee45 | [
"Apache-2.0"
] | null | null | null | #include <QSqlQuery>
#include <QSqlRecord>
#include <QSqlError>
#include "kernel.h"
#include "ilwiscontext.h"
#include "workspacemodel.h"
WorkSpaceModel::WorkSpaceModel(const QString &name, QObject *parent) :
CatalogModel( Ilwis::Resource("ilwis://internalcatalog/workspaces/" + name,itWORKSPACE),parent)
{
}
WorkSpaceModel::~WorkSpaceModel()
{
}
void WorkSpaceModel::addItems(const QString& ids)
{
auto putInConfig = [&](quint64 id, int count) {
QString basekey = "users/" + Ilwis::context()->currentUser() + "/workspace-" + name();
Ilwis::Resource res = Ilwis::mastercatalog()->id2Resource(id);
if ( res.isValid()){
QString key;
if ( res.ilwisType() & itOPERATIONMETADATA){
key = QString("%1/operation-%2").arg(basekey).arg(count);
Ilwis::context()->configurationRef().addValue(QString("%1/operation-count").arg(basekey),QString::number(count + 1));
}
else{
key = QString("%1/data-%2").arg(basekey).arg(count);
Ilwis::context()->configurationRef().addValue(QString("%1/data-count").arg(basekey),QString::number(count + 1));
}
Ilwis::context()->configurationRef().addValue(key + "/url", res.url().toString());
Ilwis::context()->configurationRef().addValue(key + "/type", QString::number(res.ilwisType()));
}
};
QSqlQuery stmt(Ilwis::kernel()->database());
int count = 0;
if (_view.fixedItemCount() == 0) {
QString query = QString("Insert into workspaces (workspaceid) values(%1)").arg(_view.id());
if(!stmt.exec(query))
return;
}
// we dont want to add ids that are already in the list so we collect all ids that we have laready added
std::set<QString> presentids;
for(auto item : _operations){
presentids.insert(item->id());
}
for(auto item : _data){
presentids.insert(item->id());
}
QStringList idlist = ids.split("|");
for(auto id : idlist){
if ( presentids.find(id) != presentids.end())
continue;
quint64 idn = id.toULongLong();
putInConfig(idn, count);
_view.addFixedItem(idn);
++count;
QString query = QString("Select workspaceid from workspace where workspaceid=%1 and itemid=%2").arg(_view.id()).arg(idn);
if (stmt.exec(query)) { // already there
if ( stmt.next()) {
continue;
}else{
query = QString("Insert into workspace (workspaceid, itemid) values(%1,%2)").arg(_view.id()).arg(idn);
if(!stmt.exec(query))
return;
}
}
}
QString availableWorkspaces = Ilwis::ilwisconfig("users/" + Ilwis::context()->currentUser() + "/workspaces",QString(""));
if ( availableWorkspaces.indexOf(name()) == -1){
if ( availableWorkspaces.size() > 0){
availableWorkspaces += "|";
}
availableWorkspaces += name();
Ilwis::context()->configurationRef().addValue("users/" + Ilwis::context()->currentUser() + "/workspaces",availableWorkspaces);
}
refresh(true);
emit dataChanged();
}
void WorkSpaceModel::removeItems(const QString& ids)
{
QStringList idlist = ids.split("|");
for(auto id : idlist){
_view.removeFixedItem(id.toULongLong());
}
}
bool WorkSpaceModel::isDefault() const
{
return resource().url().toString() == Ilwis::Catalog::DEFAULT_WORKSPACE;
}
void WorkSpaceModel::gatherItems() {
bool needRefresh = _refresh;
CatalogModel::gatherItems();
if ( needRefresh){
_operations.clear();
_data.clear();
for(auto iter=_currentItems.begin(); iter != _currentItems.end(); ++iter){
if ( (*iter)->type() & itOPERATIONMETADATA){
_operations.push_back(new OperationModel((*iter)->resource(),this));
}else if ( hasType((*iter)->type(), itILWISOBJECT)){
_data.push_back(*iter);
}
}
}
refresh(false);
}
QQmlListProperty<OperationModel> WorkSpaceModel::operations()
{
refresh(true);
gatherItems();
return QQmlListProperty<OperationModel>(this, _operations);
}
QQmlListProperty<ResourceModel> WorkSpaceModel::data()
{
refresh(true);
gatherItems();
return QQmlListProperty<ResourceModel>(this, _data);
}
| 32.843284 | 134 | 0.601 | ridoo |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.