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 108 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 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 listlengths 1 9 | max_issues_count int64 1 67k ⌀ | 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 listlengths 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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1e5d7e0819ba54ac813ffee97c00328c93c74c35 | 3,953 | hpp | C++ | modules/gui/src/MetaObject/params/ui/Qt/Containers.hpp | dtmoodie/MetaObject | 8238d143d578ff9c0c6506e7e627eca15e42369e | [
"MIT"
] | 2 | 2017-10-26T04:41:49.000Z | 2018-02-09T05:12:19.000Z | modules/gui/src/MetaObject/params/ui/Qt/Containers.hpp | dtmoodie/MetaObject | 8238d143d578ff9c0c6506e7e627eca15e42369e | [
"MIT"
] | null | null | null | modules/gui/src/MetaObject/params/ui/Qt/Containers.hpp | dtmoodie/MetaObject | 8238d143d578ff9c0c6506e7e627eca15e42369e | [
"MIT"
] | 3 | 2017-01-08T21:09:48.000Z | 2018-02-10T04:27:32.000Z | #pragma once
#include "IHandler.hpp"
#include "POD.hpp"
#include <MetaObject/thread/fiber_include.hpp>
namespace mo
{
namespace UI
{
namespace qt
{
struct UiUpdateListener;
template <class T, typename Enable>
class THandler;
// **********************************************************************************
// *************************** std::pair ********************************************
// **********************************************************************************
template <typename T1, typename T2>
class THandler<std::pair<T1, T2>> : public UiUpdateHandler
{
THandler<T1> _handler1;
THandler<T2> _handler2;
public:
THandler(IParamProxy& parent)
: UiUpdateHandler(parent)
, _handler1(parent)
, _handler2(parent)
{
}
void updateUi(const std::pair<T1, T2>& data)
{
_handler1.UpdateUi(data.first);
_handler2.UpdateUi(data.second);
}
void updateParam(std::pair<T1, T2>& data)
{
_handler1(data.first);
_handler2(data.second);
}
std::vector<QWidget*> getUiWidgets(QWidget* parent)
{
auto out1 = _handler1.getUiWidgets(parent);
auto out2 = _handler2.getUiWidgets(parent);
out2.insert(out2.end(), out1.begin(), out1.end());
return out2;
}
};
// **********************************************************************************
// *************************** std::vector ******************************************
// **********************************************************************************
template <typename T>
class THandler<std::vector<T>, void> : public UiUpdateHandler
{
QSpinBox* index;
THandler<T, void> _data_handler;
public:
THandler(IParamProxy& parent)
: index(new QSpinBox())
, UiUpdateHandler(parent)
, _data_handler(parent)
{
index->setMinimum(0);
}
void updateUi(const std::vector<T>& data)
{
if (data.size())
{
index->setMaximum(static_cast<int>(data.size()));
if (index->value() < data.size())
_data_handler.updateUi(data[index->value()]);
}
}
void updateParam(std::vector<T>& data)
{
auto idx = index->value();
if (idx < data.size())
{
_data_handler.updateParam(data[idx]);
}
else if (idx == data.size())
{
T append_data;
_data_handler.updateParam(append_data);
data.push_back(append_data);
}
}
std::vector<QWidget*> getUiWidgets(QWidget* parent)
{
auto output = _data_handler.getUiWidgets(parent);
index->setParent(parent);
index->setMinimum(0);
IHandler::proxy->connect(index, SIGNAL(valueChanged(int)), IHandler::proxy, SLOT(on_update(int)));
output.push_back(index);
return output;
}
};
}
}
}
| 36.943925 | 118 | 0.362762 | dtmoodie |
1e5e5f604ac9cf7c701e5f595e85395deb0983bb | 1,044 | hpp | C++ | headers/Core/VertexBuffer.hpp | Gilqamesh/GameEngineDemo | 796bb107df5c01b875c2ae73fcfd44e7c07e3a87 | [
"MIT"
] | null | null | null | headers/Core/VertexBuffer.hpp | Gilqamesh/GameEngineDemo | 796bb107df5c01b875c2ae73fcfd44e7c07e3a87 | [
"MIT"
] | null | null | null | headers/Core/VertexBuffer.hpp | Gilqamesh/GameEngineDemo | 796bb107df5c01b875c2ae73fcfd44e7c07e3a87 | [
"MIT"
] | null | null | null | #ifndef VERTEXBUFFER_HPP
# define VERTEXBUFFER_HPP
# include "pch.hpp"
namespace NAMESPACE
{
class VertexBuffer
{
GLuint GL_ID;
public:
VertexBuffer();
/*
* Static version
* Cannot be modified
*/
VertexBuffer(const void *data, GLuint size);
/*
* Dynamic version
* Initialize it later and possibly multiple times
*/
VertexBuffer(GLuint size);
~VertexBuffer();
// to avoid destruction of OpenGL context
VertexBuffer(const VertexBuffer &other) = delete;
VertexBuffer &operator=(const VertexBuffer &other) = delete;
VertexBuffer(VertexBuffer &&other);
VertexBuffer &operator=(VertexBuffer &&other);
/*
* Caller responsibility:
* - VBO has to be dynamically initialized
* - call bind() before calling 'update'
*/
void update(const void *data, GLuint size);
/*
* Delete IndexBuffer from the OpenGL context
* Reset the object's state
*/
void release();
void bind();
void unbind();
};
}
#endif
| 19.698113 | 64 | 0.636015 | Gilqamesh |
1e604e910458d9be0caa061f2cb698ed395f3af4 | 1,198 | hpp | C++ | src/Utilities/TypeTraits/ArraySize.hpp | nilsvu/spectre | 1455b9a8d7e92db8ad600c66f54795c29c3052ee | [
"MIT"
] | 117 | 2017-04-08T22:52:48.000Z | 2022-03-25T07:23:36.000Z | src/Utilities/TypeTraits/ArraySize.hpp | GitHimanshuc/spectre | 4de4033ba36547113293fe4dbdd77591485a4aee | [
"MIT"
] | 3,177 | 2017-04-07T21:10:18.000Z | 2022-03-31T23:55:59.000Z | src/Utilities/TypeTraits/ArraySize.hpp | geoffrey4444/spectre | 9350d61830b360e2d5b273fdd176dcc841dbefb0 | [
"MIT"
] | 85 | 2017-04-07T19:36:13.000Z | 2022-03-01T10:21:00.000Z | // Distributed under the MIT License.
// See LICENSE.txt for details.
#pragma once
#include <array>
#include <cstddef>
#include <type_traits>
namespace tt {
namespace TypeTraits_detail {
template <typename T, std::size_t N>
std::integral_constant<std::size_t, N> array_size_impl(
const std::array<T, N>& /*array*/);
} // namespace TypeTraits_detail
/// @{
/// \ingroup TypeTraitsGroup
/// \brief Get the size of a std::array as a std::integral_constant
///
/// \details
/// Given a std::array, `Array`, returns a std::integral_constant that has the
/// size of the array as its value
///
/// \usage
/// For a std::array `T`
/// \code
/// using result = tt::array_size<T>;
/// \endcode
///
/// \metareturns
/// std::integral_constant<std::size_t>
///
/// \semantics
/// For a type `T`,
/// \code
/// using tt::array_size<std::array<T, N>> = std::integral_constant<std::size_t,
/// N>;
/// \endcode
///
/// \example
/// \snippet Test_ArraySize.cpp array_size_example
/// \tparam Array the whose size should be stored in value of array_size
template <typename Array>
using array_size =
decltype(TypeTraits_detail::array_size_impl(std::declval<const Array&>()));
/// @}
} // namespace tt
| 24.44898 | 80 | 0.676962 | nilsvu |
1e608cfaf014f68ea89b95293dc04a361045792e | 7,535 | cpp | C++ | mitsuba-af602c6fd98a/src/libbidir/mut_mchain.cpp | NTForked-ML/pbrs | 0b405d92c12d257e2581366542762c9f0c3facce | [
"MIT"
] | 139 | 2017-04-21T00:22:34.000Z | 2022-02-16T20:33:10.000Z | mitsuba-af602c6fd98a/src/libbidir/mut_mchain.cpp | NTForked-ML/pbrs | 0b405d92c12d257e2581366542762c9f0c3facce | [
"MIT"
] | 11 | 2017-08-15T18:22:59.000Z | 2019-07-01T05:44:41.000Z | mitsuba-af602c6fd98a/src/libbidir/mut_mchain.cpp | NTForked-ML/pbrs | 0b405d92c12d257e2581366542762c9f0c3facce | [
"MIT"
] | 30 | 2017-07-21T03:56:45.000Z | 2022-03-11T06:55:34.000Z | /*
This file is part of Mitsuba, a physically based rendering system.
Copyright (c) 2007-2014 by Wenzel Jakob and others.
Mitsuba is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License Version 3
as published by the Free Software Foundation.
Mitsuba 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/>.
*/
#include <mitsuba/core/statistics.h>
#include <mitsuba/bidir/mut_mchain.h>
MTS_NAMESPACE_BEGIN
static StatsCounter statsAccepted("Multi-chain perturbation",
"Acceptance rate", EPercentage);
static StatsCounter statsGenerated("Multi-chain perturbation",
"Successful generation rate", EPercentage);
MultiChainPerturbation::MultiChainPerturbation(const Scene *scene, Sampler *sampler,
MemoryPool &pool, Float minJump, Float coveredArea) :
m_scene(scene), m_sampler(sampler), m_pool(pool) {
if (!scene->getSensor()->getClass()->derivesFrom(MTS_CLASS(PerspectiveCamera)))
Log(EError, "The multi-chain perturbation requires a perspective camera.");
Vector2i sizeInPixels = scene->getFilm()->getCropSize();
m_filmRes = Vector2((Float) sizeInPixels.x, (Float) sizeInPixels.y);
m_imagePlaneArea = m_filmRes.x * m_filmRes.y;
/* Pixel jump range (in pixels) [Veach, p.354] */
m_r1 = minJump;
m_r2 = std::sqrt(coveredArea * m_filmRes.x * m_filmRes.y / M_PI);
m_theta1 = degToRad(0.0001f);
m_theta2 = degToRad(0.1f);
m_logRatio = -math::fastlog(m_r2/m_r1);
m_thetaLogRatio = -math::fastlog(m_theta2/m_theta1);
}
MultiChainPerturbation::~MultiChainPerturbation() { }
Mutator::EMutationType MultiChainPerturbation::getType() const {
return EMultiChainPerturbation;
}
Float MultiChainPerturbation::suitability(const Path &path) const {
int k = path.length(), m = k - 1, l = m-1, nChains = 1;
while (l-1 >= 0 && (!path.vertex(l)->isConnectable()
|| !path.vertex(l-1)->isConnectable())) {
if (path.vertex(l)->isConnectable())
++nChains;
--l;
}
return (l-1 >= 0) && nChains >= 2;
}
bool MultiChainPerturbation::sampleMutation(
Path &source, Path &proposal, MutationRecord &muRec, const MutationRecord& sourceMuRec) {
int k = source.length(), m = k - 1, l = m-1, nChains = 1;
while (l-1 >= 0 && (!source.vertex(l)->isConnectable()
|| !source.vertex(l-1)->isConnectable())) {
if (source.vertex(l)->isConnectable())
++nChains;
--l;
}
--l;
if (l < 0 || nChains < 2)
return false;
muRec = MutationRecord(EMultiChainPerturbation, l, m, m-l,
source.getPrefixSuffixWeight(l, m));
statsAccepted.incrementBase();
statsGenerated.incrementBase();
/* Generate a screen-space offset */
Float r = m_r2 * math::fastexp(m_logRatio * m_sampler->next1D());
Float phi = m_sampler->next1D() * 2 * M_PI;
Vector2 offset(r*std::cos(phi), r*std::sin(phi));
Point2 proposalSamplePosition = source.getSamplePosition() + offset;
/* Immediately reject if we went off the image plane */
if (proposalSamplePosition.x <= 0 || proposalSamplePosition.x >= m_filmRes.x
|| proposalSamplePosition.y <= 0 || proposalSamplePosition.y >= m_filmRes.y)
return false;
const PerspectiveCamera *sensor = static_cast<const PerspectiveCamera *>(m_scene->getSensor());
Ray ray;
if (sensor->sampleRay(ray, proposalSamplePosition, Point2(0.5f), 0.0f).isZero())
return false;
Float focusDistance = sensor->getFocusDistance() /
absDot(sensor->getWorldTransform(0)(Vector(0,0,1)), ray.d);
/* Correct direction based on the current aperture sample.
This is necessary to support thin lens cameras */
Vector d = normalize(ray(focusDistance) - source.vertex(m)->getPosition());
/* Allocate memory for the proposed path */
proposal.clear();
proposal.append(source, 0, l);
if (l > 0)
proposal.append(source.edge(l-1));
proposal.append(source.vertex(l)->clone(m_pool));
for (int i=l; i<m-1; ++i) {
proposal.append(m_pool.allocEdge());
proposal.append(m_pool.allocVertex());
}
proposal.append(m_pool.allocEdge());
proposal.append(source.vertex(m)->clone(m_pool));
proposal.append(source.edge(m));
proposal.append(source.vertex(k));
BDAssert(proposal.vertexCount() == source.vertexCount());
BDAssert(proposal.edgeCount() == source.edgeCount());
Float dist = source.edge(m-1)->length
+ perturbMediumDistance(m_sampler, source.vertex(m-1));
/* Sample a perturbation and propagate it through specular interactions */
if (!proposal.vertex(m)->perturbDirection(m_scene,
proposal.vertex(k), proposal.edge(m),
proposal.edge(m-1), proposal.vertex(m-1), d, dist,
source.vertex(m-1)->getType(), ERadiance)) {
proposal.release(l, m+1, m_pool);
return false;
}
/* If necessary, propagate the perturbation through a sequence of
ideally specular interactions */
for (int i=m-1; i>l+1; --i) {
if (!source.vertex(i)->isConnectable()) {
Float dist = source.edge(i-1)->length +
perturbMediumDistance(m_sampler, source.vertex(i-1));
if (!proposal.vertex(i)->propagatePerturbation(m_scene,
proposal.vertex(i+1), proposal.edge(i),
proposal.edge(i-1), proposal.vertex(i-1),
source.vertex(i)->getComponentType(), dist,
source.vertex(i-1)->getType(), ERadiance)) {
proposal.release(l, m+1, m_pool);
return false;
}
} else {
Vector oldD = source.vertex(i-1)->getPosition()
- source.vertex(i)->getPosition();
Float dist = oldD.length();
oldD /= dist;
Float theta = m_theta2 * math::fastexp(m_thetaLogRatio * m_sampler->next1D());
Float phi = 2 * M_PI * m_sampler->next1D();
Vector newD = Frame(oldD).toWorld(sphericalDirection(theta, phi));
dist += perturbMediumDistance(m_sampler, source.vertex(i-1));
if (!proposal.vertex(i)->perturbDirection(m_scene,
proposal.vertex(i+1), proposal.edge(i),
proposal.edge(i-1), proposal.vertex(i-1),
newD, dist, source.vertex(i-1)->getType(),
ERadiance)) {
proposal.release(l, m+1, m_pool);
return false;
}
}
}
if (!PathVertex::connect(m_scene,
l > 0 ? proposal.vertex(l-1) : NULL,
l > 0 ? proposal.edge(l-1) : NULL,
proposal.vertex(l),
proposal.edge(l),
proposal.vertex(l+1),
proposal.edge(l+1),
proposal.vertex(l+2))) {
proposal.release(l, m+1, m_pool);
return false;
}
proposal.vertex(k-1)->updateSamplePosition(
proposal.vertex(k-2));
BDAssert(proposal.matchesConfiguration(source));
++statsGenerated;
return true;
}
Float MultiChainPerturbation::Q(const Path &source, const Path &proposal,
const MutationRecord &muRec) const {
int l = muRec.l, m = muRec.m;
Spectrum weight = muRec.weight *
proposal.edge(l)->evalCached(proposal.vertex(l), proposal.vertex(l+1),
PathEdge::EEverything);
for (int i=m; i>l+1; --i) {
const PathVertex *v0 = proposal.vertex(i-1),
*v1 = proposal.vertex(i);
const PathEdge *edge = proposal.edge(i-1);
weight *= edge->evalCached(v0, v1,
PathEdge::ETransmittance | (i != m ? PathEdge::EValueCosineRad : 0));
if (v0->isMediumInteraction())
weight /= pdfMediumPerturbation(source.vertex(i-1),
source.edge(i-1), edge);
}
return 1.0f / weight.getLuminance();
}
void MultiChainPerturbation::accept(const MutationRecord &) {
++statsAccepted;
}
MTS_IMPLEMENT_CLASS(MultiChainPerturbation, false, Mutator)
MTS_NAMESPACE_END
| 32.339056 | 96 | 0.700464 | NTForked-ML |
1e61d8c2c5e2e4fb2d876dc729f8371efa3e8b9c | 4,548 | hh | C++ | include/sdf/Mesh.hh | scpeters-test/sdformat | 4668d7857e1d18d8d9b68b40537f77d540353448 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | include/sdf/Mesh.hh | scpeters-test/sdformat | 4668d7857e1d18d8d9b68b40537f77d540353448 | [
"ECL-2.0",
"Apache-2.0"
] | 3 | 2020-10-30T19:22:51.000Z | 2020-12-03T20:57:20.000Z | include/sdf/Mesh.hh | scpeters-test/sdformat | 4668d7857e1d18d8d9b68b40537f77d540353448 | [
"ECL-2.0",
"Apache-2.0"
] | null | null | null | /*
* Copyright 2018 Open Source Robotics Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#ifndef SDF_MESH_HH_
#define SDF_MESH_HH_
#include <string>
#include <ignition/math/Vector3.hh>
#include <sdf/Element.hh>
#include <sdf/Error.hh>
#include <sdf/sdf_config.h>
namespace sdf
{
// Inline bracket to help doxygen filtering.
inline namespace SDF_VERSION_NAMESPACE {
//
// Forward declare private data class.
class MeshPrivate;
/// \brief Mesh represents a mesh shape, and is usually accessed through a
/// Geometry.
class SDFORMAT_VISIBLE Mesh
{
/// \brief Constructor
public: Mesh();
/// \brief Copy constructor
/// \param[in] _mesh Mesh to copy.
public: Mesh(const Mesh &_mesh);
/// \brief Move constructor
/// \param[in] _mesh Mesh to move.
public: Mesh(Mesh &&_mesh) noexcept;
/// \brief Destructor
public: virtual ~Mesh();
/// \brief Move assignment operator.
/// \param[in] _mesh Mesh to move.
/// \return Reference to this.
public: Mesh &operator=(Mesh &&_mesh);
/// \brief Copy Assignment operator.
/// \param[in] _mesh The mesh to set values from.
/// \return *this
public: Mesh &operator=(const Mesh &_mesh);
/// \brief Load the mesh geometry based on a element pointer.
/// This is *not* the usual entry point. Typical usage of the SDF DOM is
/// through the Root object.
/// \param[in] _sdf The SDF Element pointer
/// \return Errors, which is a vector of Error objects. Each Error includes
/// an error code and message. An empty vector indicates no error.
public: Errors Load(ElementPtr _sdf);
/// \brief Get the mesh's URI.
/// \return The URI of the mesh data.
public: std::string Uri() const;
/// \brief Set the mesh's URI.
/// \param[in] _uri The URI of the mesh.
public: void SetUri(const std::string &_uri);
/// \brief The path to the file where this element was loaded from.
/// \return Full path to the file on disk.
public: const std::string &FilePath() const;
/// \brief Set the path to the file where this element was loaded from.
/// \paramp[in] _filePath Full path to the file on disk.
public: void SetFilePath(const std::string &_filePath);
/// \brief Get the mesh's scale factor.
/// \return The mesh's scale factor.
public: ignition::math::Vector3d Scale() const;
/// \brief Set the mesh's scale factor.
/// \return The mesh's scale factor.
public: void SetScale(const ignition::math::Vector3d &_scale);
/// \brief A submesh, contained with the mesh at the specified URI, may
/// optionally be specified. If specified, this submesh should be used
/// instead of the entire mesh.
/// \return The name of the submesh within the mesh at the specified URI.
public: std::string Submesh() const;
/// \brief Set the mesh's submesh. See Submesh() for more information.
/// \param[in] _submesh Name of the submesh. The name should match a submesh
/// within the mesh at the specified URI.
public: void SetSubmesh(const std::string &_submesh);
/// \brief Get whether the submesh should be centered at 0,0,0. This will
/// effectively remove any transformations on the submesh before the poses
/// from parent links and models are applied. The return value is only
/// applicable if a SubMesh has been specified.
/// \return True if the submesh should be centered.
public: bool CenterSubmesh() const;
/// \brief Set whether the submesh should be centered. See CenterSubmesh()
/// for more information.
/// \param[in] _center True to center the submesh.
public: void SetCenterSubmesh(const bool _center);
/// \brief Get a pointer to the SDF element that was used during load.
/// \return SDF element pointer. The value will be nullptr if Load has
/// not been called.
public: sdf::ElementPtr Element() const;
/// \brief Private data pointer.
private: MeshPrivate *dataPtr;
};
}
}
#endif
| 35.255814 | 80 | 0.679639 | scpeters-test |
1e623ef13e1deeb8e6529b0e43f8400820d9ad21 | 218 | cpp | C++ | atcoder.jp/abc079/abc079_b/Main.cpp | shikij1/AtCoder | 7ae2946efdceaea3cc8725e99a2b9c137598e2f8 | [
"MIT"
] | null | null | null | atcoder.jp/abc079/abc079_b/Main.cpp | shikij1/AtCoder | 7ae2946efdceaea3cc8725e99a2b9c137598e2f8 | [
"MIT"
] | null | null | null | atcoder.jp/abc079/abc079_b/Main.cpp | shikij1/AtCoder | 7ae2946efdceaea3cc8725e99a2b9c137598e2f8 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
int N;
long long L[87];
int main()
{
cin >> N;
L[0] = 2, L[1] = 1;
for (int i = 2; i <= N; i++)
L[i] = L[i - 2] + L[i - 1];
cout << L[N] << endl;
}
| 16.769231 | 35 | 0.431193 | shikij1 |
1e6242b4f49b61efab81244b75026d88cdee6135 | 14,107 | cpp | C++ | src/app/qranker-barista/SpecFeatures.cpp | johnhalloran321/crux-toolkit | 329390c63a4ec8ab4add22d847732dfa2e7f74ca | [
"Apache-2.0"
] | 8 | 2018-02-26T00:56:14.000Z | 2021-10-31T03:45:53.000Z | src/app/qranker-barista/SpecFeatures.cpp | johnhalloran321/crux-toolkit | 329390c63a4ec8ab4add22d847732dfa2e7f74ca | [
"Apache-2.0"
] | null | null | null | src/app/qranker-barista/SpecFeatures.cpp | johnhalloran321/crux-toolkit | 329390c63a4ec8ab4add22d847732dfa2e7f74ca | [
"Apache-2.0"
] | null | null | null | #include "SpecFeatures.h"
const double SpecFeaturesGenerator::mass_h2o_mono = 18.01056;
const double SpecFeaturesGenerator::mass_nh3_mono = 17.02655;
const double SpecFeaturesGenerator::mass_co_mono = 27.9949;
const double SpecFeaturesGenerator::proton_mass = 1.00727646688;
const double SpecFeaturesGenerator::bin_width_mono = 1.0005079;
SpecFeaturesGenerator :: SpecFeaturesGenerator():
max_mz_(1025),
ts_m3_(NULL), ts_m7_(NULL),
spectra_(NULL), spectrum_(NULL)
{
mz_values_.reserve(1000);
intens_values_.reserve(1000);
peaks_.resize(max_mz_, 0.0);
}
SpecFeaturesGenerator :: ~SpecFeaturesGenerator()
{
if (spectra_) {
delete spectra_;
}
if (spectrum_) {
delete spectrum_;
}
clear();
}
void SpecFeaturesGenerator :: clear()
{
max_mz_ = 0;
clear_tspec(ts_m3_, 3); ts_m3_ = NULL;
clear_tspec(ts_m7_, 7); ts_m7_ = NULL;
}
void SpecFeaturesGenerator :: read_spectrum()
{
precursor_mz_ = spectrum_->getPrecursorMz();
mz_values_.clear();
intens_values_.clear();
for (PeakIterator i = spectrum_->begin(); i != spectrum_->end(); ++i) {
Peak* peak = *i;
FLOAT_T mz = peak->getLocation();
mz_values_.push_back(mz);
intens_values_.push_back(peak->getIntensity());
/*int mz_bin = (int)(mz / bin_width_mono + 0.5);
if (mz_bin >= max_mz_) {
max_mz_ = mz_bin + 1;
}*/
}
}
void SpecFeaturesGenerator :: shift_peaks()
{
#if 1
int n = peaks_.size();
vector<double> sums(n);
vector<double> integral(n+1);
integral[0] = 0;
for (int i=0; i<n; i++)
integral[i+1] = integral[i] + peaks_[i];
for (int i=0; i<n; i++)
{
int ilo = i - max_xcorr_offset;
int ihi = i + max_xcorr_offset+1;
sums[i] = integral[ihi<=n ? ihi : n] - integral[ilo>=0 ? ilo : 0];
}
#else
vector<double> sums;
sums.resize(peaks_.size(),0.0);
for(unsigned int idx = 0; idx < peaks_.size(); idx++)
{
for(int sub_idx = idx-max_xcorr_offset; sub_idx <= idx+max_xcorr_offset; sub_idx++)
if(sub_idx > -1 && sub_idx < peaks_.size())
sums[idx] += peaks_[sub_idx];
}
#endif
for(unsigned int idx = 0; idx < peaks_.size(); idx++)
peaks_[idx] -= (sums[idx]/(max_xcorr_offset*2.0+1));
}
void SpecFeaturesGenerator :: normalize_each_region(double max_intensity_overall, vector<double> &max_intensity_per_region,
int region_selector)
{
int region_idx = 0;
double max_intensity = max_intensity_per_region[region_idx];
for (int i = 0; i < (int)peaks_.size(); i++)
{
if(i >= (region_idx+1)*region_selector && (region_idx+1)<num_regions)
{
region_idx++;
max_intensity = max_intensity_per_region[region_idx];
}
// Don't normalize if no peaks in region, and for compatibility
// with SEQUEST drop peaks with intensity less than 1/20 of
// the overall max intensity.
if((max_intensity != 0)
&& (peaks_[i] > 0.05 * max_intensity_overall))
{
// normalize intensity to max 50
peaks_[i] = (peaks_[i] /max_intensity) * max_per_region;
}
// no more peaks beyond the 10 regions mark, exit
if(i > num_regions * region_selector){
return;
}
}
}
void SpecFeaturesGenerator :: process_observed_spectrum()
{
double experimental_mass_cut_off = precursor_mz_ * charge_ + 50.0;
if ((int)peaks_.size() != max_mz_)
peaks_.resize(max_mz_);
peaks_.assign(peaks_.size(), 0.0);
assert(mz_values_.size() == intens_values_.size());
double max_peak_location = 0.0;
double max_peak_intensity = 0.0;
for (unsigned int i = 0; i < mz_values_.size(); i++) {
double peak_location = mz_values_[i];
if (peak_location < experimental_mass_cut_off &&
peak_location > max_peak_location)
max_peak_location = peak_location;
}
int region_selector = (int)max_peak_location / num_regions;
vector<double> max_peak_intensity_per_region;
max_peak_intensity_per_region.resize(num_regions,0.0);
for (unsigned int i = 0; i < mz_values_.size(); i++)
{
double peak_location = mz_values_[i];
double peak_intensity = intens_values_[i];
//if above experimental mass, skip
if (peak_location > experimental_mass_cut_off)
continue;
// skip all peaks within precursor ion mz +/- 15
if (peak_location < precursor_mz_ + 15 &&
peak_location > precursor_mz_ - 15)
continue;
//get the bin and the region
int mz = (int)(peak_location / bin_width_mono + 0.5);
int region = mz / region_selector;
// don't let index beyond array
if (region >= num_regions) {
continue;
}
//update max mz over all spectra
/*if (mz >= max_mz_) {
max_mz_ = mz + 1;
peaks_.resize(max_mz_,0.0);
}*/
// sqrt the original intensity
peak_intensity = sqrt(peak_intensity);
if (peak_intensity > max_peak_intensity)
max_peak_intensity = peak_intensity;
if (peaks_[mz] < peak_intensity) {
peaks_[mz] = peak_intensity;
// check if this peak is max intensity in the region(one out of 10)
if (max_peak_intensity_per_region[region] < peak_intensity) {
max_peak_intensity_per_region[region] = peak_intensity;
}
}
}
normalize_each_region(max_peak_intensity, max_peak_intensity_per_region,
region_selector);
shift_peaks();
}
void SpecFeaturesGenerator :: read_ms2_file(const string& filename)
{
spectra_ = SpectrumCollectionFactory::create(filename.c_str());
spectra_->parse();
// TODO hack for finding max m/z out of all spectra
for (SpectrumIterator i = spectra_->begin(); i != spectra_->end(); ++i) {
int mz_bin = (int)((*i)->getMaxPeakMz() / bin_width_mono + 0.5);
if (mz_bin >= max_mz_) {
max_mz_ = mz_bin + 1;
}
}
}
/*************************************************************************************/
void SpecFeaturesGenerator :: get_observed_spectrum(int scan)
{
if (spectrum_) {
delete spectrum_;
spectrum_ = NULL;
}
for (SpectrumIterator i = spectra_->begin(); i != spectra_->end(); ++i) {
if (scan == (*i)->getFirstScan()) {
spectrum_ = new Crux::Spectrum();
spectrum_->copyFrom(*i);
break;
}
}
// TODO this doesn't work because subclasses of spectrumcollection override
//spectrum_ = spectra_->getSpectrum(scan);
// not found in MS2 file
if (!spectrum_)
carp(CARP_FATAL, "Spectrum \"%d\" not found in MS2 file", scan);
read_spectrum();
process_observed_spectrum();
}
void SpecFeaturesGenerator :: clear_tspec(double **tspec, int num_features)
{
if (tspec) {
for (int i = 0; i < num_features; i++)
if (tspec[i]) {
delete [] tspec[i];
tspec[i] = NULL;
}
delete [] tspec;
tspec = NULL;
}
}
void SpecFeaturesGenerator :: allocate_tspec(double ***tspec, int num_features)
{
(*tspec) = new double*[num_features];
for(int i = 0; i < num_features; i++)
(*tspec)[i] = new double[max_mz_];
}
void SpecFeaturesGenerator :: zero_out_tspec(double **tspec, int num_features)
{
for(int i = 0; i < num_features; i++)
memset(tspec[i], 0, sizeof(double) * max_mz_);
}
void SpecFeaturesGenerator :: add_intensity(double *tspec, int idx, double intensity)
{
if(idx > -1 && idx < max_mz_ &&
tspec[idx] < intensity) {
tspec[idx] = intensity;
}
}
double SpecFeaturesGenerator :: sproduct(double *tspec)
{
double sm = 0;
for (unsigned int i = 0; i < peaks_.size(); i++)
sm += tspec[i] * peaks_[i];
return sm;
}
void SpecFeaturesGenerator :: get_spec_features_m3(int scan, int ch, string &peptide, double *features)
{
charge_ = ch;
get_observed_spectrum(scan);
//allocate the theoretical spectrum if necessary
if (!ts_m3_)
allocate_tspec(&ts_m3_, 3);
zero_out_tspec(ts_m3_, 3);
double mz = 0;
int idx = 0;
double fragment_mass;
//start from the beginning of the peptide and do the B-ION
fragment_mass = 0.0;
for(unsigned int i = 0; i < peptide.size()-1;i++)
{
char aa = peptide.at(i);
if(aa != '.')
{
//do the B-ION
fragment_mass += aa_masses_mono[aa-'A'];
//add the fragment
for (int charg = 1; charg < ch; charg++)
{
//add the ion itself
mz = (fragment_mass+charg*proton_mass)/charg;
idx = (int)(mz/bin_width_mono+0.5);
add_intensity(ts_m3_[0], idx, 1.0);
//add its flanking peaks
add_intensity(ts_m3_[1], idx-1, 1.0);
add_intensity(ts_m3_[1], idx+1, 1.0);
//add its neutral losses nh3 and h2o
double mz_nh3 = mz-(mass_nh3_mono/charg);
idx = (int)(mz_nh3/bin_width_mono+0.5);
add_intensity(ts_m3_[2], idx, 1.0);
double mz_h2o = mz-(mass_h2o_mono/charg);
idx = (int)(mz_h2o/bin_width_mono+0.5);
add_intensity(ts_m3_[2], idx, 1.0);
//add neutral loss co
double mz_co = mz-(mass_co_mono/charg);
idx = (int)(mz_co/bin_width_mono+0.5);
add_intensity(ts_m3_[2], idx, 1.0);
}
}
}
//do the Y-ION
fragment_mass = mass_h2o_mono;
for(unsigned int i = peptide.size(); i > 1;i--)
{
char aa = peptide.at(i-1);
if(aa != '.')
{
fragment_mass += aa_masses_mono[aa-'A'];
//add the fragment
for (int charg = 1; charg < ch; charg++)
{
//add the ion itself
mz = (fragment_mass+charg*proton_mass)/charg;
idx = (int)(mz/bin_width_mono+0.5);
add_intensity(ts_m3_[0], idx, 1.0);
//add its flanking peaks
add_intensity(ts_m3_[1], idx-1, 1.0);
add_intensity(ts_m3_[1], idx+1, 1.0);
//add its neutral losses
double mz_nh3 = mz-(mass_nh3_mono/charg);
idx = (int)(mz_nh3/bin_width_mono+0.5);
add_intensity(ts_m3_[2], idx, 1.0);
//double mz_h2o = mz-(mass_h2o_mono/charg);
//idx = (int)(mz_h2o/bin_width_mono+0.5);
//add_intensity(ts_m3[2], idx, 1.0);
}
}
}
features[0] = sproduct(ts_m3_[0]);
features[1] = sproduct(ts_m3_[1]);
features[2] = sproduct(ts_m3_[2]);
//cout << features[0] << " " << features[1] << " " << features[2] << endl;
}
void SpecFeaturesGenerator :: get_spec_features_m7(int scan, int ch, string &peptide, double *features)
{
charge_ = ch;
get_observed_spectrum(scan);
//allocate the theoretical spectrum if necessary
if (!ts_m7_)
allocate_tspec(&ts_m7_, 7);
zero_out_tspec(ts_m7_, 7);
/*
* 0. b-ion
* 1. y_ion
* 2. flanking
* 3. h2o_nl
* 4. co2_nl
* 5. nh3_nl_b
* 6. nh3_nl_y
*/
double mz = 0;
int idx = 0;
double fragment_mass;
//start from the beginning of the peptide and do the B-ION
fragment_mass = 0.0;
for(unsigned int i = 0; i < peptide.size()-1;i++)
{
char aa = peptide.at(i);
if(aa != '.')
{
//do the B-ION
fragment_mass += aa_masses_mono[aa-'A'];
//add the fragment
for (int charg = 1; charg < ch; charg++)
{
//add the ion itself
mz = (fragment_mass+charg*proton_mass)/charg;
idx = (int)(mz/bin_width_mono+0.5);
//0 in array
add_intensity(ts_m7_[0], idx, 1.0);
//add its flanking peaks (2 in array)
add_intensity(ts_m7_[2], idx-1, 1.0);
add_intensity(ts_m7_[2], idx+1, 1.0);
//add its neutral losses nh3(5 in array)
double mz_nh3 = mz-(mass_nh3_mono/charg);
idx = (int)(mz_nh3/bin_width_mono+0.5);
add_intensity(ts_m7_[5], idx, 1.0);
//add h2o (3 in array)
double mz_h2o = mz-(mass_h2o_mono/charg);
idx = (int)(mz_h2o/bin_width_mono+0.5);
add_intensity(ts_m7_[3], idx, 1.0);
//add neutral loss co (4 in array)
double mz_co = mz-(mass_co_mono/charg);
idx = (int)(mz_co/bin_width_mono+0.5);
add_intensity(ts_m7_[4], idx, 1.0);
}
}
}
//do the Y-ION
fragment_mass = mass_h2o_mono;
for(unsigned int i = peptide.size(); i > 1;i--)
{
char aa = peptide.at(i-1);
if(aa != '.')
{
fragment_mass += aa_masses_mono[aa-'A'];
//add the fragment
for (int charg = 1; charg < ch; charg++)
{
//add the ion itself ( 1 in array)
mz = (fragment_mass+charg*proton_mass)/charg;
idx = (int)(mz/bin_width_mono+0.5);
add_intensity(ts_m7_[1], idx, 1.0);
//add its flanking peaks ( 2 in array)
add_intensity(ts_m7_[2], idx-1, 1.0);
add_intensity(ts_m7_[2], idx+1, 1.0);
//add its neutral losses (6 in array)
double mz_nh3 = mz-(mass_nh3_mono/charg);
idx = (int)(mz_nh3/bin_width_mono+0.5);
add_intensity(ts_m7_[6], idx, 1.0);
}
}
}
features[0] = sproduct(ts_m7_[0]);
features[1] = sproduct(ts_m7_[1]);
features[2] = sproduct(ts_m7_[2]);
features[3] = sproduct(ts_m7_[3]);
features[4] = sproduct(ts_m7_[4]);
features[5] = sproduct(ts_m7_[5]);
features[6] = sproduct(ts_m7_[6]);
//cout << features[0] << " " << features[1] << " " << features[2] << " " << features[3] << " " << features[4] << " " << features[5] << " " << features[6] << endl;
}
void SpecFeaturesGenerator :: initialize_aa_tables()
{
aa_masses_mono.resize(NUM_AA,0.0);
aa_masses_mono['A' - 'A'] = 71.03711;
aa_masses_mono['B' - 'A'] = 114.53494;
aa_masses_mono['C' - 'A'] = 103.00919;
aa_masses_mono['D' - 'A'] = 115.02694;
aa_masses_mono['E' - 'A'] = 129.04259;
aa_masses_mono['F' - 'A'] = 147.06841;
aa_masses_mono['G' - 'A'] = 57.02146;
aa_masses_mono['H' - 'A'] = 137.05891;
aa_masses_mono['I' - 'A'] = 113.08406;
aa_masses_mono['K' - 'A'] = 128.09496;
aa_masses_mono['L' - 'A'] = 113.08406;
aa_masses_mono['M' - 'A'] = 131.04049;
aa_masses_mono['N' - 'A'] = 114.04293;
aa_masses_mono['O' - 'A'] = 114.07931;
aa_masses_mono['P' - 'A'] = 97.05276;
aa_masses_mono['Q' - 'A'] = 128.05858;
aa_masses_mono['R' - 'A'] = 156.10111;
aa_masses_mono['S' - 'A'] = 87.03203;
aa_masses_mono['T' - 'A'] = 101.04768;
aa_masses_mono['U' - 'A'] = 150.04344;
aa_masses_mono['V' - 'A'] = 99.06841;
aa_masses_mono['W' - 'A'] = 186.07931;
aa_masses_mono['X' - 'A'] = 113.08406;
aa_masses_mono['Y' - 'A'] = 163.06333;
aa_masses_mono['Z' - 'A'] = 128.55059;
//nl_masses_mono.resize(NUM_NL,0.0);
//nl_masses_mono[H2O] = mass_h2o_mono;
//nl_masses_mono[NH3] = mass_nh3_mono;
//nl_masses_mono[CO] = mass_co_mono;
}
| 28.214 | 164 | 0.623591 | johnhalloran321 |
1e6272cc6b091f11b2b8ec7df3139e3c63b3c2d6 | 3,234 | cpp | C++ | Code en C++ de Mage War Online/VikingHammer.cpp | Drakandes/Portfolio_NicolasPaulBonneau | c8115d5ecd6c284113766d64d0f907c074315cff | [
"MIT"
] | null | null | null | Code en C++ de Mage War Online/VikingHammer.cpp | Drakandes/Portfolio_NicolasPaulBonneau | c8115d5ecd6c284113766d64d0f907c074315cff | [
"MIT"
] | null | null | null | Code en C++ de Mage War Online/VikingHammer.cpp | Drakandes/Portfolio_NicolasPaulBonneau | c8115d5ecd6c284113766d64d0f907c074315cff | [
"MIT"
] | null | null | null | #include "stdafx.h"
#include "VikingHammer.h"
VikingHammer::VikingHammer()
{
texture_projectile.loadFromFile("VikingHammer.png");
shadow_texture.loadFromFile("VikingHammerShadow.png");
}
VikingHammer::~VikingHammer()
{
}
void VikingHammer::Init(sf::Vector2f &position_initial, float damage_received, float direction_projectile_received, int id_caster, float speed, bool can_affect_player, bool can_affect_monster)
{
id_parent = id_caster;
direction_projectile = direction_projectile_received;
damage_initial = damage_received;
damage = damage_received;
position_origin = position_initial;
range_projectile = 800;
this->can_affect_player = can_affect_player;
this->can_affect_monster = can_affect_monster;
size_projectile = sf::Vector2f(100, 60);
shadow_size = size_projectile;
speed_projectile = speed;
projectile = GlobalFunction::CreateSprite(position_initial, size_projectile, texture_projectile);
projectile.setTextureRect(sf::IntRect(0, 0, size_projectile.x, size_projectile.y));
projectile.setRotation(direction_projectile);
shadow = GlobalFunction::CreateSprite(sf::Vector2f(0, 0), shadow_size, shadow_texture);
shadow.setRotation(direction_projectile);
}
void VikingHammer::CuttingSprite()
{
if (clock_animation.getElapsedTime().asSeconds() >= 0.01)
{
projectile.setTextureRect(sf::IntRect(size_projectile.x*source_x, 0, size_projectile.x, size_projectile.y));
shadow.setTextureRect(sf::IntRect(size_projectile.x*source_x, 0, size_projectile.x, size_projectile.y));
source_x++;
if (source_x == 20)
{
source_x = 0;
}
clock_animation.restart();
}
}
void VikingHammer::Update(float DELTATIME, sf::Vector2f player_position)
{
MovementGestion(DELTATIME);
CuttingSprite();
}
float VikingHammer::GetDamage()
{
return damage;
}
void VikingHammer::DealWithCollision(std::shared_ptr<CollisionalObject> object_collided)
{
int id_object = object_collided->GetId();
int type_object = object_collided->GetTypeCollisionalObject();
sf::Vector2f position_self = GetCurrentPosition();
sf::Vector2f position_objet = object_collided->GetCurrentPosition();
sf::Vector2f size_object = object_collided->GetSize();
float armor_penetration = 0;
if (type_object == Player_E)
{
if (CanAffectPlayer())
{
is_to_delete = true;
float damage_dealt = object_collided->GotDamaged(GetDamage(), id_parent, 0);
if (CanStun())
{
object_collided->ChangeStunTime(GetStunTime());
}
if (CanChangeObjectStat())
{
for (int i = 0; i < GetNumberObjectStatChange(); i++)
{
object_collided->GivePlayerChangeStat(GetObjectStatChanging(i), GetObjectStatChangeDuration(i), GetObjectStatChangValue(i));
}
}
}
}
if (type_object == Monster_E)
{
if (CanAffectMonster())
{
is_to_delete = true;
float damage_dealt = object_collided->GotDamaged(GetDamage(), id_parent, armor_penetration);
TextGenerator::instance()->GenerateOneTextForBlob(position_objet, damage_dealt, size_object, object_collided);
}
}
if (type_object == NatureObject_E)
{
if (!object_collided->CheckIfProjectileDisable())
{
is_to_delete = true;
}
}
} | 28.368421 | 193 | 0.730674 | Drakandes |
1e63de01753dfa49c82abb6098bd3c4d80ef9ec7 | 2,034 | hpp | C++ | Oem/dbxml/xqilla/include/xqilla/xerces/XercesConfiguration.hpp | achilex/MgDev | f7baf680a88d37659af32ee72b9a2046910b00d8 | [
"PHP-3.0"
] | 2 | 2017-04-19T01:38:30.000Z | 2020-07-31T03:05:32.000Z | Oem/dbxml/xqilla/include/xqilla/xerces/XercesConfiguration.hpp | achilex/MgDev | f7baf680a88d37659af32ee72b9a2046910b00d8 | [
"PHP-3.0"
] | null | null | null | Oem/dbxml/xqilla/include/xqilla/xerces/XercesConfiguration.hpp | achilex/MgDev | f7baf680a88d37659af32ee72b9a2046910b00d8 | [
"PHP-3.0"
] | 1 | 2021-12-29T10:46:12.000Z | 2021-12-29T10:46:12.000Z | /*
* Copyright (c) 2001-2008
* DecisionSoft Limited. All rights reserved.
* Copyright (c) 2004-2008
* Oracle. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* $Id$
*/
#ifndef XERCESCONFIGURATION_H
#define XERCESCONFIGURATION_H
#include <xqilla/framework/XQillaExport.hpp>
#include <xqilla/simple-api/XQillaConfiguration.hpp>
#include <xqilla/items/Node.hpp>
XERCES_CPP_NAMESPACE_BEGIN
class DOMNode;
XERCES_CPP_NAMESPACE_END
class XQILLA_API XercesConfiguration : public XQillaConfiguration
{
public:
/**
* The "Xerces" DOMNode node interface.
* Use this as the parameter when you call Item::getInterface()
* to have a xerces DOMNode returned, if the Node is of the
* correct type. If it is not of the correct type, the method
* will return 0.
*/
static const XMLCh gXerces[];
virtual DocumentCache *createDocumentCache(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *memMgr);
virtual SequenceBuilder *createSequenceBuilder(const DynamicContext *context);
virtual ItemFactory *createItemFactory(DocumentCache *cache,
XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *memMgr);
virtual UpdateFactory *createUpdateFactory(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *memMgr);
virtual URIResolver *createDefaultURIResolver(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *memMgr);
virtual Node::Ptr createNode(const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *node, const DynamicContext *context) const;
};
#endif
| 33.344262 | 120 | 0.759095 | achilex |
1e663f6fc641ee122299408e6b4a32059a899e9c | 380 | hpp | C++ | BrainfuckCompiler/Assert.hpp | addrianyy/BrainfuckCompiler | 4e47cb9fc926aeae567556e5c75e095c304ae7f5 | [
"MIT"
] | 3 | 2020-05-28T21:05:44.000Z | 2020-06-23T10:03:19.000Z | BrainfuckCompiler/Assert.hpp | addrianyy/BrainfuckCompiler | 4e47cb9fc926aeae567556e5c75e095c304ae7f5 | [
"MIT"
] | null | null | null | BrainfuckCompiler/Assert.hpp | addrianyy/BrainfuckCompiler | 4e47cb9fc926aeae567556e5c75e095c304ae7f5 | [
"MIT"
] | null | null | null | #pragma once
#include <cstdint>
// Assert working on release builds.
void AssertInternal(bool condition,
const char* conditionText,
const char* filename,
uint32_t lineNumer);
#define MAKE_STRING(s) MAKE_STRING_1(s)
#define MAKE_STRING_1(s) #s
#define Assert(x) AssertInternal((x), MAKE_STRING(x), __FILE__, __LINE__) | 27.142857 | 73 | 0.652632 | addrianyy |
1e6aa11097025c50662746292dd67ea5d487998c | 2,419 | cpp | C++ | Engine/code/IA_Controller_Task.cpp | miguelangelgil/FirstEngine | 3177cffa3663c9f75bc37fe67ac52d6780acfeec | [
"MIT"
] | null | null | null | Engine/code/IA_Controller_Task.cpp | miguelangelgil/FirstEngine | 3177cffa3663c9f75bc37fe67ac52d6780acfeec | [
"MIT"
] | null | null | null | Engine/code/IA_Controller_Task.cpp | miguelangelgil/FirstEngine | 3177cffa3663c9f75bc37fe67ac52d6780acfeec | [
"MIT"
] | null | null | null | #include "headers\IA_Controller_Task.hpp"
#include <Scene.hpp>
#include <IA_Component.hpp>
#include <Transform_Component.hpp>
namespace engine
{
engine::IA_Controller_Task::IA_Controller_Task(Scene* scene, int priority) : Task(scene, priority)
{
}
bool engine::IA_Controller_Task::initialize()
{
scan_entities();
active = true;
return true;
}
bool engine::IA_Controller_Task::finalize()
{
active = false;
return true;
}
bool engine::IA_Controller_Task::step(double time)
{
for (auto&& entity : entities)
{
glm::vec3 target = dynamic_cast<IA_Component*>(entity->get_component("ia").get())->get_current_target_position();
Transform_Component* transform = dynamic_cast<Transform_Component*>(entity->get_component("transform").get());
glm::vec3 current_position = *transform->get_position();
glm::vec3 translation(0.f,0.f,0.f);
if (target.x > current_position.x)
{
translation.x = 1.f * 0.003f;
}
else if (target.x < current_position.x)
{
translation.x = - 1.f *0.003f;
}
if (target.y > current_position.y)
{
translation.y = 1.f * 0.003f;
}
else if (target.y < current_position.y)
{
translation.y = -1.f * 0.003f;
}
transform->set_traslate(translation);
}
return true;
}
void engine::IA_Controller_Task::scan_entities()
{
typedef shared_ptr<Component> component_ptr;
map<string, component_ptr> ::iterator iterator_components;
map<ID, Entity*>* scene_entities = scene->get_entities();
map<ID, Entity*> ::iterator iterator_entities = scene_entities->begin();
for (; iterator_entities != scene_entities->end(); iterator_entities++)
{
iterator_components = iterator_entities->second->get_components()->begin();
for (; iterator_components != iterator_entities->second->get_components()->end(); iterator_components++)
{
if (iterator_components->second->get_type_component() == "ia")
{
entities.push_back(iterator_entities->second);
}
}
}
}
}
| 31.415584 | 125 | 0.567177 | miguelangelgil |
1e6efa3b812a95d652142334d9d0b69311c8034a | 861 | cpp | C++ | src/expression/operation/optime.cpp | ellery85/sparselizard | 7d09e97e9443a436d74cbd241b8466527edb9e2f | [
"MIT"
] | null | null | null | src/expression/operation/optime.cpp | ellery85/sparselizard | 7d09e97e9443a436d74cbd241b8466527edb9e2f | [
"MIT"
] | null | null | null | src/expression/operation/optime.cpp | ellery85/sparselizard | 7d09e97e9443a436d74cbd241b8466527edb9e2f | [
"MIT"
] | null | null | null | #include "optime.h"
std::vector<std::vector<densematrix>> optime::interpolate(elementselector& elemselect, std::vector<double>& evaluationcoordinates, expression* meshdeform)
{
densematrix output(elemselect.countinselection(), evaluationcoordinates.size()/3, universe::currenttimestep);
// This can only be on the cos0 harmonic:
return {{},{output}};
}
densematrix optime::multiharmonicinterpolate(int numtimeevals, elementselector& elemselect, std::vector<double>& evaluationcoordinates, expression* meshdeform)
{
std::cout << "Error in 'optime' object: time variable 't' is not supported (non-periodic)" << std::endl;
abort();
}
std::shared_ptr<operation> optime::copy(void)
{
std::shared_ptr<optime> op(new optime);
*op = *this;
op->reuse = false;
return op;
}
void optime::print(void)
{
std::cout << "t";
}
| 28.7 | 159 | 0.704994 | ellery85 |
1e71268db677c5a6f060d7d1d76b3b61767d5886 | 1,049 | hpp | C++ | game/code/common/engine/gui/guiradiobutton.hpp | justinctlam/MarbleStrike | 64fe36a5a4db2b299983b0e2556ab1cd8126259b | [
"MIT"
] | null | null | null | game/code/common/engine/gui/guiradiobutton.hpp | justinctlam/MarbleStrike | 64fe36a5a4db2b299983b0e2556ab1cd8126259b | [
"MIT"
] | null | null | null | game/code/common/engine/gui/guiradiobutton.hpp | justinctlam/MarbleStrike | 64fe36a5a4db2b299983b0e2556ab1cd8126259b | [
"MIT"
] | 2 | 2019-03-08T03:02:45.000Z | 2019-05-14T08:41:26.000Z | #ifndef GUI_RADIOBUTTON_HPP
#define GUI_RADIOBUTTON_HPP
//////////////////////////////////////////////////////
// INCLUDES
//////////////////////////////////////////////////////
#include "common/engine/gui/guicheckbox.hpp"
//////////////////////////////////////////////////////
// FORWARD DECLARATIONS
//////////////////////////////////////////////////////
class GuiScreen;
//////////////////////////////////////////////////////
// CONSTANTS
//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// STRUCTURES
//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
// CLASSES
//////////////////////////////////////////////////////
class GuiRadioButton : public GuiCheckBox
{
public:
GuiRadioButton( GuiScreen* parentScreen );
virtual ~GuiRadioButton();
void SetButtonGroup( int buttonGroup )
{
mButtonGroup = buttonGroup;
}
int GetButtonGroup()
{
return mButtonGroup;
}
private:
int mButtonGroup;
};
#endif
| 20.568627 | 54 | 0.35081 | justinctlam |
1e723aadb187589d5b96e1fb6f6a9d4160106403 | 8,148 | hpp | C++ | src/main/cpp/Balau/Concurrent/Fork.hpp | borasoftware/balau | 8bb82e9cbf7aa8193880eda1de5cbca4db1e1c14 | [
"Apache-2.0"
] | 6 | 2018-12-30T15:09:26.000Z | 2020-04-20T09:27:59.000Z | src/main/cpp/Balau/Concurrent/Fork.hpp | borasoftware/balau | 8bb82e9cbf7aa8193880eda1de5cbca4db1e1c14 | [
"Apache-2.0"
] | null | null | null | src/main/cpp/Balau/Concurrent/Fork.hpp | borasoftware/balau | 8bb82e9cbf7aa8193880eda1de5cbca4db1e1c14 | [
"Apache-2.0"
] | 2 | 2019-11-12T08:07:16.000Z | 2019-11-29T11:19:47.000Z | // @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
///
/// @file Fork.hpp
///
/// Convenience wrapper for forking processes.
///
#ifndef COM_BORA_SOFTWARE__BALAU_CONCURRENT__FORK
#define COM_BORA_SOFTWARE__BALAU_CONCURRENT__FORK
#include <Balau/Exception/SystemExceptions.hpp>
#include <Balau/Dev/Assert.hpp>
#include <boost/predef.h>
#include <sys/wait.h>
namespace Balau::Concurrent {
///
/// Convenience wrapper for forking processes.
///
class Fork {
///
/// Determine whether forking is support on this platform.
///
public: static bool forkSupported() {
#pragma clang diagnostic push
#pragma ide diagnostic ignored "OCSimplifyInspection"
#pragma ide diagnostic ignored "OCDFAInspection"
return BOOST_OS_UNIX;
#pragma clang diagnostic pop
}
///
/// Perform a fork operator and run the supplied function for the child.
///
/// The child process will exit when the function returns if exitChild is set
/// to true. Otherwise, the child will return and the caller will need to
/// handle child termination.
///
/// @param function the function to run in the child process
/// @param exitChild if set to true, _Exit(int) is called with the the exit state of the function
/// @return the child pid for the parent process, the exit state of the function for the child process if it returns
/// @throw ForkException if the fork call failed
///
public: static int performFork(const std::function<int ()> & function, bool exitChild) {
Assert::assertion(forkSupported(), "fork() called for platform that does not support it.");
const int pid = ::fork();
if (pid == 0) {
const int status = function();
if (exitChild) {
_Exit(status);
} else {
return status;
}
} else if (pid > 0) {
return pid;
} else {
ThrowBalauException(Exception::ForkException, errno, "Failed to fork process.");
}
}
///
/// Perform a fork operator and run the supplied function for the child.
///
/// The child will return when the function has completed and the caller will
/// need to handle child termination.
///
/// This version does not require a function that returns an integer.
///
/// @param function the function to run in the child process
/// @return the child pid for the parent process and zero for the child process
/// @throw ForkException if the fork call failed
///
public: static int performFork(const std::function<int ()> & function) {
Assert::assertion(forkSupported(), "fork() called for platform that does not support it.");
const int pid = ::fork();
if (pid == 0) {
function();
return 0;
} else if (pid > 0) {
return pid;
} else {
ThrowBalauException(Exception::ForkException, errno, "Failed to fork process.");
}
}
///
/// A termination report, returned by wait methods.
///
/// Instances of this structure are returned from the pid checking functions
/// in this class, in order to communicate the status code of the process.
///
public: struct TerminationReport {
///
/// The PID of the process.
///
int pid;
///
/// The signal code.
///
int code;
///
/// The exit status.
///
int exitStatus;
TerminationReport() : pid(0), code(0), exitStatus(0) {}
TerminationReport(int pid_, int code_, int exitStatus_)
: pid(pid_), code(code_), exitStatus(exitStatus_) {}
TerminationReport(const TerminationReport & copy) = default;
TerminationReport(TerminationReport && rhs) noexcept
: pid(rhs.pid), code(rhs.code), exitStatus(rhs.exitStatus) {}
TerminationReport & operator = (const TerminationReport & copy) = default;
TerminationReport & operator = (TerminationReport && rhs) noexcept {
pid = rhs.pid;
code = rhs.code;
exitStatus = rhs.exitStatus;
return *this;
}
};
///
/// Wait on a process until the process terminates.
///
/// If the pid is invalid, an empty termination report is returned.
///
/// @param pid the process id
/// @return a termination report
/// @throw WaitException if the waitid call failed
///
public: static TerminationReport waitOnProcess(int pid) {
if (pid <= 0) {
return TerminationReport();
}
siginfo_t infop;
int options = WEXITED;
memset(&infop, 0, sizeof(siginfo_t));
if (waitid(P_PID, (unsigned int) pid, &infop, options) == -1) {
ThrowBalauException(Exception::WaitException, errno);
} else if (infop.si_pid) {
return TerminationReport(pid, infop.si_code, infop.si_status);
}
// TODO what else may happen here?
return TerminationReport();
}
///
/// Check the process for termination without blocking.
///
/// If the pid is invalid, an empty termination report is returned.
///
/// If the process with the specified id has not terminated, an empty
/// termination report is returned.
///
/// @param pid the process id
/// @return a termination report
/// @throw WaitException if the waitid call failed
///
public: static TerminationReport checkForTermination(int pid) {
if (pid <= 0) {
return TerminationReport();
}
siginfo_t infop;
int options = WEXITED | WNOHANG;
memset(&infop, 0, sizeof(siginfo_t));
if (waitid(P_PID, (unsigned int) pid, &infop, options) == -1) {
ThrowBalauException(Exception::WaitException, errno);
} else if (infop.si_pid) {
switch (infop.si_code) {
case CLD_EXITED:
case CLD_KILLED:
case CLD_DUMPED: {
return TerminationReport(pid, infop.si_code, infop.si_status);
}
default: {
break;
}
}
}
return TerminationReport();
}
///
/// Check without blocking the supplied processes for termination.
///
/// @param pids the process ids
/// @return a vector of termination reports for the pids that terminated.
/// @throw WaitException if the waitid call failed
///
public: static std::vector<TerminationReport> checkForTermination(const std::vector<int> & pids) {
std::vector<TerminationReport> reports;
siginfo_t infop;
int options = WEXITED | WNOHANG; // NOLINT
for (int pid : pids) {
if (pid <= 0) {
continue;
}
memset(&infop, 0, sizeof(siginfo_t));
if (waitid(P_PID, (unsigned int) pid, &infop, options) == -1) {
ThrowBalauException(Exception::WaitException, errno);
} else if (infop.si_pid) {
switch (infop.si_code) {
case CLD_EXITED:
case CLD_KILLED:
case CLD_DUMPED: {
reports.emplace_back(pid, infop.si_code, infop.si_status);
}
default: {
break;
}
}
}
}
return reports;
}
///
/// Terminate the child process if it is running.
///
/// If the process has not terminated, terminate it and return an empty termination report.
/// If the pid is invalid, an empty termination report is returned.
///
/// @param pid the process id
/// @return a termination report
/// @throw WaitException if the waitid call failed
///
public: static TerminationReport terminateProcess(int pid) {
if (pid <= 0) {
return TerminationReport();
}
siginfo_t infop;
int options = WEXITED | WNOHANG; // NOLINT
memset(&infop, 0, sizeof(siginfo_t));
if (waitid(P_PID, (unsigned int) pid, &infop, options) == -1) {
ThrowBalauException(Exception::WaitException, errno);
} else if (infop.si_pid) {
switch (infop.si_code) {
case CLD_EXITED:
case CLD_KILLED:
case CLD_DUMPED: {
return TerminationReport(pid, infop.si_code, infop.si_status);
}
default: {
kill(pid, SIGKILL);
break;
}
}
}
return TerminationReport();
}
};
} // namespace Balau::Concurrent
#endif // COM_BORA_SOFTWARE__BALAU_CONCURRENT__FORK
| 26.627451 | 117 | 0.681885 | borasoftware |
1e7d954c72bdb3633c53792b451915d4115927b6 | 1,073 | cpp | C++ | src/Passes/Decomposition/bridge_decomp.cpp | paniash/tweedledum | fe997bea3413a02033d76b20034e3a24b840bffb | [
"MIT"
] | 76 | 2018-07-21T08:12:17.000Z | 2022-01-25T06:22:25.000Z | src/Passes/Decomposition/bridge_decomp.cpp | paniash/tweedledum | fe997bea3413a02033d76b20034e3a24b840bffb | [
"MIT"
] | 44 | 2018-10-26T10:44:39.000Z | 2022-02-07T01:07:38.000Z | src/Passes/Decomposition/bridge_decomp.cpp | paniash/tweedledum | fe997bea3413a02033d76b20034e3a24b840bffb | [
"MIT"
] | 23 | 2018-09-27T15:28:48.000Z | 2022-03-07T12:21:37.000Z | /*------------------------------------------------------------------------------
| Part of Tweedledum Project. This file is distributed under the MIT License.
| See accompanying file /LICENSE for details.
*-----------------------------------------------------------------------------*/
#include "tweedledum/Passes/Decomposition/bridge_decomp.h"
#include "tweedledum/Decomposition/BridgeDecomposer.h"
#include "tweedledum/Operators/Extension/Bridge.h"
#include "tweedledum/Operators/Standard/X.h"
#include "tweedledum/Passes/Utility/shallow_duplicate.h"
namespace tweedledum {
Circuit bridge_decomp(
Device const& device, Circuit const& original, nlohmann::json const& config)
{
BridgeDecomposer decomposer(device, config);
Circuit decomposed = shallow_duplicate(original);
original.foreach_instruction([&](Instruction const& inst) {
if (inst.is_a<Op::Bridge>()) {
decomposer.decompose(decomposed, inst);
return;
}
decomposed.apply_operator(inst);
});
return decomposed;
}
} // namespace tweedledum
| 35.766667 | 80 | 0.621622 | paniash |
1e829c69509ef5b207e2b075eb86f152db5795eb | 692 | cpp | C++ | HSAHRBNUOJ/P32xx/P3244.cpp | HeRaNO/OI-ICPC-Codes | 4a4639cd3e347b472520065ca6ab8caadde6906d | [
"MIT"
] | 18 | 2019-01-01T13:16:59.000Z | 2022-02-28T04:51:50.000Z | HSAHRBNUOJ/P32xx/P3244.cpp | HeRaNO/OI-ICPC-Codes | 4a4639cd3e347b472520065ca6ab8caadde6906d | [
"MIT"
] | null | null | null | HSAHRBNUOJ/P32xx/P3244.cpp | HeRaNO/OI-ICPC-Codes | 4a4639cd3e347b472520065ca6ab8caadde6906d | [
"MIT"
] | 5 | 2019-09-13T08:48:17.000Z | 2022-02-19T06:59:03.000Z | #include <cmath>
#include <cstdio>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-20;
double l, c, n, nl;
double newl;
double left, right, middle;
int main()
{
while (~scanf("%lf %lf %lf", &l, &c, &n))
{
if (l == -1 && c == -1 && n == -1) break;
newl = (1.0 + n * c) * l;
right = PI / 2.0;
left = 0.0;
while (true)
{
middle = (left + right) / 2.0;
double ans = ((l / 2.0) / sin(middle)) * middle * 2.0;
if (fabs(ans - newl) < eps)
{
double r = (l / 2.0) / sin(middle);
double k = (l / 2.0) / tan(middle);
printf("%.3lf\n", r - k);
break;
}
if (ans < newl) left = middle;
else right = middle;
}
}
return 0;
}
| 18.702703 | 57 | 0.507225 | HeRaNO |
1e8466e16680d09d1ce501eb40fa074d6f1217cf | 28,888 | cpp | C++ | test/json/json_test.cpp | sekiguchi-nagisa/ydsh | 19b94962e076d4dffacb6b0236147d84dbe0fd53 | [
"Apache-2.0"
] | 16 | 2017-04-30T18:12:59.000Z | 2022-01-10T10:04:02.000Z | test/json/json_test.cpp | sekiguchi-nagisa/ydsh | 19b94962e076d4dffacb6b0236147d84dbe0fd53 | [
"Apache-2.0"
] | 564 | 2015-01-30T19:14:26.000Z | 2022-03-31T15:16:36.000Z | test/json/json_test.cpp | sekiguchi-nagisa/ydsh | 19b94962e076d4dffacb6b0236147d84dbe0fd53 | [
"Apache-2.0"
] | 2 | 2020-05-12T11:04:20.000Z | 2021-04-05T19:20:25.000Z | #include "gtest/gtest.h"
#include "jsonrpc.h"
using namespace ydsh;
using namespace json;
TEST(JSON, type) {
JSON json;
ASSERT_TRUE(json.isInvalid());
json = nullptr;
ASSERT_TRUE(json.isNull());
ASSERT_TRUE(ydsh::get<std::nullptr_t>(json) == nullptr);
json = true;
ASSERT_TRUE(json.isBool());
ASSERT_EQ(true, json.asBool());
json = JSON(12);
ASSERT_TRUE(json.isLong());
ASSERT_EQ(12, json.asLong());
json = JSON(3.14);
ASSERT_TRUE(json.isDouble());
ASSERT_EQ(3.14, json.asDouble());
json = "hello";
ASSERT_TRUE(json.isString());
ASSERT_EQ("hello", json.asString());
json = JSON(array());
ASSERT_TRUE(json.isArray());
json.asArray().emplace_back(23);
json.asArray().emplace_back(true);
ASSERT_EQ(2, json.size());
ASSERT_EQ(23, json[0].asLong());
ASSERT_TRUE(json[1].asBool());
json = array(23, 4.3, "hello", false, nullptr, array(34, 34), std::move(json));
ASSERT_TRUE(json.isArray());
ASSERT_EQ(7, json.size());
ASSERT_EQ(23, json[0].asLong());
ASSERT_EQ(4.3, json[1].asDouble());
ASSERT_EQ("hello", json[2].asString());
ASSERT_EQ(false, json[3].asBool());
ASSERT_TRUE(json[4].isNull());
ASSERT_EQ(34, json[5][0].asLong());
ASSERT_EQ(34, json[5][1].asLong());
ASSERT_EQ(23, json[6][0].asLong());
ASSERT_EQ(true, json[6][1].asBool());
json = JSON(object());
ASSERT_TRUE(json.isObject());
json.asObject().emplace("hey", false);
ASSERT_FALSE(json["hey"].asBool());
json = {{"hello", 45}, {"world", array("false", true)}};
ASSERT_TRUE(json.isObject());
ASSERT_EQ(2, json.size());
ASSERT_EQ(45, json["hello"].asLong());
ASSERT_EQ("false", json["world"][0].asString());
ASSERT_TRUE(json["world"][1].asBool());
// Optional<JSON>
ASSERT_EQ(sizeof(JSON), sizeof(Optional<JSON>));
Optional<JSON> opt;
ASSERT_TRUE(opt.isInvalid());
opt = JSON(23);
ASSERT_TRUE(opt.isLong());
}
TEST(JSON, serialize) {
JSON json = {{"hello", false}, {"hoge", array(2, nullptr, true)}};
auto actual = json.serialize();
const char *expect = R"({"hello":false,"hoge":[2,null,true]})";
ASSERT_EQ(expect, actual);
json = 34;
actual = json.serialize(1);
ASSERT_EQ("34\n", actual);
json = {{"23", array(JSON())}, {"hey", array(3, -123, nullptr, object({"3", ""}))}};
actual = json.serialize(4);
expect = R"({
"23": [],
"hey": [
3,
-123,
null,
{
"3": ""
}
]
}
)";
ASSERT_EQ(expect, actual);
}
class ParserTest : public ::testing::Test {
protected:
JSON ret;
void parse(const char *src) {
JSONParser parser(src);
this->ret = parser();
if (parser.hasError()) {
parser.showError();
}
ASSERT_FALSE(parser.hasError());
}
public:
ParserTest() = default;
};
TEST(InvalidTest, base) {
JSONParser parser("hoge");
auto ret = parser();
ASSERT_TRUE(parser.hasError());
ASSERT_TRUE(ret.isInvalid());
}
TEST_F(ParserTest, null1) {
ASSERT_NO_FATAL_FAILURE(this->parse("null"));
ASSERT_TRUE(this->ret.isNull());
}
TEST_F(ParserTest, null2) {
ASSERT_NO_FATAL_FAILURE(this->parse("\t\n\tnull \t \n\n \n"));
ASSERT_TRUE(this->ret.isNull());
}
TEST_F(ParserTest, bool1) {
ASSERT_NO_FATAL_FAILURE(this->parse("\t\n\t false \t \n\n \n"));
ASSERT_TRUE(this->ret.isBool());
ASSERT_FALSE(this->ret.asBool());
}
TEST_F(ParserTest, bool2) {
ASSERT_NO_FATAL_FAILURE(this->parse("true"));
ASSERT_TRUE(this->ret.isBool());
ASSERT_TRUE(this->ret.asBool());
}
TEST_F(ParserTest, num1) {
ASSERT_NO_FATAL_FAILURE(this->parse("\t\n\t9876 \t \n\n \n"));
ASSERT_TRUE(this->ret.isLong());
ASSERT_EQ(9876, this->ret.asLong());
}
TEST_F(ParserTest, num2) {
ASSERT_NO_FATAL_FAILURE(this->parse("\t\n\t-1203 \t \n\n \n"));
ASSERT_TRUE(this->ret.isLong());
ASSERT_EQ(-1203, this->ret.asLong());
}
TEST_F(ParserTest, num3) {
ASSERT_NO_FATAL_FAILURE(this->parse("\t\n\t-1203e+2 \t \n\n \n"));
ASSERT_TRUE(this->ret.isDouble());
ASSERT_EQ(-120300, this->ret.asDouble());
}
TEST_F(ParserTest, num4) {
ASSERT_NO_FATAL_FAILURE(this->parse("\t\n\t12.03E-2 \t \n\n \n"));
ASSERT_TRUE(this->ret.isDouble());
ASSERT_EQ(0.1203, this->ret.asDouble());
}
TEST_F(ParserTest, num5) {
ASSERT_NO_FATAL_FAILURE(this->parse("\t 0 \n"));
ASSERT_TRUE(this->ret.isLong());
ASSERT_EQ(0, this->ret.asLong());
}
TEST_F(ParserTest, string1) {
const char *text = R"("hello")";
ASSERT_NO_FATAL_FAILURE(this->parse(text));
ASSERT_TRUE(this->ret.isString());
ASSERT_EQ("hello", this->ret.asString());
}
template <unsigned int N>
static std::string str(const char (&v)[N]) {
return std::string(v, N - 1);
}
TEST_F(ParserTest, string2) {
const char *text = R"("hello\n\t\b\f\r \u0023\u0000\ud867\uDE3d\u0026")";
ASSERT_NO_FATAL_FAILURE(this->parse(text));
ASSERT_TRUE(this->ret.isString());
ASSERT_NO_FATAL_FAILURE(
ASSERT_EQ(str("hello\n\t\b\f\r #\0\xf0\xa9\xb8\xbd&"), this->ret.asString()));
}
TEST_F(ParserTest, string3) {
const char *text = R"("\"\\\/")";
ASSERT_NO_FATAL_FAILURE(this->parse(text));
const char *expect = R"("\/)";
ASSERT_EQ(expect, this->ret.asString());
}
TEST_F(ParserTest, string4) {
const char *text = R"("あいうえお\u3042")";
ASSERT_NO_FATAL_FAILURE(this->parse(text));
const char *expect = R"(あいうえおあ)";
ASSERT_EQ(expect, this->ret.asString());
}
TEST_F(ParserTest, array) {
const char *text = R"(
[
"a" , "b", true
, null,
[45
,
54
], 3.14
])";
ASSERT_NO_FATAL_FAILURE(this->parse(text));
ASSERT_TRUE(this->ret.isArray());
ASSERT_EQ(6, this->ret.size());
ASSERT_EQ("a", this->ret[0].asString());
ASSERT_EQ("b", this->ret[1].asString());
ASSERT_EQ(true, this->ret[2].asBool());
ASSERT_EQ(true, this->ret[3].isNull());
ASSERT_EQ(45, this->ret[4][0].asLong());
ASSERT_EQ(54, this->ret[4][1].asLong());
ASSERT_EQ(3.14, this->ret[5].asDouble());
}
TEST_F(ParserTest, object) {
const char *text = R"(
{ "23" :
[true, false, null], "aaa"
: null
,
"bbb" : {
}
,
"ccc" :[]
}
)";
ASSERT_NO_FATAL_FAILURE(this->parse(text));
ASSERT_TRUE(this->ret.isObject());
ASSERT_EQ(4, this->ret.size());
ASSERT_EQ(true, this->ret["23"][0].asBool());
ASSERT_EQ(false, this->ret["23"][1].asBool());
ASSERT_EQ(true, this->ret["23"][2].isNull());
ASSERT_EQ(true, this->ret["aaa"].isNull());
ASSERT_EQ(true, this->ret["bbb"].asObject().empty());
ASSERT_EQ(true, this->ret["ccc"].asArray().empty());
ASSERT_TRUE(this->ret["hohgeo"].isInvalid());
}
TEST_F(ParserTest, serialize1) {
auto expect = JSON{{"hiofr", JSON()},
{"34", object()},
{"aa", false},
{"bb", array(nullptr, 3, 3.4, "hey", object({"huga", array()}), JSON())},
{"ZZ", {{";;;", 234}, {"", object()}}}}
.serialize(3);
auto actual = JSONParser(expect.c_str())().serialize(3);
ASSERT_EQ(expect, actual);
expect = JSON(34).serialize(3);
actual = JSONParser(expect.c_str())().serialize(3);
ASSERT_EQ(expect, actual);
}
TEST_F(ParserTest, serialize2) {
// error
auto actual = rpc::Error(-1, "hello").toJSON().serialize(3);
const char *text = R"( { "code" : -1, "message": "hello" })";
auto expect = JSONParser(text)().serialize(3);
ASSERT_EQ(expect, actual);
actual = rpc::Error(-100, "world", array(1, 3, 5)).toJSON().serialize(3);
text = R"( { "code" : -100, "message": "world", "data": [1,3,5] })";
expect = JSONParser(text)().serialize(3);
ASSERT_EQ(expect, actual);
// response
actual = rpc::Response(34, nullptr).toJSON().serialize(2);
text = R"( { "jsonrpc" : "2.0", "id" : 34, "result" : null } )";
expect = JSONParser(text)().serialize(2);
ASSERT_EQ(expect, actual);
actual = rpc::Response(-0.4, 34).toJSON().serialize(2);
text = R"( { "jsonrpc" : "2.0", "id" : -0.4, "result" : 34 } )";
expect = JSONParser(text)().serialize(2);
ASSERT_EQ(expect, actual);
actual = rpc::Response(nullptr, rpc::Error(-100, "world", array(1, 3, 5))).toJSON().serialize(2);
text = R"( { "jsonrpc" : "2.0", "id" : null,
"error" : { "code": -100, "message" : "world", "data" : [1,3,5]}})";
expect = JSONParser(text)().serialize(2);
ASSERT_EQ(expect, actual);
}
template <typename T>
static JSON serialize(T &&v) {
JSONSerializer serializer;
serializer(std::forward<T>(v));
return std::move(serializer).take();
}
TEST(SerializeTest, base) {
auto ret = serialize(true);
ASSERT_TRUE(ret.isBool());
ASSERT_TRUE(ret.asBool());
ret = serialize(3.14);
ASSERT_TRUE(ret.isDouble());
ASSERT_EQ(3.14, ret.asDouble());
ret = serialize("hello");
ASSERT_TRUE(ret.isString());
ASSERT_EQ("hello", ret.asString());
std::vector<int> v = {1, 2, 3};
ret = serialize(v);
ASSERT_TRUE(ret.isArray());
ASSERT_EQ(3, ret.asArray().size());
ASSERT_EQ(1, ret.asArray()[0].asLong());
ret = serialize(nullptr);
ASSERT_TRUE(ret.isNull());
}
struct BBB {
int b1;
std::string b2;
template <typename T>
void jsonify(T &t) {
t("b1", b1);
t("b2", b2);
}
};
struct AAA {
int a1;
BBB a2;
};
namespace ydsh::json {
template <typename T>
void jsonify(T &t, AAA &v) {
t("a1", v.a1);
t("a2", v.a2);
}
} // namespace ydsh::json
TEST(SerializeTest, object) {
AAA v = {.a1 = 190,
.a2 = BBB{
.b1 = -234,
.b2 = "world!!",
}};
auto ret = serialize(v);
ASSERT_TRUE(ret.isObject());
ASSERT_EQ(2, ret.asObject().size());
ASSERT_EQ(190, ret["a1"].asLong());
ASSERT_EQ(-234, ret["a2"]["b1"].asLong());
ASSERT_EQ("world!!", ret["a2"]["b2"].asString());
}
TEST(SerializeTest, variant) {
Union<bool, BBB, int> v;
auto ret = serialize(v);
ASSERT_TRUE(ret.isInvalid());
v = 234;
ret = serialize(v);
ASSERT_TRUE(ret.isLong());
ASSERT_EQ(234, ret.asLong());
v = false;
ret = serialize(v);
ASSERT_TRUE(ret.isBool());
ASSERT_FALSE(ret.asBool());
v = BBB{
.b1 = 999,
.b2 = "@@@@",
};
ret = serialize(v);
ASSERT_TRUE(ret.isObject());
ASSERT_EQ(2, ret.asObject().size());
ASSERT_EQ(999, ret["b1"].asLong());
ASSERT_EQ("@@@@", ret["b2"].asString());
}
TEST(DeserializeTest, base) {
JSONDeserializer deserializer(false);
bool b = true;
deserializer(b);
ASSERT_FALSE(deserializer.hasError());
ASSERT_FALSE(b);
deserializer = JSONDeserializer(true);
deserializer(b);
ASSERT_FALSE(deserializer.hasError());
ASSERT_TRUE(b);
deserializer = JSONDeserializer(34);
deserializer(b);
ASSERT_TRUE(deserializer.hasError());
int64_t i = 0;
deserializer = JSONDeserializer(12);
deserializer(i);
ASSERT_FALSE(deserializer.hasError());
ASSERT_EQ(12, i);
deserializer = JSONDeserializer(3.14);
deserializer(i);
ASSERT_TRUE(deserializer.hasError());
double d = 0;
deserializer = JSONDeserializer(34.5);
deserializer(d);
ASSERT_FALSE(deserializer.hasError());
ASSERT_EQ(34.5, d);
deserializer = JSONDeserializer("12345");
deserializer(d);
ASSERT_TRUE(deserializer.hasError());
std::string s;
deserializer = JSONDeserializer("9999");
deserializer(s);
ASSERT_FALSE(deserializer.hasError());
ASSERT_EQ("9999", s);
}
TEST(DeserializeTest, array) {
std::vector<std::vector<std::string>> v1 = {{"helllo", "1"}, {"world", "2"}};
auto j = serialize(v1);
std::vector<std::vector<std::string>> v2;
JSONDeserializer deserializer(std::move(j));
deserializer(v2);
ASSERT_FALSE(deserializer.hasError());
ASSERT_EQ(2, v2.size());
ASSERT_EQ(2, v2[0].size());
ASSERT_EQ("helllo", v2[0][0]);
ASSERT_EQ("1", v2[0][1]);
ASSERT_EQ(2, v2[1].size());
ASSERT_EQ("world", v2[1][0]);
ASSERT_EQ("2", v2[1][1]);
}
TEST(DeserializeTest, object) {
AAA v1 = {.a1 = 190,
.a2 = BBB{
.b1 = -234,
.b2 = "world!!",
}};
auto ret = serialize(v1);
JSONDeserializer deserializer(std::move(ret));
AAA v2;
deserializer(v2);
ASSERT_FALSE(deserializer.hasError());
ASSERT_EQ(190, v2.a1);
ASSERT_EQ(-234, v2.a2.b1);
ASSERT_EQ("world!!", v2.a2.b2);
}
static JSONDeserializer operator""_deserialize(const char *text, size_t) {
return JSONDeserializer(JSON::fromString(text));
}
TEST(DeserializeTest, variant1) {
Union<int, std::string, std::vector<BBB>> v;
JSONDeserializer deserializer(456);
deserializer(v);
ASSERT_FALSE(deserializer.hasError());
ASSERT_TRUE(is<int>(v));
ASSERT_EQ(456, get<int>(v));
v = decltype(v)();
deserializer = JSONDeserializer("abcd");
deserializer(v);
ASSERT_FALSE(deserializer.hasError());
ASSERT_TRUE(is<std::string>(v));
ASSERT_EQ("abcd", get<std::string>(v));
v = decltype(v)();
deserializer = R"(
[
{ "b1": -999, "b2": "@@@" },
{ "b1": 56, "b2": "error"}
]
)"_deserialize;
deserializer(v);
ASSERT_FALSE(deserializer.hasError());
ASSERT_TRUE(is<std::vector<BBB>>(v));
ASSERT_EQ(2, get<std::vector<BBB>>(v).size());
ASSERT_EQ(-999, get<std::vector<BBB>>(v)[0].b1);
ASSERT_EQ("@@@", get<std::vector<BBB>>(v)[0].b2);
ASSERT_EQ(56, get<std::vector<BBB>>(v)[1].b1);
ASSERT_EQ("error", get<std::vector<BBB>>(v)[1].b2);
v = decltype(v)();
deserializer = JSONDeserializer(34.2);
deserializer(v);
ASSERT_TRUE(deserializer.hasError());
ASSERT_FALSE(v.hasValue());
ASSERT_EQ("require `array', but is `double'", deserializer.getValidationError().formatError());
}
TEST(DeserializeTest, variant2) {
Union<int, std::nullptr_t> v1{nullptr};
auto json = serialize(v1);
ASSERT_TRUE(json.isNull());
JSONDeserializer deserializer(std::move(json));
Union<int, std::nullptr_t> v2;
ASSERT_FALSE(v2.hasValue());
deserializer(v2);
ASSERT_FALSE(deserializer.hasError());
ASSERT_TRUE(v2.hasValue());
ASSERT_TRUE(is<std::nullptr_t>(v2));
}
struct CCC {
int id{1};
Optional<BBB> value;
template <typename T>
void jsonify(T &t) {
t("id", id);
t("value", value);
}
};
TEST(DeserializeTest, option1) {
Optional<CCC> v1;
JSON json = serialize(v1);
ASSERT_TRUE(json.isInvalid());
v1 = CCC();
json = serialize(v1);
ASSERT_TRUE(json.isObject());
ASSERT_EQ(1, json.asObject().size());
ASSERT_EQ(1, json["id"].asLong());
Optional<CCC> v2;
JSONDeserializer deserializer(std::move(json));
deserializer(v2);
ASSERT_FALSE(deserializer.hasError());
ASSERT_TRUE(v2.hasValue());
ASSERT_EQ(1, v2.unwrap().id);
ASSERT_FALSE(v2.unwrap().value.hasValue());
v2.unwrap().id = 999;
v2.unwrap().value = BBB{
.b1 = -100,
.b2 = "hoge",
};
json = serialize(v2);
ASSERT_TRUE(json.isObject());
v2 = Optional<CCC>();
deserializer = JSONDeserializer(std::move(json));
deserializer(v2);
ASSERT_FALSE(deserializer.hasError());
ASSERT_TRUE(v2.hasValue());
ASSERT_EQ(999, v2.unwrap().id);
ASSERT_TRUE(v2.unwrap().value.hasValue());
ASSERT_EQ(-100, v2.unwrap().value.unwrap().b1);
ASSERT_EQ("hoge", v2.unwrap().value.unwrap().b2);
}
struct DDD {
Optional<JSON> json;
template <typename T>
void jsonify(T &t) {
t("json", json);
}
};
TEST(DeserializeTest, option2) {
DDD v1 = {
.json = JSON(100),
};
auto json = serialize(v1);
ASSERT_TRUE(json.isObject());
ASSERT_EQ(1, json.asObject().size());
JSONDeserializer deserializer(std::move(json));
DDD v2;
deserializer(v2);
std::cerr << deserializer.getValidationError().formatError() << std::endl;
ASSERT_FALSE(deserializer.hasError());
ASSERT_TRUE(v2.json.hasValue());
ASSERT_EQ(100, v2.json.unwrap().asLong());
v2.json = Optional<JSON>();
v1 = decltype(v1)();
deserializer = JSONDeserializer(serialize(v2));
deserializer(v1);
ASSERT_FALSE(deserializer.hasError());
ASSERT_FALSE(v1.json.hasValue());
}
enum class Flag1 {
BLUE = 34,
RED = 35,
BLACK = 40,
};
TEST(DeserializeTest, enum1) {
Flag1 f1 = Flag1::BLUE;
auto json = serialize(f1);
Flag1 f2 = Flag1::BLACK;
JSONDeserializer deserializer(std::move(json));
deserializer(f2);
ASSERT_FALSE(deserializer.hasError());
ASSERT_EQ(Flag1::BLUE, f2);
}
TEST(DeserializeTest, error) {
auto des = "23"_deserialize;
bool b;
des(b);
ASSERT_TRUE(des.hasError());
ASSERT_EQ("require `bool', but is `long'", des.getValidationError().formatError());
des = "[12,34,56]"_deserialize;
des(b);
ASSERT_TRUE(des.hasError());
ASSERT_EQ("require `bool', but is `array'", des.getValidationError().formatError());
des = R"E(
{
"a1" : 100,
"a2" : {
"b1" : -12,
"b2": "hello"
}
}
)E"_deserialize;
BBB bbb;
des(bbb);
ASSERT_TRUE(des.hasError());
ASSERT_EQ("undefined field `b1'", des.getValidationError().formatError());
}
struct SingleNullLogger : ydsh::SingletonLogger<SingleNullLogger> {
SingleNullLogger() : ydsh::SingletonLogger<SingleNullLogger>("") {}
};
TEST(ReqTest, parse) {
using namespace rpc;
// syntax error
ByteBuffer buf;
std::string text = "}{";
buf.append(text.c_str(), text.size());
auto msg = MessageParser(SingleNullLogger::instance(), std::move(buf))();
ASSERT_TRUE(is<Error>(msg));
ASSERT_EQ(rpc::ParseError, get<Error>(msg).code);
// semantic error
text = R"({ "hoge" : "de" })";
buf = ByteBuffer();
buf.append(text.c_str(), text.size());
msg = MessageParser(SingleNullLogger::instance(), std::move(buf))();
ASSERT_TRUE(is<Error>(msg));
ASSERT_EQ(rpc::InvalidRequest, get<Error>(msg).code);
// request
text = rpc::Request("AAA", "hey", array(false, true)).toJSON().serialize(0);
buf = ByteBuffer();
buf.append(text.c_str(), text.size());
msg = MessageParser(SingleNullLogger::instance(), std::move(buf))();
ASSERT_TRUE(is<Request>(msg));
ASSERT_TRUE(get<Request>(msg).isCall());
auto json = get<Request>(msg).toJSON();
ASSERT_EQ("AAA", json["id"].asString());
ASSERT_EQ("hey", json["method"].asString());
ASSERT_EQ(2, json["params"].size());
ASSERT_EQ(false, json["params"][0].asBool());
ASSERT_EQ(true, json["params"][1].asBool());
text = rpc::Request(1234, "hoge", JSON()).toJSON().serialize(0);
buf = ByteBuffer();
buf.append(text.c_str(), text.size());
msg = MessageParser(SingleNullLogger::instance(), std::move(buf))();
ASSERT_TRUE(is<Request>(msg));
ASSERT_TRUE(get<Request>(msg).isCall());
json = get<Request>(msg).toJSON();
ASSERT_EQ(1234, json["id"].asLong());
ASSERT_EQ("hoge", json["method"].asString());
ASSERT_TRUE(json["params"].isInvalid());
// notification
text = rpc::Request(JSON(), "world", {{"AAA", 0.23}}).toJSON().serialize(0);
buf = ByteBuffer();
buf.append(text.c_str(), text.size());
msg = MessageParser(SingleNullLogger::instance(), std::move(buf))();
ASSERT_TRUE(is<Request>(msg));
ASSERT_TRUE(get<Request>(msg).isNotification());
json = get<Request>(msg).toJSON();
ASSERT_TRUE(json["id"].isInvalid());
ASSERT_EQ("world", json["method"].asString());
ASSERT_EQ(1, json["params"].size());
ASSERT_EQ(0.23, json["params"]["AAA"].asDouble());
// invalid request
text = rpc::Request(true, "world", {{"AAA", 0.23}}).toJSON().serialize(0);
buf = ByteBuffer();
buf.append(text.c_str(), text.size());
msg = MessageParser(SingleNullLogger::instance(), std::move(buf))();
ASSERT_TRUE(is<Error>(msg));
}
struct StringTransport : public rpc::Transport {
std::string inStr;
unsigned int cursor{0};
std::string outStr;
StringTransport() : rpc::Transport(SingleNullLogger::instance()) {}
explicit StringTransport(std::string &&text)
: rpc::Transport(SingleNullLogger::instance()), inStr(std::move(text)) {}
int send(unsigned int size, const char *data) override {
this->outStr.append(data, size);
return size;
}
int recv(unsigned int size, char *data) override {
unsigned int count = 0;
for (; this->cursor < this->inStr.size() && count < size; this->cursor++) {
data[count] = this->inStr[this->cursor];
count++;
}
return count;
}
int recvSize() override { return this->inStr.size(); }
};
class RPCTest : public ::testing::Test {
protected:
StringTransport transport;
rpc::Handler handler;
RPCTest() : handler(SingleNullLogger::instance()) {}
void init(rpc::Request &&req) { this->init(req.toJSON().serialize()); }
void init(std::string &&text) {
this->transport = StringTransport(std::move(text));
ASSERT_EQ(0, this->transport.cursor);
}
void dispatch() { this->transport.dispatch(this->handler); }
const std::string &response() const { return this->transport.outStr; }
void assertResponse(rpc::Response &&res) {
ASSERT_EQ(res.toJSON().serialize(), this->response());
}
void parseResponse(JSON &value) {
JSONParser parser(this->response().c_str());
auto ret = parser();
ASSERT_FALSE(parser.hasError());
ASSERT_FALSE(ret.isInvalid());
ASSERT_TRUE(ret.isObject());
value = std::move(ret);
}
};
TEST_F(RPCTest, api1) {
this->transport.call(34, "hoge", {{"value", false}});
JSON json;
ASSERT_NO_FATAL_FAILURE(this->parseResponse(json));
ASSERT_EQ("2.0", json["jsonrpc"].asString());
ASSERT_EQ("hoge", json["method"].asString());
ASSERT_EQ(34, json["id"].asLong());
ASSERT_EQ(1, json["params"].size());
ASSERT_EQ(false, json["params"]["value"].asBool());
}
TEST_F(RPCTest, api2) {
this->transport.notify("hoge", {{"value", "hey"}});
JSON json;
ASSERT_NO_FATAL_FAILURE(this->parseResponse(json));
ASSERT_EQ("2.0", json["jsonrpc"].asString());
ASSERT_EQ("hoge", json["method"].asString());
ASSERT_TRUE(json["id"].isInvalid());
ASSERT_EQ(1, json["params"].size());
ASSERT_EQ("hey", json["params"]["value"].asString());
}
struct Param1 {
unsigned int value;
template <typename T>
void jsonify(T &t) {
t("value", value);
}
};
struct Param2 {
std::string value;
template <typename T>
void jsonify(T &t) {
t("value", value);
}
};
struct Context {
unsigned int nRet{0};
std::string cRet;
bool exited{false};
std::string calledName;
void init(const Param1 &p) {
this->calledName = "init";
this->nRet = p.value;
}
rpc::Reply<std::string> put(const Param2 &p) {
this->calledName = "put";
this->cRet = p.value;
if (this->cRet.size() > 5) {
return rpc::newError(rpc::InternalError, "too long");
}
return std::string("hello");
}
void exit() {
this->calledName = "exit";
this->exited = true;
}
rpc::Reply<void> tryExit() {
this->calledName = "tryExit";
this->exited = false;
return rpc::newError(rpc::InternalError, "busy");
}
};
TEST_F(RPCTest, parse1) {
this->init("hoger hiur!!");
this->dispatch();
JSON json;
ASSERT_NO_FATAL_FAILURE(this->parseResponse(json));
ASSERT_TRUE(json.asObject().find("id") != json.asObject().end());
ASSERT_TRUE(json["id"].isNull());
ASSERT_TRUE(json.asObject().find("error") != json.asObject().end());
ASSERT_EQ(rpc::ParseError, json["error"]["code"].asLong());
ASSERT_EQ("Parse error", json["error"]["message"].asString());
ASSERT_TRUE(json["error"]["data"].isString());
}
TEST_F(RPCTest, parse2) {
this->init("false");
this->dispatch();
JSON json;
ASSERT_NO_FATAL_FAILURE(this->parseResponse(json));
ASSERT_TRUE(json.asObject().find("id") != json.asObject().end());
ASSERT_TRUE(json["id"].isNull());
ASSERT_TRUE(json.asObject().find("error") != json.asObject().end());
ASSERT_EQ(rpc::InvalidRequest, json["error"]["code"].asLong());
ASSERT_EQ("Invalid Request", json["error"]["message"].asString());
ASSERT_TRUE(json["error"]["data"].isString());
}
TEST_F(RPCTest, call1) {
Context ctx;
this->init(rpc::Request(1, "/put", {{"value", "hello"}}));
this->handler.bind("/init", &ctx, &Context::init);
this->handler.bind("/put", &ctx, &Context::put);
this->handler.bind("/exit", &ctx, &Context::exit);
this->dispatch();
ASSERT_EQ("put", ctx.calledName);
ASSERT_EQ("hello", ctx.cRet);
ASSERT_EQ(0, ctx.nRet);
ASSERT_FALSE(ctx.exited);
ASSERT_NO_FATAL_FAILURE(this->assertResponse(rpc::Response(1, "hello")));
}
TEST_F(RPCTest, call2) {
Context ctx;
this->init(rpc::Request(1, "/putdd", {{"value", "hello"}}));
this->handler.bind("/init", &ctx, &Context::init);
this->handler.bind("/put", &ctx, &Context::put);
this->handler.bind("/exit", &ctx, &Context::exit);
this->dispatch();
ASSERT_EQ("", ctx.calledName);
ASSERT_EQ("", ctx.cRet);
ASSERT_EQ(0, ctx.nRet);
ASSERT_FALSE(ctx.exited);
JSON json;
ASSERT_NO_FATAL_FAILURE(this->parseResponse(json));
ASSERT_EQ(1, json["id"].asLong());
ASSERT_TRUE(json.asObject().find("error") != json.asObject().end());
ASSERT_EQ(rpc::MethodNotFound, json["error"]["code"].asLong());
ASSERT_EQ("undefined method: /putdd", json["error"]["message"].asString());
ASSERT_TRUE(json["error"]["data"].isInvalid());
}
TEST_F(RPCTest, call3) {
Context ctx;
this->init(rpc::Request(1, "/put", {{"value", array(34, 43)}}));
this->handler.bind("/init", &ctx, &Context::init);
this->handler.bind("/put", &ctx, &Context::put);
this->handler.bind("/exit", &ctx, &Context::exit);
this->dispatch();
ASSERT_EQ("", ctx.calledName);
ASSERT_EQ("", ctx.cRet);
ASSERT_EQ(0, ctx.nRet);
ASSERT_FALSE(ctx.exited);
JSON json;
ASSERT_NO_FATAL_FAILURE(this->parseResponse(json));
ASSERT_EQ(1, json["id"].asLong());
ASSERT_TRUE(json.asObject().find("error") != json.asObject().end());
ASSERT_EQ(rpc::InvalidParams, json["error"]["code"].asLong());
ASSERT_TRUE(json["error"]["message"].isString());
ASSERT_TRUE(json["error"]["data"].isInvalid());
}
TEST_F(RPCTest, call4) {
Context ctx;
this->init(rpc::Request(1, "/tryExit", nullptr));
this->handler.bind("/init", &ctx, &Context::init);
this->handler.bind("/put", &ctx, &Context::put);
this->handler.bind("/exit", &ctx, &Context::exit);
this->handler.bind("/tryExit", &ctx, &Context::tryExit);
this->dispatch();
ASSERT_EQ("tryExit", ctx.calledName);
ASSERT_EQ("", ctx.cRet);
ASSERT_EQ(0, ctx.nRet);
ASSERT_FALSE(ctx.exited);
JSON json;
ASSERT_NO_FATAL_FAILURE(this->parseResponse(json));
ASSERT_EQ(1, json["id"].asLong());
ASSERT_TRUE(json.asObject().find("error") != json.asObject().end());
ASSERT_EQ(rpc::InternalError, json["error"]["code"].asLong());
ASSERT_EQ("busy", json["error"]["message"].asString());
ASSERT_TRUE(json["error"]["data"].isInvalid());
}
TEST_F(RPCTest, call5) {
Context ctx;
this->init(rpc::Request(1, "/tryExit", {{"de", 45}}));
this->handler.bind("/init", &ctx, &Context::init);
this->handler.bind("/put", &ctx, &Context::put);
this->handler.bind("/exit", &ctx, &Context::exit);
this->handler.bind("/tryExit", &ctx, &Context::tryExit);
this->dispatch();
ASSERT_EQ("", ctx.calledName);
ASSERT_EQ("", ctx.cRet);
ASSERT_EQ(0, ctx.nRet);
ASSERT_FALSE(ctx.exited);
JSON json;
ASSERT_NO_FATAL_FAILURE(this->parseResponse(json));
ASSERT_EQ(1, json["id"].asLong());
ASSERT_TRUE(json.asObject().find("error") != json.asObject().end());
ASSERT_EQ(rpc::InvalidParams, json["error"]["code"].asLong());
ASSERT_EQ("require `null', but is `object'", json["error"]["message"].asString());
ASSERT_TRUE(json["error"]["data"].isInvalid());
}
TEST_F(RPCTest, notify1) {
Context ctx;
this->init(rpc::Request("/init", {{"value", 1234}}));
this->handler.bind("/init", &ctx, &Context::init);
this->handler.bind("/put", &ctx, &Context::put);
this->handler.bind("/exit", &ctx, &Context::exit);
this->handler.bind("/tryExit", &ctx, &Context::tryExit);
this->dispatch();
ASSERT_EQ("init", ctx.calledName);
ASSERT_EQ("", ctx.cRet);
ASSERT_EQ(1234, ctx.nRet);
ASSERT_FALSE(ctx.exited);
ASSERT_EQ("", this->response());
}
TEST_F(RPCTest, notify2) {
Context ctx;
this->init(rpc::Request("/inited", {{"value", 1234}}));
this->handler.bind("/init", &ctx, &Context::init);
this->handler.bind("/put", &ctx, &Context::put);
this->handler.bind("/exit", &ctx, &Context::exit);
this->handler.bind("/tryExit", &ctx, &Context::tryExit);
this->dispatch();
ASSERT_EQ("", ctx.calledName);
ASSERT_EQ("", ctx.cRet);
ASSERT_EQ(0, ctx.nRet);
ASSERT_FALSE(ctx.exited);
ASSERT_EQ("", this->response());
}
TEST_F(RPCTest, notify3) {
Context ctx;
this->init(rpc::Request("/exit", nullptr));
this->handler.bind("/init", &ctx, &Context::init);
this->handler.bind("/put", &ctx, &Context::put);
this->handler.bind("/exit", &ctx, &Context::exit);
this->handler.bind("/tryExit", &ctx, &Context::tryExit);
this->dispatch();
ASSERT_EQ("exit", ctx.calledName);
ASSERT_EQ("", ctx.cRet);
ASSERT_EQ(0, ctx.nRet);
ASSERT_TRUE(ctx.exited);
ASSERT_EQ("", this->response());
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
} | 27.356061 | 99 | 0.629119 | sekiguchi-nagisa |
1e84a9fb8a076b8210e8cb9a5712d21d6f77b173 | 1,198 | cpp | C++ | example/concepts.cpp | boost-ext/te | f18e0a3462575b5159c43d5a54023ea72461f4bc | [
"BSL-1.0"
] | 72 | 2020-07-01T17:01:35.000Z | 2022-03-22T10:37:18.000Z | example/concepts.cpp | boost-ext/te | f18e0a3462575b5159c43d5a54023ea72461f4bc | [
"BSL-1.0"
] | 4 | 2021-05-08T13:36:27.000Z | 2022-02-07T18:46:57.000Z | example/concepts.cpp | boost-ext/te | f18e0a3462575b5159c43d5a54023ea72461f4bc | [
"BSL-1.0"
] | 8 | 2020-07-10T08:04:38.000Z | 2022-03-22T11:40:01.000Z | //
// Copyright (c) 2018-2019 Kris Jusiak (kris at jusiak dot net)
//
// 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)
//
#if defined(__cpp_concepts)
#include <iostream>
#include "boost/te.hpp"
namespace te = boost::te;
struct Drawable {
void draw(std::ostream &out) const {
te::call([](auto const &self,
auto &out) -> decltype(self.draw(out)) { self.draw(out); },
*this, out);
}
};
struct Square {
void draw(std::ostream &out) const { out << "Square"; }
};
struct Circle {
void draw(std::ostream &out) const { out << "Circle"; }
};
template <te::conceptify<Drawable> TDrawable>
void draw(TDrawable const &drawable) {
drawable.draw(std::cout);
}
int main() {
{
te::var<Drawable> drawable = Square{};
drawable.draw(std::cout); // prints Square
}
{
te::var<Drawable> drawable = Circle{};
drawable.draw(std::cout); // prints Circle
}
{
auto drawable = Square{};
draw(drawable); // prints Square
}
{
auto drawable = Circle{};
draw(drawable); // prints Circle
}
}
#else
int main() {}
#endif
| 19.966667 | 75 | 0.6202 | boost-ext |
1e8537ac60c9fa2ce327a86213842d3101e3c95c | 8,241 | cpp | C++ | Ray.cpp | selinnilesy/Ray-Tracing | 4b1ac770902ed35560f0bc774ac42cb118f3789a | [
"MIT"
] | null | null | null | Ray.cpp | selinnilesy/Ray-Tracing | 4b1ac770902ed35560f0bc774ac42cb118f3789a | [
"MIT"
] | null | null | null | Ray.cpp | selinnilesy/Ray-Tracing | 4b1ac770902ed35560f0bc774ac42cb118f3789a | [
"MIT"
] | null | null | null | #include "Ray.h"
#include "Algebra.h"
#include "math.h"
#include <limits>
using namespace std;
using namespace parser;
Ray::Ray()
{
}
Ray::Ray(const Vec3f& e_, const Vec3f& d_):e(e_),d(d_),recursion(parser::scene.max_recursion_depth)
{
//selincikkk:D
normalize(d);
}
inline Vec3f Ray::positionT(float t)
{
return e+d*t;
}
/* return -1 if does not intersect.
*
*/
float Ray::intersect(const Sphere& s)
{
Vec3f diff = this->e - s.center_vertex; // o - c
float B = dotProduct(this->d, diff ); // d.(o-c)
float A = dotProduct(this->d , this->d ); // d.d
float C = dotProduct(diff, diff ) - s.radius*s.radius; // (o-c).(o-c) - R^2
float discriminant = B*B - A*C;
if(discriminant < -1 * epsilon ) return -1;
float t1 = (-B + sqrt(discriminant) ) / (A) ;
float t2 = (-B - sqrt(discriminant) ) / (A) ;
return t1<t2 ? t1 : t2;
}
/* returns -1 if the plane and the ray are perpendicular.
* to eachother.
*/
float Ray::intersect(const Face& f)
{
//Vec3f normd(d);
//normalize(normd);
float product = dotProduct( f.normal, this->d);
if( product < epsilon && product > -1*epsilon ) {
//LOG_ERR("perpendicular face and normal") ;
return -1;
}
Vec3f a = scene.vertex_data[f.v0_id - 1 ];
Vec3f b = scene.vertex_data[f.v1_id - 1 ];
Vec3f c = scene.vertex_data[f.v2_id - 1 ];
float t = (dotProduct((a - this->e),f.normal)) / product;
// TO DO: check if the intersection is inside triangle.
Vec3f point = e+d*t;
// check vertex c and point on the same direction of ab
Vec3f vp = crossProduct(point-b , a-b);
Vec3f vc = crossProduct(c-b, a-b);
if(dotProduct(vp, vc) + epsilon> 0){
// check vertex a and point on the same direction of bc
Vec3f vp_2 = crossProduct(point-c , b-c);
Vec3f va_2 = crossProduct(a-c, b-c);
if(dotProduct(vp_2, va_2) +epsilon > 0){
// check vertex b and point on the same direction of ca
Vec3f vp_3 = crossProduct(point-a , c-a);
Vec3f vb_3 = crossProduct(b-a, c-a);
if(dotProduct(vp_3, vb_3) +epsilon > 0){
return t;
}
}
}
return -1;
}
float Ray::intersect(const Vec3f& position)
{
return (e.x - position.x)/d.x;
}
/*
* verify intersection of the ray in the proper range.
*/
bool Ray::checkObstacle(float minDistance, float maxDistance)
{
float t ; //= std::numeric_limits<float>::max();
for (Sphere& s : parser::scene.spheres) {
t = intersect(s);
if (t > minDistance && t < maxDistance) {
return true;
}
}
for (Triangle& tr : parser::scene.triangles) {
Face& f = tr.indices;
t = intersect(f);
if (t > minDistance && t < maxDistance) {
return true;
}
}
for (Mesh& m : parser::scene.meshes) {
for (Face& f : m.faces) {
t = intersect(f);
Vec3f p = e + d * t;
if (t > minDistance && t < maxDistance) {
float dp = dotProduct(d,f.normal );
return true;
}
}
}
return false;
}
Vec3f Ray::calculateColor(const Vec3f& intersection, const Vec3f& normal, const Material& material)
{
Vec3f ambient = hadamardProduct(scene.ambient_light, material.ambient);
Vec3f spec = { 0,0,0 }, diffuse = { 0,0,0 }, specAdd = { 0,0,0 }, diffuseAdd = { 0,0,0 },half;
float cos, cosNormal;
for (PointLight& l : scene.point_lights) {
float distance = calculateDistance(l.position, intersection);
Ray r(intersection, l.position - intersection);
if (!r.checkObstacle(scene.shadow_ray_epsilon, distance)) {
cos = max((float)0.0, dotProduct(r.d, normal));
diffuseAdd = (cos / (distance * distance)) * l.intensity;
//diffuseAdd = hadamardProduct(diffuseAdd, material.diffuse);
//limitColorRange(diffuseAdd);
diffuse = diffuse + diffuseAdd;
if (cos == 0) {
continue;
}
half = r.d - d;
normalize(half);
cos = max((float)0.0, dotProduct(normal, half));
specAdd = (pow(cos, material.phong_exponent) / (distance * distance)) * l.intensity;
//specAdd = hadamardProduct(specAdd, material.specular);
//limitColorRange(specAdd);
spec = spec +specAdd ;
}
}
diffuse = hadamardProduct(diffuse, material.diffuse);
spec = hadamardProduct(spec, material.specular);
//Vec3f total = ambient + spec + diffuse;
//limitColorRange(total);
if(this->recursion == scene.max_recursion_depth) return ambient + spec + diffuse;
else return diffuse + spec;
}
/* minDistance = epsilon
* for recursion level 1, minDistance = distance of scene
*/
Vec3f Ray::calculateColor(float minDistance)
{
float t = std::numeric_limits<float>::max(), tmpt = 0;
Vec3f color,normal,intersection;
color.x = scene.background_color.x;
color.y = scene.background_color.y;
color.z = scene.background_color.z;
if (recursion == -1) return color;
Ray newRay;
Sphere* sphere = nullptr;
Triangle* triange = nullptr;
Mesh* mesh = nullptr;
Face* face = nullptr;
Material* material;
bool intersected = false;
for (Sphere& s : parser::scene.spheres) {
tmpt = intersect(s);
if (tmpt > minDistance && tmpt < t) {
t = tmpt;
sphere = &s;
material = &s.material;
intersection = positionT(t);
normal = (intersection - sphere->center_vertex)/sphere->radius;
intersected = true;
}
}
for (Triangle& tr : parser::scene.triangles) {
Face& f = tr.indices;
tmpt = intersect(f);
if (tmpt > minDistance && tmpt < t) {
t = tmpt;
face = &f;
material = &tr.material;
normal = face->normal;
intersected = true;
}
}
for (Mesh& m : parser::scene.meshes) {
for (Face& f : m.faces) {
tmpt = intersect(f);
if (tmpt > minDistance && tmpt < t) {
t = tmpt;
face = &f;
material = &m.material;
normal = face->normal;
intersected = true;
}
}
}
if (intersected == false) {
color.x = scene.background_color.x;
color.y = scene.background_color.y;
color.z = scene.background_color.z;
return color;
}
intersection = positionT(t);
color = calculateColor(intersection, normal, *material);
if (recursion != 0 && material->is_mirror ) {
newRay = generateReflection(intersection, normal);
Vec3f reflectionColor = newRay.calculateColor(parser::scene.shadow_ray_epsilon);
return color + hadamardProduct(reflectionColor, material->mirror);
}
else return color;
}
Vec3f Ray::calculateDiffuse(const Vec3f& intersection, const Vec3f& normal, const Material& material)
{
float cos;
Vec3f diffuse;
diffuse.x = 0;
diffuse.y = 0;
diffuse.z = 0;
Vec3f diffuseAdd(diffuse);
for (PointLight& l : scene.point_lights) {
float distance = calculateDistance(l.position, intersection);
Ray r(intersection, l.position - intersection);
if (!r.checkObstacle(scene.shadow_ray_epsilon, distance)) {
cos = max((float)0.0, dotProduct(r.d, normal));
if (cos > 1 || cos < -1 * epsilon) {
int bp = 0;
}
diffuseAdd = (cos / (distance * distance)) * l.intensity;
//diffuseAdd = hadamardProduct(diffuseAdd, material.diffuse);
//limitColorRange(diffuseAdd);
diffuse = diffuse + diffuseAdd;
}
}
diffuse = hadamardProduct(diffuse, material.diffuse);
//limitColorRange(diffuse);
return diffuse;
}
Vec3f Ray::calculateSpecular(const Vec3f& intersection, const Vec3f& normal, const Material& material)
{
float cos;
Vec3f spec, half;
spec.x = 0;
spec.y = 0;
spec.z = 0;
Vec3f specAdd(spec);
for (PointLight& l : scene.point_lights) {
float distance = calculateDistance(l.position, intersection);
Ray r(intersection, (l.position - intersection) / distance);
if (!r.checkObstacle(scene.shadow_ray_epsilon, distance)) {
half = r.d - d;
half = normalize(half);
cos = max((float)0.0, dotProduct(normal, half));
float cosNormal = dotProduct(normal, r.d);
if (cosNormal < -1 * epsilon) {
continue;
}
specAdd = (pow(cos,material.phong_exponent) / (distance * distance)) * l.intensity;
//specAdd = hadamardProduct(specAdd, material.specular);
//limitColorRange(specAdd);
spec = spec + specAdd;
}
}
spec = hadamardProduct(spec, material.specular);
//limitColorRange(spec);
return spec;
}
Ray Ray::generateReflection(const Vec3f& position, const Vec3f& normal)
{
Vec3f d_reflection;
float cos = dotProduct(normal, -1 * d);
Ray r(position, d + 2 * cos* normal );
r.recursion = recursion - 1;
return r;
}
| 28.915789 | 103 | 0.649193 | selinnilesy |
1e86c52f38707156cbb2a7ed3a8cb9a5aeafac0b | 2,892 | cpp | C++ | McQuickBoot/src/Controller/McResult.cpp | mrcao20/McQuickBoot | 187a16ea9459fa5e2b3477b5280302a9090e8ccf | [
"MIT"
] | 3 | 2020-03-29T18:41:42.000Z | 2020-09-23T01:46:25.000Z | McQuickBoot/src/Controller/McResult.cpp | mrcao20/McQuickBoot | 187a16ea9459fa5e2b3477b5280302a9090e8ccf | [
"MIT"
] | 3 | 2020-11-26T03:37:31.000Z | 2020-12-21T02:17:17.000Z | McQuickBoot/src/Controller/McResult.cpp | mrcao20/McQuickBoot | 187a16ea9459fa5e2b3477b5280302a9090e8ccf | [
"MIT"
] | null | null | null | /*
* MIT License
*
* Copyright (c) 2021 mrcao20
*
* 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 "McBoot/Controller/impl/McResult.h"
#include <QDebug>
#include <QJsonDocument>
#include <QJsonObject>
MC_DECL_PRIVATE_DATA(McResult)
bool isInternalError{false};
bool isSuccess{false};
QString errMsg;
QVariant result;
MC_DECL_PRIVATE_DATA_END
MC_INIT(McResult)
MC_REGISTER_BEAN_FACTORY(McResult);
MC_INIT_END
McResult::McResult(QObject *parent)
: QObject(parent)
{
MC_NEW_PRIVATE_DATA(McResult)
}
McResult::~McResult()
{
}
bool McResult::isSuccess() const noexcept
{
return d->isSuccess;
}
void McResult::setSuccess(bool val) noexcept
{
d->isSuccess = val;
}
QString McResult::errMsg() const noexcept
{
return d->errMsg;
}
void McResult::setErrMsg(const QString &val) noexcept
{
d->errMsg = val;
}
QVariant McResult::result() const noexcept
{
return d->result;
}
void McResult::setResult(const QVariant &val) noexcept
{
d->result = val;
}
QDebug operator<<(QDebug dbg, McResult *r)
{
QDebugStateSaver saver(dbg);
QJsonObject jsonObj;
jsonObj.insert("isSuccess", r->isSuccess());
jsonObj.insert("result", QJsonValue::fromVariant(r->result()));
jsonObj.insert("errMsg", r->errMsg());
dbg.noquote() << QJsonDocument(jsonObj).toJson();
return dbg;
}
QDebug operator<<(QDebug dbg, const QSharedPointer<McResult> &r)
{
QDebugStateSaver saver(dbg);
QJsonObject jsonObj;
jsonObj.insert("isSuccess", r->isSuccess());
jsonObj.insert("result", QJsonValue::fromVariant(r->result()));
jsonObj.insert("errMsg", r->errMsg());
dbg.noquote() << QJsonDocument(jsonObj).toJson();
return dbg;
}
bool McResult::isInternalError() const noexcept
{
return d->isInternalError;
}
void McResult::setInternalError(bool val) noexcept
{
d->isInternalError = val;
}
| 25.821429 | 81 | 0.727178 | mrcao20 |
1e8accbfe398a414ec0bfc3ac465c9e775172b70 | 1,144 | cpp | C++ | src/core/dfs_memory.cpp | gogobody/ngx_epoll_sample | d44c195f608da52aacf6e140690afe82f4afb6ac | [
"MIT"
] | null | null | null | src/core/dfs_memory.cpp | gogobody/ngx_epoll_sample | d44c195f608da52aacf6e140690afe82f4afb6ac | [
"MIT"
] | null | null | null | src/core/dfs_memory.cpp | gogobody/ngx_epoll_sample | d44c195f608da52aacf6e140690afe82f4afb6ac | [
"MIT"
] | null | null | null | #include "dfs_memory.h"
/*
*
<1>alloca是向栈申请内存,因此无需释放.
<2>malloc分配的内存是位于堆中的,并且没有初始化内存的内容,因此基本上malloc之后,调用函数memset来初始化这部分的内存空间.
<3>calloc则将初始化这部分的内存,设置为0.
* */
void * memory_alloc(size_t size)
{
void *p = nullptr;
if (size == 0)
{
return nullptr;
}
p = malloc(size);
return p;
}
// 申请内存并初始化为 0
void * memory_calloc(size_t size)
{
void *p = memory_alloc(size);
if (p)
{
memory_zero(p, size);
}
return p;
}
void memory_free(void *p)
{
if (p)
{
free(p);
}
}
// 内存对其的分配
void * memory_memalign(size_t alignment, size_t size)
{
void *p = nullptr;
if (size == 0)
{
return nullptr;
}
// 分配size大小的字节，并将分配的内存地址存放在memptr中。分配的内存的地址将是alignment的倍数
posix_memalign(&p, alignment, size);
return p;
}
int memory_n2cmp(uchar_t *s1, uchar_t *s2, size_t n1, size_t n2)
{
size_t n = 0;
int m = 0, z = 0;
if (n1 <= n2)
{
n = n1;
z = -1;
}
else
{
n = n2;
z = 1;
}
m = memory_memcmp(s1, s2, n);
if (m || n1 == n2)
{
return m;
}
return z;
}
| 13.783133 | 72 | 0.530594 | gogobody |
1e948963b99808defb6948eed9bbe07f81adf80b | 9,171 | cpp | C++ | core/Instances.cpp | sudarsun/c48 | 4ffd0825380eacd0b120b42cfd0b24182bf9fb8e | [
"Unlicense"
] | null | null | null | core/Instances.cpp | sudarsun/c48 | 4ffd0825380eacd0b120b42cfd0b24182bf9fb8e | [
"Unlicense"
] | null | null | null | core/Instances.cpp | sudarsun/c48 | 4ffd0825380eacd0b120b42cfd0b24182bf9fb8e | [
"Unlicense"
] | null | null | null | #include "Instances.h"
#include "Instance.h"
#include "Consts.h"
#include "Utils.h"
#include <iostream>
#include <unordered_set>
#include <exception>
#include <stdexcept>
Instances::Instances(const string &name, std::vector<Attribute*> &attInfo, const int capacity)
{
// check whether the attribute names are unique
std::unordered_set<string> attr_names;
string nonUniqueNames = "";
for (auto att : attInfo)
{
if (std::find(attr_names.begin(), attr_names.end(), att->name()) != attr_names.end())
{
nonUniqueNames.append(string("'") + att->name() + string("' "));
}
attr_names.insert(att->name());
}
if (attr_names.size() != attInfo.size())
{
throw std::invalid_argument(string("Attribute names are not unique!") + string(" Causes: ") + nonUniqueNames);
}
attr_names.clear();
mRelationName = name;
mClassIndex = -1;
mAttributes = attInfo;
mNamesToAttributeIndices = std::unordered_map<string, int>(static_cast<int>(numAttributes() / 0.75));
for (int i = 0; i < numAttributes(); i++)
{
attribute(i).setIndex(i);
mNamesToAttributeIndices[(attribute(i)).name()] = i;
}
mInstances = std::vector<Instance*>(capacity);
}
Instances::Instances(Instances *dataset) :Instances(dataset, 0)
{
this->copyInstances(0, *dataset, dataset->numInstances());
}
Instances::Instances(Instances *dataset, const int capacity)
{
initialize(*dataset, capacity);
}
Attribute &Instances::attribute(const int index) const
{
return *mAttributes[index];
}
Attribute &Instances::attribute(const string &name)
{
int index = mNamesToAttributeIndices[name];
if (index != -1)
{
return attribute(index);
}
return *(new Attribute(nullptr));
}
int Instances::numAttributes() const
{
return (int)mAttributes.size();
}
int Instances::classIndex() const
{
return mClassIndex;
}
void Instances::setClassIndex(const int classIndex)
{
if (classIndex >= numAttributes())
{
throw string("Invalid class index: ") + std::to_string(classIndex);
}
mClassIndex = classIndex;
}
bool Instances::add(Instance &instance)
{
Instance *newInstance = static_cast<Instance*>(&instance);
newInstance->setDataset(const_cast<Instances*>(this));
mInstances.push_back(&instance);
return true;
}
void Instances::add(const int index, Instance &instance)
{
Instance *newInstance = static_cast<Instance*>(&instance);
newInstance->setDataset(this);
mInstances[index] = &instance;
}
int Instances::numInstances() const
{
return (int)mInstances.size();
}
void Instances::copyInstances(const int from, const Instances &dest, const int num)
{
for (int i = 0; i < num; i++)
{
Instance *newInstance = new Instance(dest.instance(i).weight(), dest.instance(i).toDoubleArray());
newInstance->setDataset(const_cast<Instances*>(this));
mInstances.push_back(newInstance);
}
}
Instance &Instances::instance(const int index) const
{
return *mInstances[index];
}
void Instances::initialize(const Instances &dataset, int capacity)
{
if (capacity < 0)
{
capacity = 0;
}
// Strings only have to be "shallow" copied because
// they can't be modified.
mClassIndex = dataset.mClassIndex;
mRelationName = dataset.mRelationName;
mAttributes = dataset.mAttributes;
mNamesToAttributeIndices = dataset.mNamesToAttributeIndices;
mInstances = std::vector<Instance*>(capacity);
}
Attribute &Instances::classAttribute() const
{
if (mClassIndex < 0)
{
throw "Class index is negative (not set)!";
}
return attribute(mClassIndex);
}
int Instances::numClasses() const
{
if (mClassIndex < 0)
{
throw "Class index is negative (not set)!";
}
if (!classAttribute().isNominal())
{
return 1;
}
else
{
return classAttribute().numValues();
}
}
Instance &Instances::lastInstance() const
{
return *mInstances[mInstances.size() - 1];
}
void Instances::deleteWithMissing(const int attIndex)
{
std::vector<Instance*> newInstances;
int totalInst = numInstances();
for (int i = 0; i < totalInst; i++)
{
if (!instance(i).isMissing(attIndex))
{
newInstances.push_back(&instance(i));
}
}
mInstances = newInstances;
}
void Instances::deleteWithMissing(const Attribute &att)
{
deleteWithMissing(att.index());
}
void Instances::deleteWithMissingClass()
{
if (mClassIndex < 0)
{
throw "Class index is negative (not set)!";
}
deleteWithMissing(mClassIndex);
}
double Instances::sumOfWeights() const
{
double sum = 0;
for (int i = 0; i < numInstances(); i++)
{
sum += instance(i).weight();
}
return sum;
}
Instances *Instances::trainCV(const int numFolds, const int numFold)
{
int numInstForFold, first, offset;
Instances *train;
if (numFolds < 2)
{
throw std::invalid_argument("Number of folds must be at least 2!");
}
if (numFolds > numInstances())
{
throw "Can't have more folds than instances!";
}
numInstForFold = numInstances() / numFolds;
if (numFold < numInstances() % numFolds)
{
numInstForFold++;
offset = numFold;
}
else
{
offset = numInstances() % numFolds;
}
train = new Instances(this, numInstances() - numInstForFold);
first = numFold * (numInstances() / numFolds) + offset;
copyInstances(0, train, first);
copyInstances(first + numInstForFold, train, numInstances() - first - numInstForFold);
return train;
}
Instances *Instances::testCV(const int numFolds, const int numFold)
{
int numInstForFold, first, offset;
Instances *test;
if (numFolds < 2)
{
throw std::invalid_argument("Number of folds must be at least 2!");
}
if (numFolds > numInstances())
{
throw "Can't have more folds than instances!";
}
numInstForFold = numInstances() / numFolds;
if (numFold < numInstances() % numFolds)
{
numInstForFold++;
offset = numFold;
}
else
{
offset = numInstances() % numFolds;
}
test = new Instances(this, numInstForFold);
first = numFold * (numInstances() / numFolds) + offset;
copyInstances(first, test, numInstForFold);
return test;
}
void Instances::Sort(const int attIndex)
{
if (!attribute(attIndex).isNominal())
{
// Use quicksort from Utils class for sorting
double_array vals(numInstances());
std::vector<Instance*> backup(vals.size());
for (int i = 0; i < vals.size(); i++)
{
Instance &inst = instance(i);
backup[i] = &inst;
double val = inst.value(attIndex);
if (Utils::isMissingValue(val))
{
vals[i] = std::numeric_limits<double>::max();
}
else
{
vals[i] = val;
}
}
int_array sortOrder = Utils::sortWithNoMissingValues(vals);
for (int i = 0; i < vals.size(); i++)
{
mInstances[i] = backup[sortOrder[i]];
}
}
else
{
sortBasedOnNominalAttribute(attIndex);
}
}
void Instances::Sort(const Attribute &att)
{
Sort(att.index());
}
void Instances::sortBasedOnNominalAttribute(const int attIndex)
{
// Figure out number of instances for each attribute value
// and store original list of instances away
int_array counts((attribute(attIndex)).numValues());
std::vector<Instance*> backup(numInstances());
int j = 0;
for (auto inst : mInstances)
{
backup[j++] = inst;
if (!inst->isMissing(attIndex))
{
counts[static_cast<int>(inst->value(attIndex))]++;
}
}
// Indices to figure out where to add instances
int_array indices(counts.size());
int start = 0;
for (int i = 0; i < counts.size(); i++)
{
indices[i] = start;
start += counts[i];
}
for (auto inst : backup)
{
// Use backup here
if (!inst->isMissing(attIndex))
{
mInstances[indices[static_cast<int>(inst->value(attIndex))]++] = inst;
}
else
{
mInstances[start++] = inst;
}
}
}
string Instances::getRelationName() const
{
return mRelationName;
}
void Instances::setRelationName(const string &name)
{
mRelationName = name;
}
double_array Instances::attributeToDoubleArray(const int index) const
{
int totalInst = numInstances();
double_array result;
for (int i = 0; i < totalInst; i++) {
result.push_back(instance(i).value(index));
}
return result;
}
| 25.264463 | 119 | 0.591975 | sudarsun |
1e96c8415812536d618641cf19b018660ba0b7a6 | 2,494 | cpp | C++ | atcoder/arc011/B/main.cpp | Johniel/contests | b692eff913c20e2c1eb4ff0ce3cd4c57900594e0 | [
"Unlicense"
] | null | null | null | atcoder/arc011/B/main.cpp | Johniel/contests | b692eff913c20e2c1eb4ff0ce3cd4c57900594e0 | [
"Unlicense"
] | 19 | 2016-05-04T02:46:31.000Z | 2021-11-27T06:18:33.000Z | atcoder/arc011/B/main.cpp | Johniel/contests | b692eff913c20e2c1eb4ff0ce3cd4c57900594e0 | [
"Unlicense"
] | null | null | null | // atcoder/arc011/B/main.cpp
// author: @___Johniel
// github: https://github.com/johniel/
#include <bits/stdc++.h>
#define each(i, c) for (auto& i : c)
#define unless(cond) if (!(cond))
using namespace std;
template<typename P, typename Q> ostream& operator << (ostream& os, pair<P, Q> p) { os << "(" << p.first << "," << p.second << ")"; return os; }
template<typename P, typename Q> istream& operator >> (istream& is, pair<P, Q>& p) { is >> p.first >> p.second; return is; }
template<typename T> ostream& operator << (ostream& os, vector<T> v) { os << "("; for (auto& i: v) os << i << ","; os << ")"; return os; }
template<typename T> istream& operator >> (istream& is, vector<T>& v) { for (auto& i: v) is >> i; return is; }
template<typename T> ostream& operator << (ostream& os, set<T> s) { os << "#{"; for (auto& i: s) os << i << ","; os << "}"; return os; }
template<typename K, typename V> ostream& operator << (ostream& os, map<K, V> m) { os << "{"; for (auto& i: m) os << i << ","; os << "}"; return os; }
template<typename T> inline T setmax(T& a, T b) { return a = std::max(a, b); }
template<typename T> inline T setmin(T& a, T b) { return a = std::min(a, b); }
using lli = long long int;
using ull = unsigned long long;
using point = complex<double>;
using str = string;
template<typename T> using vec = vector<T>;
constexpr array<int, 8> di({0, 1, -1, 0, 1, -1, 1, -1});
constexpr array<int, 8> dj({1, 0, 0, -1, 1, -1, -1, 1});
constexpr lli mod = 1e9 + 7;
int main(int argc, char *argv[])
{
std::ios_base::sync_with_stdio(0);
std::cin.tie(0);
std::cout.setf(std::ios_base::fixed);
std::cout.precision(15);
int n;
while (cin >> n) {
vec<str> v(n);
cin >> v;
vec<str> u;
each (s, v) {
str t;
each (c, s) {
c = tolower(c);
if (c == 'a' || c == 'i' || c == 'u' || c == 'e' || c == 'o') continue;
if (c == 'b' || c == 'c') t += '1';
if (c == 'd' || c == 'w') t += '2';
if (c == 't' || c == 'j') t += '3';
if (c == 'f' || c == 'q') t += '4';
if (c == 'l' || c == 'v') t += '5';
if (c == 's' || c == 'x') t += '6';
if (c == 'p' || c == 'm') t += '7';
if (c == 'h' || c == 'k') t += '8';
if (c == 'n' || c == 'g') t += '9';
if (c == 'z' || c == 'r') t += '0';
}
if (t.size()) u.push_back(t);
}
for (int i = 0; i < u.size(); ++i) {
if (i) cout << ' ';
cout << u[i];
}
cout << endl;
}
return 0;
}
| 34.164384 | 150 | 0.480754 | Johniel |
1e9904710a041b6f25f4adc797faec875a3e87ad | 14,976 | cpp | C++ | reconstruction/gadgetron/CS_LAB_Gadget/src/ELASTIX_GADGET/ElastixRegistrationGadget.cpp | alwaysbefun123/CS_MoCo_LAB | a26e8e483624b2e4ee669e7a069ba9c74d2d2e4b | [
"BSD-2-Clause"
] | 83 | 2017-08-11T09:18:17.000Z | 2022-01-23T03:08:00.000Z | reconstruction/gadgetron/CS_LAB_Gadget/src/ELASTIX_GADGET/ElastixRegistrationGadget.cpp | MrYuwan/CS_MoCo_LAB | a26e8e483624b2e4ee669e7a069ba9c74d2d2e4b | [
"BSD-2-Clause"
] | 4 | 2017-09-19T23:02:12.000Z | 2020-11-23T11:25:18.000Z | reconstruction/gadgetron/CS_LAB_Gadget/src/ELASTIX_GADGET/ElastixRegistrationGadget.cpp | MrYuwan/CS_MoCo_LAB | a26e8e483624b2e4ee669e7a069ba9c74d2d2e4b | [
"BSD-2-Clause"
] | 49 | 2017-03-19T18:41:55.000Z | 2021-11-25T08:25:44.000Z | /*
file name : ElastixRegistrationGadget.cpp
author : Martin Schwartz (martin.schwartz@med.uni-tuebingen.de)
Thomas Kuestner (thomas.kuestner@med.uni-tuebingen.de)
version : 1.2
date : 13.10.2015
23.03.2017 - update for Gadgetron v3.8
23.01.2018 - renaming
description : implementation of the class ElastixRegistrationGadget - only 3D (x,y,t) and 4D data (x,y,z,t) provided
*/
#include "ElastixRegistrationGadget.h"
#include <boost/algorithm/string/predicate.hpp>
#include "SomeFunctions.h"
using namespace Gadgetron;
ElastixRegistrationGadget::ElastixRegistrationGadget()
{
}
ElastixRegistrationGadget::~ElastixRegistrationGadget()
{
}
int ElastixRegistrationGadget::process_config(ACE_Message_Block *mb)
{
#ifdef __GADGETRON_VERSION_HIGHER_3_6__
log_output_ = LogOutput.value();
sPathParam_ = PathParam.value();
sPathLog_ = PathLog.value();
#else
log_output_ = *(get_bool_value("LogOutput").get());
sPathParam_ = *(get_string_value("PathParam").get());
sPathLog_ = *(get_string_value("PathLog").get());
#endif
// ensure that path variable ends with dir separator
#ifdef __WIN32__
#define DIR_SEPARATOR "\\"
#else
#define DIR_SEPARATOR "/"
#endif
if (boost::algorithm::ends_with(sPathLog_, DIR_SEPARATOR)) {
sPathLog_ += DIR_SEPARATOR;
}
return GADGET_OK;
}
int ElastixRegistrationGadget::process(GadgetContainerMessage<ISMRMRD::ImageHeader> *m1, GadgetContainerMessage<hoNDArray<float> > *m2)
{
// create references for easier usage
const hoNDArray<float> &data = *m2->getObjectPtr();
std::vector<size_t> dimensions = *data.get_dimensions();
// determine number of gate dimensions
const size_t number_of_gate_dimensions = data.get_number_of_dimensions() > 3 ? data.get_number_of_dimensions()-3 : data.get_number_of_dimensions()-1;
// get gate dimensions
const std::vector<size_t> gate_dimensions(dimensions.end()-number_of_gate_dimensions, dimensions.end());
// determine number of images
const size_t number_of_images = std::accumulate(dimensions.end()-number_of_gate_dimensions, dimensions.end(), 1, std::multiplies<size_t>());
// other dimensions are dimension of one image
const std::vector<size_t> dimensions_of_image(dimensions.begin(), dimensions.end()-number_of_gate_dimensions);
// check for image dimensions
bool skip_registration = false;
if (dimensions_of_image.size() < 2 || dimensions_of_image.size() > 3) {
GWARN("Dataset does not contain 2D or 3D images - Skip registration...\n");
skip_registration = true;
} else if (number_of_images <= 1) {
GWARN("There must be at least two images to register them - Skip registration...\n");
skip_registration = true;
}
// skip registration if it cannot be performed
if (skip_registration) {
if (this->next()->putq(m1) < 0) {
return GADGET_FAIL;
}
return GADGET_OK;
}
/* ------------------------------------------------------------------- */
/* --------------- create registration parameter data ---------------- */
/* ------------------------------------------------------------------- */
GINFO("Load elastix parameter file..\n");
// Create parser for transform parameters text file.
ParserType::Pointer file_parser = ParserType::New();
GINFO("search for parameter file - %s..\n", sPathParam_.c_str());
// Try parsing transform parameters text file.
file_parser->SetParameterFileName(sPathParam_);
try {
file_parser->ReadParameterFile();
} catch (itk::ExceptionObject &e) {
std::cout << e.what() << std::endl;
}
RegistrationParametersType parameters = file_parser->GetParameterMap();
GINFO("parameter file - %s - loaded..\n", sPathParam_.c_str());
/* ------------------------------------------------------------------- */
/* -------------------- init elastix registration -------------------- */
/* ------------------------------------------------------------------- */
// print dimensions
std::stringstream ss;
ss << "size - ";
for (size_t i = 0; i < dimensions_of_image.size(); i++) {
ss << dimensions_of_image.at(i) << " ";
}
ss << number_of_images;
GDEBUG("%s\n", ss.str().c_str());
// get fixed image from dataset
std::vector<size_t> fixed_image_dimensions = dimensions_of_image;
hoNDArray<float> fixed_image(fixed_image_dimensions, const_cast<float*>(data.get_data_ptr()), false);
// create registered (output) image
hoNDArray<float> output_image(*data.get_dimensions());
memcpy(output_image.get_data_ptr(), fixed_image.get_data_ptr(), fixed_image.get_number_of_bytes());
// create array for deformation field with dimensions [X Y Z CombinedPhases VectorComponents(2 or 3)]
std::vector<size_t> output_df_dimensions = dimensions_of_image;
output_df_dimensions.push_back(number_of_images - 1);
output_df_dimensions.push_back(dimensions_of_image.size());
hoNDArray<float> output_deformation_field(&output_df_dimensions);
// set itk image parameter
ImportFilterType::Pointer itkImportFilter = ImportFilterType::New();
ImportFilterType::SizeType itkSize;
itkSize[0] = dimensions_of_image.at(0);
itkSize[1] = dimensions_of_image.at(1);
itkSize[2] = dimensions_of_image.size() >= 3 ? dimensions_of_image.at(2) : 1; // ITK handels 3D image, so if we have a 2D moving image, 3rd dimension=1
ImportFilterType::IndexType itkStart;
itkStart.Fill(0);
ImportFilterType::RegionType itkRegion;
itkRegion.SetIndex(itkStart);
itkRegion.SetSize(itkSize);
itkImportFilter->SetRegion(itkRegion);
double itkOrigin[3];
itkOrigin[0] = 0.0;
itkOrigin[1] = 0.0;
itkOrigin[2] = 0.0;
itkImportFilter->SetOrigin(itkOrigin);
double itkSpacing[3];
itkSpacing[0] = m1->getObjectPtr()->field_of_view[0]/m1->getObjectPtr()->matrix_size[0];
itkSpacing[1] = m1->getObjectPtr()->field_of_view[1]/m1->getObjectPtr()->matrix_size[1];
itkSpacing[2] = m1->getObjectPtr()->field_of_view[2]/m1->getObjectPtr()->matrix_size[2];
itkImportFilter->SetSpacing(itkSpacing);
float *fLocalBuffer = new float[fixed_image.get_number_of_elements()];
memcpy(fLocalBuffer, fixed_image.get_data_ptr(), fixed_image.get_number_of_bytes());
itkImportFilter->SetImportPointer(fLocalBuffer, fixed_image.get_number_of_elements(), true);
ImageType::Pointer itkFixedImage = ImageType::New();
itkFixedImage = itkImportFilter->GetOutput();
itkImportFilter->Update();
/* ------------------------------------------------------------------- */
/* --------- loop over moving images and perform registration -------- */
/* ------------------------------------------------------------------- */
GINFO("Loop over moving images..\n");
// loop over respiration
// #pragma omp parallel for // Note: Elastix itselfs parallels quite good. Some serious error can occur if you parallelise here!
for (size_t calculated_images = 1; calculated_images < number_of_images; calculated_images++) {
GINFO("%i of %i ...\n", calculated_images, number_of_images-1);
// calculate offset for one single image
const size_t moving_image_offset = std::accumulate(std::begin(dimensions_of_image), std::end(dimensions_of_image), 1, std::multiplies<size_t>())*calculated_images; // accumulate() := dimensions_of_image[0]*dimensions_of_image[1]*...
// crop moving image from 4D dataset
std::vector<size_t> moving_image_dimensions = dimensions_of_image;
hoNDArray<float> moving_image(moving_image_dimensions, const_cast<float*>(data.get_data_ptr()) + moving_image_offset, false);
float *fLocalBuffer = new float[moving_image.get_number_of_elements()];
memcpy(fLocalBuffer, moving_image.get_data_ptr(), moving_image.get_number_of_bytes());
itkImportFilter->SetImportPointer(fLocalBuffer, moving_image.get_number_of_elements(), true);
ImageType::Pointer itkMovingImage = ImageType::New();
itkMovingImage = itkImportFilter->GetOutput();
itkImportFilter->Update();
// image registration
elastix::ELASTIX *elastix_obj = new elastix::ELASTIX();
int error = 0;
try {
// perform registration with (FixedImage, MovingImage, ParameterFile, OutputPath, ElastixLog, ConsoleOutput, FixedImageMask, MovingImageMask)
error = elastix_obj->RegisterImages(static_cast<itk::DataObject::Pointer>(itkFixedImage.GetPointer()), static_cast<itk::DataObject::Pointer>(itkMovingImage.GetPointer()), parameters, sPathLog_, log_output_, false, 0, 0);
} catch (itk::ExitEvent &err) {
// error handling - write message and fill array with zeros
GERROR("Error event catched directly from elastix\n");
}
// get output image
ImageType *itkOutputImage = NULL;
if (error == 0) {
if (elastix_obj->GetResultImage().IsNotNull()) {
itkOutputImage = static_cast<ImageType*>(elastix_obj->GetResultImage().GetPointer());
} else {
GERROR("GetResultImage() is NULL \n", error);
}
} else {
// error handling - write message and fill array with zeros
GERROR("array is zero\n", error);
}
// set output image to zeros if non-existent
void *memcpy_pointer = NULL;
ImageType::Pointer zero_image;
if (itkOutputImage != NULL) {
memcpy_pointer = itkOutputImage->GetBufferPointer();
} else {
ImageType::IndexType start;
for (size_t i = 0; i < 3; i++) {
start[i] = 0;
}
ImageType::SizeType size;
for (size_t i = 0; i < dimensions_of_image.size(); i++) {
size[i] = dimensions_of_image[i];
}
size[dimensions_of_image.size()] = number_of_images;
ImageType::RegionType region;
region.SetSize(size);
region.SetIndex(start);
zero_image = ImageType::New();
zero_image->SetRegions(region);
zero_image->Allocate();
zero_image->FillBuffer(0.0);
memcpy_pointer = zero_image->GetBufferPointer();
}
// copy image to new registered 4D image
memcpy(output_image.get_data_ptr()+moving_image_offset, memcpy_pointer, moving_image.get_number_of_bytes());
// clean up
delete elastix_obj;
elastix_obj = NULL;
// calculate deformation field
std::string transformix_command = std::string("transformix -def all -out ")+sPathLog_+std::string(" -tp ")+sPathLog_+std::string("TransformParameters.0.txt");
int term_status = system(transformix_command.c_str());
if (WIFEXITED(term_status)) {
// transformix completed successfully. Handle case here.
// create new dimension vector for array (dimensions e.g. 3 256 256 72) - should also apply on 2D image
std::vector<size_t> deformation_field_dims;
deformation_field_dims.push_back(dimensions_of_image.size());
for (size_t i = 0; i < dimensions_of_image.size(); i++) {
deformation_field_dims.push_back(dimensions_of_image.at(i));
}
// create new array for deformation field image
hoNDArray<float> deformation_field(&deformation_field_dims);
std::string deformation_field_file_name = sPathLog_ + std::string("deformationField.mhd");
// read out image
switch (dimensions_of_image.size()) {
case 2:
read_itk_to_hondarray<2>(deformation_field, deformation_field_file_name.c_str(), fixed_image.get_number_of_elements());
break;
case 3:
read_itk_to_hondarray<3>(deformation_field, deformation_field_file_name.c_str(), fixed_image.get_number_of_elements());
break;
default:
GERROR("Image dimension (%d) is neither 2D nor 3D! Abort.\n", dimensions_of_image.size());
return GADGET_FAIL;
}
// permute data (in ITK dim is: [value_vector size_x size_y size_z])
// we want to output: (layer with value_vector X component, layer with Y,...)
// so: [value X Y Z] -> [X Y Z value]
std::vector<size_t> new_dim_order;
new_dim_order.push_back(1);
new_dim_order.push_back(2);
new_dim_order.push_back(3);
new_dim_order.push_back(0);
deformation_field = permute(deformation_field, new_dim_order);
// save deformation fields
for (size_t i = 0; i < dimensions_of_image.size(); i++) {
const size_t df_offset = i * moving_image.get_number_of_elements();
const size_t output_df_offset = moving_image.get_number_of_elements() * ( // all slots (4th dimension 3D images) have same size, so multiply it with position)
i * output_deformation_field.get_size(3) // select correct vector component (X|Y[|Z])
+ (calculated_images - 1) // select correct image
);
// and copy permuted data into great return image
memcpy(output_deformation_field.get_data_ptr()+output_df_offset, deformation_field.get_data_ptr()+df_offset, moving_image.get_number_of_bytes());
}
} else {
GWARN("No deformation field for state %d available (Errors in transformix).\n", calculated_images);
}
}
// clean up the elastix/transformix generated files
std::vector<std::string> files_to_remove;
files_to_remove.push_back(std::string("deformationField.mhd"));
files_to_remove.push_back(std::string("deformationField.raw"));
if (!log_output_) {
files_to_remove.push_back(std::string("transformix.log"));
}
files_to_remove.push_back(std::string("TransformParameters.0.txt"));
files_to_remove.push_back(std::string("IterationInfo.0.R0.txt"));
files_to_remove.push_back(std::string("IterationInfo.0.R1.txt"));
files_to_remove.push_back(std::string("IterationInfo.0.R2.txt"));
files_to_remove.push_back(std::string("IterationInfo.0.R3.txt"));
while (files_to_remove.size() > 0) {
std::string file_to_remove = sPathLog_ + files_to_remove.back();
if (remove(file_to_remove.c_str()) != 0) {
GWARN("Could not remove %s. Please delete it manually!\n", file_to_remove.c_str());
}
// delete last element in list
files_to_remove.pop_back();
}
// free memory
m2->release();
// new GadgetContainer
GadgetContainerMessage<hoNDArray<float> > *cm2 = new GadgetContainerMessage<hoNDArray<float> >();
// concatenate data with header
m1->cont(cm2);
// create output
try {
cm2->getObjectPtr()->create(*output_image.get_dimensions());
} catch (std::runtime_error &err) {
GEXCEPTION(err,"Unable to allocate new image array\n");
m1->release();
return GADGET_FAIL;
}
// copy data
memcpy(cm2->getObjectPtr()->get_data_ptr(), output_image.get_data_ptr(), output_image.get_number_of_bytes());
// Now pass on image
if (this->next()->putq(m1) < 0) {
return GADGET_FAIL;
}
// ########## create deformation field message ###########
// copy header
GadgetContainerMessage<ISMRMRD::ImageHeader> *m1_df = new GadgetContainerMessage<ISMRMRD::ImageHeader>();
fCopyImageHeader(m1_df, m1->getObjectPtr());
// new GadgetContainer
GadgetContainerMessage<hoNDArray<float> > *m2_df = new GadgetContainerMessage<hoNDArray<float> >();
// concatenate data with header
m1_df->cont(m2_df);
// create output
try {
m2_df->getObjectPtr()->create(*output_deformation_field.get_dimensions());
} catch (std::runtime_error &err) {
GEXCEPTION(err,"Unable to allocate new deformation field array\n");
m1_df->release();
return GADGET_FAIL;
}
// copy data
memcpy(m2_df->getObjectPtr()->get_data_ptr(), output_deformation_field.begin(), output_deformation_field.get_number_of_bytes());
// Now pass on deformation field
if (this->next()->putq(m1_df) < 0) {
return GADGET_FAIL;
}
return GADGET_OK;
}
GADGET_FACTORY_DECLARE(ElastixRegistrationGadget)
| 36.705882 | 235 | 0.71047 | alwaysbefun123 |
1e9d1a5e295b188d51bacd4402496b77901359f7 | 13,508 | cpp | C++ | Source/modules/serviceworkers/Request.cpp | Fusion-Rom/android_external_chromium_org_third_party_WebKit | 8865f83aaf400ef5f7c234a70da404d3fc5e1272 | [
"BSD-3-Clause"
] | 2 | 2016-05-19T10:37:25.000Z | 2019-09-18T04:37:14.000Z | Source/modules/serviceworkers/Request.cpp | Fusion-Rom/android_external_chromium_org_third_party_WebKit | 8865f83aaf400ef5f7c234a70da404d3fc5e1272 | [
"BSD-3-Clause"
] | null | null | null | Source/modules/serviceworkers/Request.cpp | Fusion-Rom/android_external_chromium_org_third_party_WebKit | 8865f83aaf400ef5f7c234a70da404d3fc5e1272 | [
"BSD-3-Clause"
] | 7 | 2015-09-23T09:56:29.000Z | 2022-01-20T10:36:06.000Z | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "config.h"
#include "Request.h"
#include "bindings/core/v8/Dictionary.h"
#include "core/dom/ExecutionContext.h"
#include "core/fetch/FetchUtils.h"
#include "core/fetch/ResourceLoaderOptions.h"
#include "core/loader/ThreadableLoader.h"
#include "core/xml/XMLHttpRequest.h"
#include "modules/serviceworkers/FetchManager.h"
#include "modules/serviceworkers/HeadersForEachCallback.h"
#include "modules/serviceworkers/RequestInit.h"
#include "platform/NotImplemented.h"
#include "platform/network/HTTPParsers.h"
#include "platform/network/ResourceRequest.h"
#include "platform/weborigin/Referrer.h"
#include "public/platform/WebServiceWorkerRequest.h"
namespace blink {
namespace {
class FillWebRequestHeaders : public HeadersForEachCallback {
public:
FillWebRequestHeaders(WebServiceWorkerRequest* webRequest) : m_webRequest(webRequest) { }
virtual bool handleItem(ScriptValue, const String&, const String&, Headers*)
{
ASSERT_NOT_REACHED();
return false;
}
virtual bool handleItem(const String& value, const String& key, Headers*)
{
m_webRequest->appendHeader(key, value);
return true;
}
private:
WebServiceWorkerRequest* m_webRequest;
};
} // namespace
Request* Request::createRequestWithRequestData(ExecutionContext* context, FetchRequestData* request, const RequestInit& init, FetchRequestData::Mode mode, FetchRequestData::Credentials credentials, ExceptionState& exceptionState)
{
// "7. Let |mode| be |init|'s mode member if it is present, and
// |fallbackMode| otherwise."
// "8. If |mode| is non-null, set |request|'s mode to |mode|."
if (init.mode == "same-origin") {
request->setMode(FetchRequestData::SameOriginMode);
} else if (init.mode == "no-cors") {
request->setMode(mode = FetchRequestData::NoCORSMode);
} else if (init.mode == "cors") {
request->setMode(FetchRequestData::CORSMode);
} else {
// Instead of using null as a special fallback value, we pass the
// current mode in Request::create(). So we just set here.
request->setMode(mode);
}
// "9. Let |credentials| be |init|'s credentials member if it is present,
// and |fallbackCredentials| otherwise."
// "10. If |credentials| is non-null, set |request|'s credentials mode to
// |credentials|.
if (init.credentials == "omit") {
request->setCredentials(FetchRequestData::OmitCredentials);
} else if (init.credentials == "same-origin") {
request->setCredentials(FetchRequestData::SameOriginCredentials);
} else if (init.credentials == "include") {
request->setCredentials(FetchRequestData::IncludeCredentials);
} else {
// Instead of using null as a special fallback value, we pass the
// current credentials in Request::create(). So we just set here.
request->setCredentials(credentials);
}
// "11. If |init|'s method member is present, let |method| be it and run
// these substeps:"
if (!init.method.isEmpty()) {
// "1. If |method| is not a useful method, throw a TypeError."
if (!FetchUtils::isUsefulMethod(init.method)) {
exceptionState.throwTypeError("'" + init.method + "' HTTP method is unsupported.");
return 0;
}
if (!isValidHTTPToken(init.method)) {
exceptionState.throwTypeError("'" + init.method + "' is not a valid HTTP method.");
return 0;
}
// FIXME: "2. Add case correction as in XMLHttpRequest?"
// "3. Set |request|'s method to |method|."
request->setMethod(XMLHttpRequest::uppercaseKnownHTTPMethod(AtomicString(init.method)));
}
// "12. Let |r| be a new Request object associated with |request|, Headers
// object."
Request* r = Request::create(context, request);
// "13. Let |headers| be a copy of |r|'s Headers object."
// "14. If |init|'s headers member is present, set |headers| to |init|'s
// headers member."
// We don't create a copy of r's Headers object when init's headers member
// is present.
Headers* headers = 0;
if (!init.headers && init.headersDictionary.isUndefinedOrNull()) {
headers = r->headers()->createCopy();
}
// "15. Empty |r|'s request's header list."
r->clearHeaderList();
// "16. If |r|'s request's mode is no CORS, run these substeps:
if (r->request()->mode() == FetchRequestData::NoCORSMode) {
// "1. If |r|'s request's method is not a simple method, throw a
// TypeError."
if (!FetchUtils::isSimpleMethod(r->request()->method())) {
exceptionState.throwTypeError("'" + r->request()->method() + "' is unsupported in no-cors mode.");
return 0;
}
// "Set |r|'s Headers object's guard to |request-no-CORS|.
r->headers()->setGuard(Headers::RequestNoCORSGuard);
}
// "17. Fill |r|'s Headers object with |headers|. Rethrow any exceptions."
if (init.headers) {
ASSERT(init.headersDictionary.isUndefinedOrNull());
r->headers()->fillWith(init.headers.get(), exceptionState);
} else if (!init.headersDictionary.isUndefinedOrNull()) {
r->headers()->fillWith(init.headersDictionary, exceptionState);
} else {
ASSERT(headers);
r->headers()->fillWith(headers, exceptionState);
}
if (exceptionState.hadException())
return 0;
// "18. If |init|'s body member is present, run these substeps:"
if (init.bodyBlobHandle) {
// "1. Let |stream| and |Content-Type| be the result of extracting
// |init|'s body member."
// "2. Set |r|'s request's body to |stream|."
// "3.If |Content-Type| is non-null and |r|'s request's header list
// contains no header named `Content-Type`, append
// `Content-Type`/|Content-Type| to |r|'s Headers object. Rethrow any
// exception."
r->setBodyBlobHandle(init.bodyBlobHandle);
if (!init.bodyBlobHandle->type().isEmpty() && !r->headers()->has("Content-Type", exceptionState)) {
r->headers()->append("Content-Type", init.bodyBlobHandle->type(), exceptionState);
}
if (exceptionState.hadException())
return 0;
}
// "19. Set |r|'s MIME type to the result of extracting a MIME type from
// |r|'s request's header list."
// FIXME: We don't have MIME type in Request object yet.
// "20. Return |r|."
return r;
}
Request* Request::create(ExecutionContext* context, const String& input, ExceptionState& exceptionState)
{
return create(context, input, Dictionary(), exceptionState);
}
Request* Request::create(ExecutionContext* context, const String& input, const Dictionary& init, ExceptionState& exceptionState)
{
// "2. Let |request| be |input|'s associated request, if |input| is a
// Request object, and a new request otherwise."
FetchRequestData* request(FetchRequestData::create(context));
// "3. Set |request| to a restricted copy of itself."
request = request->createRestrictedCopy(context, SecurityOrigin::create(context->url()));
// "6. If |input| is a string, run these substeps:"
// "1. Let |parsedURL| be the result of parsing |input| with entry settings
// object's API base URL."
KURL parsedURL = context->completeURL(input);
// "2. If |parsedURL| is failure, throw a TypeError."
if (!parsedURL.isValid()) {
exceptionState.throwTypeError("Invalid URL");
return 0;
}
// "3. Set |request|'s url to |parsedURL|."
request->setURL(parsedURL);
// "4. Set |fallbackMode| to CORS."
// "5. Set |fallbackCredentials| to omit."
return createRequestWithRequestData(context, request, RequestInit(context, init, exceptionState), FetchRequestData::CORSMode, FetchRequestData::OmitCredentials, exceptionState);
}
Request* Request::create(ExecutionContext* context, Request* input, ExceptionState& exceptionState)
{
return create(context, input, Dictionary(), exceptionState);
}
Request* Request::create(ExecutionContext* context, Request* input, const Dictionary& init, ExceptionState& exceptionState)
{
// "1. If input is a Request object, run these substeps:"
// " 1. If input's used flag is set, throw a TypeError."
// " 2. Set input's used flag."
if (input->bodyUsed()) {
exceptionState.throwTypeError(
"Cannot construct a Request with a Request object that has already been used.");
return 0;
}
input->setBodyUsed();
// "2. Let |request| be |input|'s associated request, if |input| is a
// Request object, and a new request otherwise."
// "3. Set |request| to a restricted copy of itself."
FetchRequestData* request(input->request()->createRestrictedCopy(context, SecurityOrigin::create(context->url())));
// "4. Let |fallbackMode| be null."
// "5. Let |fallbackCredentials| be null."
// Instead of using null as a special fallback value, just pass the current
// mode and credentials; it has the same effect.
const FetchRequestData::Mode currentMode = request->mode();
const FetchRequestData::Credentials currentCredentials = request->credentials();
return createRequestWithRequestData(context, request, RequestInit(context, init, exceptionState), currentMode, currentCredentials, exceptionState);
}
Request* Request::create(ExecutionContext* context, FetchRequestData* request)
{
Request* r = new Request(context, request);
r->suspendIfNeeded();
return r;
}
Request::Request(ExecutionContext* context, FetchRequestData* request)
: Body(context)
, m_request(request)
, m_headers(Headers::create(m_request->headerList()))
{
m_headers->setGuard(Headers::RequestGuard);
}
Request* Request::create(ExecutionContext* context, const WebServiceWorkerRequest& webRequest)
{
Request* r = new Request(context, webRequest);
r->suspendIfNeeded();
return r;
}
Request* Request::create(const Request& copyFrom)
{
Request* r = new Request(copyFrom);
r->suspendIfNeeded();
return r;
}
Request::Request(ExecutionContext* context, const WebServiceWorkerRequest& webRequest)
: Body(context)
, m_request(FetchRequestData::create(webRequest))
, m_headers(Headers::create(m_request->headerList()))
{
m_headers->setGuard(Headers::RequestGuard);
}
Request::Request(const Request& copy_from)
: Body(copy_from)
, m_request(copy_from.m_request)
, m_headers(copy_from.m_headers->createCopy())
{
}
String Request::method() const
{
// "The method attribute's getter must return request's method."
return m_request->method();
}
String Request::url() const
{
// The url attribute's getter must return request's url, serialized with the exclude fragment flag set.
if (!m_request->url().hasFragmentIdentifier())
return m_request->url();
KURL url(m_request->url());
url.removeFragmentIdentifier();
return url;
}
String Request::referrer() const
{
// "The referrer attribute's getter must return the empty string if
// request's referrer is none, and request's referrer, serialized,
// otherwise."
return m_request->referrer().referrer().referrer;
}
String Request::mode() const
{
// "The mode attribute's getter must return the value corresponding to the
// first matching statement, switching on request's mode:"
switch (m_request->mode()) {
case FetchRequestData::SameOriginMode:
return "same-origin";
case FetchRequestData::NoCORSMode:
return "no-cors";
case FetchRequestData::CORSMode:
case FetchRequestData::CORSWithForcedPreflight:
return "cors";
}
ASSERT_NOT_REACHED();
return "";
}
String Request::credentials() const
{
// "The credentials attribute's getter must return the value corresponding
// to the first matching statement, switching on request's credentials
// mode:"
switch (m_request->credentials()) {
case FetchRequestData::OmitCredentials:
return "omit";
case FetchRequestData::SameOriginCredentials:
return "same-origin";
case FetchRequestData::IncludeCredentials:
return "include";
}
ASSERT_NOT_REACHED();
return "";
}
Request* Request::clone() const
{
return Request::create(*this);
}
void Request::populateWebServiceWorkerRequest(WebServiceWorkerRequest& webRequest)
{
webRequest.setMethod(method());
webRequest.setURL(m_request->url());
m_headers->forEach(new FillWebRequestHeaders(&webRequest));
webRequest.setReferrer(m_request->referrer().referrer().referrer, static_cast<WebReferrerPolicy>(m_request->referrer().referrer().referrerPolicy));
// FIXME: How can we set isReload properly? What is the correct place to load it in to the Request object? We should investigate the right way
// to plumb this information in to here.
}
void Request::setBodyBlobHandle(PassRefPtr<BlobDataHandle> blobDataHandle)
{
m_request->setBlobDataHandle(blobDataHandle);
}
void Request::clearHeaderList()
{
m_request->headerList()->clearList();
}
PassRefPtr<BlobDataHandle> Request::blobDataHandle()
{
return m_request->blobDataHandle();
}
void Request::trace(Visitor* visitor)
{
Body::trace(visitor);
visitor->trace(m_request);
visitor->trace(m_headers);
}
} // namespace blink
| 37.522222 | 229 | 0.679301 | Fusion-Rom |
1e9e457e811076929716813d2d8c2004010b2fe0 | 7,081 | cxx | C++ | test/rtkadjointoperatorstest.cxx | cyrilmory/CyrilsRTK | bb829a9d6aff45181d1642b4b050dde999169ff8 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | test/rtkadjointoperatorstest.cxx | cyrilmory/CyrilsRTK | bb829a9d6aff45181d1642b4b050dde999169ff8 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | test/rtkadjointoperatorstest.cxx | cyrilmory/CyrilsRTK | bb829a9d6aff45181d1642b4b050dde999169ff8 | [
"Apache-2.0",
"BSD-3-Clause"
] | null | null | null | #include "rtkMacro.h"
#include "rtkTest.h"
#include "itkRandomImageSource.h"
#include "rtkConstantImageSource.h"
#include "rtkJosephBackProjectionImageFilter.h"
#include "rtkJosephForwardProjectionImageFilter.h"
#ifdef RTK_USE_CUDA
#include "rtkCudaForwardProjectionImageFilter.h"
#include "rtkCudaRayCastBackProjectionImageFilter.h"
#endif
/**
* \file rtkadjointoperatorstest.cxx
*
* \brief Tests whether forward and back projectors are matched
*
* This test generates a random volume "v" and a random set of projections "p",
* and compares the scalar products <Rv , p> and <v, R* p>, where R is either the
* Joseph forward projector or the Cuda ray cast forward projector,
* and R* is either the Joseph back projector or the Cuda ray cast back projector.
* If R* is indeed the adjoint of R, these scalar products are equal.
*
* \author Cyril Mory
*/
int main(int, char** )
{
const unsigned int Dimension = 3;
typedef float OutputPixelType;
#ifdef USE_CUDA
typedef itk::CudaImage< OutputPixelType, Dimension > OutputImageType;
#else
typedef itk::Image< OutputPixelType, Dimension > OutputImageType;
#endif
#if FAST_TESTS_NO_CHECKS
const unsigned int NumberOfProjectionImages = 3;
#else
const unsigned int NumberOfProjectionImages = 180;
#endif
// Random image sources
typedef itk::RandomImageSource< OutputImageType > RandomImageSourceType;
RandomImageSourceType::Pointer randomVolumeSource = RandomImageSourceType::New();
RandomImageSourceType::Pointer randomProjectionsSource = RandomImageSourceType::New();
// Constant sources
typedef rtk::ConstantImageSource< OutputImageType > ConstantImageSourceType;
ConstantImageSourceType::Pointer constantVolumeSource = ConstantImageSourceType::New();
ConstantImageSourceType::Pointer constantProjectionsSource = ConstantImageSourceType::New();
// Image meta data
RandomImageSourceType::PointType origin;
RandomImageSourceType::SizeType size;
RandomImageSourceType::SpacingType spacing;
// Volume metadata
origin[0] = -127.;
origin[1] = -127.;
origin[2] = -127.;
#if FAST_TESTS_NO_CHECKS
size[0] = 2;
size[1] = 2;
size[2] = 2;
spacing[0] = 252.;
spacing[1] = 252.;
spacing[2] = 252.;
#else
size[0] = 64;
size[1] = 64;
size[2] = 64;
spacing[0] = 4.;
spacing[1] = 4.;
spacing[2] = 4.;
#endif
randomVolumeSource->SetOrigin( origin );
randomVolumeSource->SetSpacing( spacing );
randomVolumeSource->SetSize( size );
randomVolumeSource->SetMin( 0. );
randomVolumeSource->SetMax( 1. );
randomVolumeSource->SetNumberOfThreads(2); //With 1, it's deterministic
constantVolumeSource->SetOrigin( origin );
constantVolumeSource->SetSpacing( spacing );
constantVolumeSource->SetSize( size );
constantVolumeSource->SetConstant( 0. );
// Projections metadata
origin[0] = -255.;
origin[1] = -255.;
origin[2] = -255.;
#if FAST_TESTS_NO_CHECKS
size[0] = 2;
size[1] = 2;
size[2] = NumberOfProjectionImages;
spacing[0] = 504.;
spacing[1] = 504.;
spacing[2] = 504.;
#else
size[0] = 64;
size[1] = 64;
size[2] = NumberOfProjectionImages;
spacing[0] = 8.;
spacing[1] = 8.;
spacing[2] = 8.;
#endif
randomProjectionsSource->SetOrigin( origin );
randomProjectionsSource->SetSpacing( spacing );
randomProjectionsSource->SetSize( size );
randomProjectionsSource->SetMin( 0. );
randomProjectionsSource->SetMax( 100. );
randomProjectionsSource->SetNumberOfThreads(2); //With 1, it's deterministic
constantProjectionsSource->SetOrigin( origin );
constantProjectionsSource->SetSpacing( spacing );
constantProjectionsSource->SetSize( size );
constantProjectionsSource->SetConstant( 0. );
// Update all sources
TRY_AND_EXIT_ON_ITK_EXCEPTION( randomVolumeSource->Update() );
TRY_AND_EXIT_ON_ITK_EXCEPTION( constantVolumeSource->Update() );
TRY_AND_EXIT_ON_ITK_EXCEPTION( randomProjectionsSource->Update() );
TRY_AND_EXIT_ON_ITK_EXCEPTION( constantProjectionsSource->Update() );
// Geometry object
typedef rtk::ThreeDCircularProjectionGeometry GeometryType;
GeometryType::Pointer geometry = GeometryType::New();
for(unsigned int noProj=0; noProj<NumberOfProjectionImages; noProj++)
geometry->AddProjection(600., 1200., noProj*360./NumberOfProjectionImages);
for (unsigned int panel = 0; panel<2; panel++)
{
if (panel==0)
std::cout << "\n\n****** Testing with flat panel ******" << std::endl;
else
{
std::cout << "\n\n****** Testing with cylindrical panel ******" << std::endl;
geometry->SetRadiusCylindricalDetector(200);
}
std::cout << "\n\n****** Joseph Forward projector ******" << std::endl;
typedef rtk::JosephForwardProjectionImageFilter<OutputImageType, OutputImageType> JosephForwardProjectorType;
JosephForwardProjectorType::Pointer fw = JosephForwardProjectorType::New();
fw->SetInput(0, constantProjectionsSource->GetOutput());
fw->SetInput(1, randomVolumeSource->GetOutput());
fw->SetGeometry( geometry );
TRY_AND_EXIT_ON_ITK_EXCEPTION( fw->Update() );
std::cout << "\n\n****** Joseph Back projector ******" << std::endl;
typedef rtk::JosephBackProjectionImageFilter<OutputImageType, OutputImageType> JosephBackProjectorType;
JosephBackProjectorType::Pointer bp = JosephBackProjectorType::New();
bp->SetInput(0, constantVolumeSource->GetOutput());
bp->SetInput(1, randomProjectionsSource->GetOutput());
bp->SetGeometry( geometry.GetPointer() );
TRY_AND_EXIT_ON_ITK_EXCEPTION( bp->Update() );
CheckScalarProducts<OutputImageType, OutputImageType>(randomVolumeSource->GetOutput(), bp->GetOutput(), randomProjectionsSource->GetOutput(), fw->GetOutput());
std::cout << "\n\nTest PASSED! " << std::endl;
#ifdef USE_CUDA
std::cout << "\n\n****** Cuda Ray Cast Forward projector ******" << std::endl;
typedef rtk::CudaForwardProjectionImageFilter<OutputImageType, OutputImageType> CudaForwardProjectorType;
CudaForwardProjectorType::Pointer cfw = CudaForwardProjectorType::New();
cfw->SetInput(0, constantProjectionsSource->GetOutput());
cfw->SetInput(1, randomVolumeSource->GetOutput());
cfw->SetGeometry( geometry );
TRY_AND_EXIT_ON_ITK_EXCEPTION( cfw->Update() );
std::cout << "\n\n****** Cuda Ray Cast Back projector ******" << std::endl;
typedef rtk::CudaRayCastBackProjectionImageFilter CudaRayCastBackProjectorType;
CudaRayCastBackProjectorType::Pointer cbp = CudaRayCastBackProjectorType::New();
cbp->SetInput(0, constantVolumeSource->GetOutput());
cbp->SetInput(1, randomProjectionsSource->GetOutput());
cbp->SetGeometry( geometry.GetPointer() );
cbp->SetNormalize(false);
TRY_AND_EXIT_ON_ITK_EXCEPTION( cbp->Update() );
CheckScalarProducts<OutputImageType, OutputImageType>(randomVolumeSource->GetOutput(), cbp->GetOutput(), randomProjectionsSource->GetOutput(), cfw->GetOutput());
std::cout << "\n\nTest PASSED! " << std::endl;
#endif
}
return EXIT_SUCCESS;
}
| 36.880208 | 167 | 0.71473 | cyrilmory |
1ea6dfec202cda0320e555a1851f1e84df6b819f | 1,041 | cpp | C++ | userland/libraries/libc/stdio/sprintf.cpp | pro-hacker64/pranaOS | 01e5f0ba7fc7b561a08ba60ea6b3890202ac97c7 | [
"BSD-2-Clause"
] | null | null | null | userland/libraries/libc/stdio/sprintf.cpp | pro-hacker64/pranaOS | 01e5f0ba7fc7b561a08ba60ea6b3890202ac97c7 | [
"BSD-2-Clause"
] | null | null | null | userland/libraries/libc/stdio/sprintf.cpp | pro-hacker64/pranaOS | 01e5f0ba7fc7b561a08ba60ea6b3890202ac97c7 | [
"BSD-2-Clause"
] | null | null | null | /*
* Copyright (c) 2021, krishpranav
*
* SPDX-License-Identifier: BSD-2-Clause
*/
// includes
#include <pranaos/Printf.h>
#include <stdio.h>
#include <string.h>
void string_printf_append(printf_info_t *info, char c)
{
if (info->allocated == -1)
{
strapd((char *)info->output, c);
}
else
{
strnapd((char *)info->output, c, info->allocated);
}
}
int snprintf(char *s, size_t n, const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
int result = vsnprintf(s, n, fmt, va);
va_end(va);
return result;
}
int vsnprintf(char *s, size_t n, const char *fmt, va_list va)
{
if (n == 0)
{
return 0;
}
printf_info_t info = {};
info.format = fmt;
info.append = string_printf_append;
info.output = s;
info.allocated = n;
s[0] = '\0';
return __printf(&info, va);
}
int sprintf(char *s, const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
int result = vsnprintf(s, 65535, fmt, va);
va_end(va);
return result;
} | 16.265625 | 61 | 0.574448 | pro-hacker64 |
1ea8c1d5a25a411dbb41f9daa147ff59cefd8613 | 39,480 | cpp | C++ | SOLVER/src/preloop/physics/material/Material.cpp | kuangdai/AxiSEM3D | fd9da14e9107783e3b07b936c67af2412146e099 | [
"MIT"
] | 17 | 2016-12-16T03:13:57.000Z | 2021-12-15T01:56:45.000Z | SOLVER/src/preloop/physics/material/Material.cpp | syzeng-duduxi/AxiSEM3D | fd9da14e9107783e3b07b936c67af2412146e099 | [
"MIT"
] | 6 | 2018-01-15T17:17:20.000Z | 2020-03-18T09:53:58.000Z | SOLVER/src/preloop/physics/material/Material.cpp | syzeng-duduxi/AxiSEM3D | fd9da14e9107783e3b07b936c67af2412146e099 | [
"MIT"
] | 19 | 2016-12-28T16:55:00.000Z | 2021-06-23T01:02:16.000Z | // Material.cpp
// created by Kuangdai on 17-May-2016
// 3D seismic material properties
#include "Material.h"
#include "Quad.h"
#include "ExodusModel.h"
#include "SpectralConstants.h"
#include "Volumetric3D.h"
#include "XMath.h"
#include "Relabelling.h"
#include "Acoustic1D.h"
#include "Acoustic3D.h"
#include "AttBuilder.h"
#include "Attenuation1D.h"
#include "Attenuation3D.h"
#include "Isotropic1D.h"
#include "Isotropic3D.h"
#include "TransverselyIsotropic1D.h"
#include "TransverselyIsotropic3D.h"
#include "Anisotropic1D.h"
#include "Anisotropic3D.h"
#include "Geodesy.h"
#include <boost/algorithm/string.hpp>
#include "SlicePlot.h"
Material::Material(const Quad *myQuad, const ExodusModel &exModel): mMyQuad(myQuad) {
// read Exodus model
int quadTag = mMyQuad->getQuadTag();
if (exModel.isIsotropic()) {
for (int i = 0; i < 4; i++) {
mVpv1D(i) = mVph1D(i) = exModel.getElementalVariables("VP_" + std::to_string(i), quadTag);
mVsv1D(i) = mVsh1D(i) = exModel.getElementalVariables("VS_" + std::to_string(i), quadTag);
mEta1D(i) = 1.;
}
} else {
for (int i = 0; i < 4; i++) {
mVpv1D(i) = exModel.getElementalVariables("VPV_" + std::to_string(i), quadTag);
mVph1D(i) = exModel.getElementalVariables("VPH_" + std::to_string(i), quadTag);
mVsv1D(i) = exModel.getElementalVariables("VSV_" + std::to_string(i), quadTag);
mVsh1D(i) = exModel.getElementalVariables("VSH_" + std::to_string(i), quadTag);
mEta1D(i) = exModel.getElementalVariables("ETA_" + std::to_string(i), quadTag);
}
}
for (int i = 0; i < 4; i++) {
mRho1D(i) = exModel.getElementalVariables("RHO_" + std::to_string(i), quadTag);
}
if (exModel.hasAttenuation()) {
for (int i = 0; i < 4; i++) {
mQkp1D(i) = exModel.getElementalVariables("QKAPPA_" + std::to_string(i), quadTag);
mQmu1D(i) = exModel.getElementalVariables("QMU_" + std::to_string(i), quadTag);
}
} else {
mQkp1D.setZero();
mQmu1D.setZero();
}
// initialize 3D properties with 1D reference
int Nr = mMyQuad->getNr();
mVpv3D = RDMatXN::Zero(1, nPE);
mVph3D = RDMatXN::Zero(1, nPE);
mVsv3D = RDMatXN::Zero(1, nPE);
mVsh3D = RDMatXN::Zero(1, nPE);
mRho3D = RDMatXN::Zero(1, nPE);
mEta3D = RDMatXN::Zero(1, nPE);
mQkp3D = RDMatXN::Zero(1, nPE);
mQmu3D = RDMatXN::Zero(1, nPE);
for (int ipol = 0; ipol <= nPol; ipol++) {
for (int jpol = 0; jpol <= nPol; jpol++) {
int ipnt = ipol * nPntEdge + jpol;
const RDCol2 &xieta = SpectralConstants::getXiEta(ipol, jpol, mMyQuad->isAxial());
// fill with 1D
mVpv3D.col(ipnt).fill(Mapping::interpolate(mVpv1D, xieta));
mVph3D.col(ipnt).fill(Mapping::interpolate(mVph1D, xieta));
mVsv3D.col(ipnt).fill(Mapping::interpolate(mVsv1D, xieta));
mVsh3D.col(ipnt).fill(Mapping::interpolate(mVsh1D, xieta));
mRho3D.col(ipnt).fill(Mapping::interpolate(mRho1D, xieta));
mEta3D.col(ipnt).fill(Mapping::interpolate(mEta1D, xieta));
mQkp3D.col(ipnt).fill(Mapping::interpolate(mQkp1D, xieta));
mQmu3D.col(ipnt).fill(Mapping::interpolate(mQmu1D, xieta));
// rho for mass
int NrP = mMyQuad->getPointNr(ipol, jpol);
mRhoMass3D[ipnt] = RDColX::Constant(NrP, mRho3D.col(ipnt)(0));
mVpFluid3D[ipnt] = RDColX::Constant(NrP, mVpv3D.col(ipnt)(0));
}
}
}
void Material::addVolumetric3D(const std::vector<Volumetric3D *> &m3D,
double srcLat, double srcLon, double srcDep, double phi2D) {
if (m3D.size() == 0) {
return;
}
// pointers for fast access to material matrices
std::vector<RDRow4 *> prop1DPtr = {&mVpv1D, &mVph1D, &mVsv1D, &mVsh1D, &mRho1D, &mEta1D, &mQkp1D, &mQmu1D,
&mVpv1D, &mVsv1D, // these two take no other effect than occupying the slots
&mC11_1D, &mC12_1D, &mC13_1D, &mC14_1D, &mC15_1D, &mC16_1D,
&mC22_1D, &mC23_1D, &mC24_1D, &mC25_1D, &mC26_1D,
&mC33_1D, &mC34_1D, &mC35_1D, &mC36_1D,
&mC44_1D, &mC45_1D, &mC46_1D,
&mC55_1D, &mC56_1D,
&mC66_1D
};
std::vector<RDMatXN *> prop3DPtr = {&mVpv3D, &mVph3D, &mVsv3D, &mVsh3D, &mRho3D, &mEta3D, &mQkp3D, &mQmu3D,
&mVpv3D, &mVsv3D, // these two take no other effect than occupying the slots
&mC11_3D, &mC12_3D, &mC13_3D, &mC14_3D, &mC15_3D, &mC16_3D,
&mC22_3D, &mC23_3D, &mC24_3D, &mC25_3D, &mC26_3D,
&mC33_3D, &mC34_3D, &mC35_3D, &mC36_3D,
&mC44_3D, &mC45_3D, &mC46_3D,
&mC55_3D, &mC56_3D,
&mC66_3D
};
// radius at element center
double rElemCenter = mMyQuad->computeCenterRadius();
// read 3D model
int Nr = mMyQuad->getNr();
for (int ipol = 0; ipol <= nPol; ipol++) {
for (int jpol = 0; jpol <= nPol; jpol++) {
// geographic oordinates of cardinal points
const RDCol2 &xieta = SpectralConstants::getXiEta(ipol, jpol, mMyQuad->isAxial());
const RDMatX3 &rtp = mMyQuad->computeGeocentricGlobal(srcLat, srcLon, srcDep, xieta, Nr, phi2D);
int ipnt = ipol * nPntEdge + jpol;
for (int alpha = 0; alpha < Nr; alpha++) {
double r = rtp(alpha, 0);
double t = rtp(alpha, 1);
double p = rtp(alpha, 2);
for (const auto &model: m3D) {
if (mMyQuad->isFluid() && !model->makeFluid3D()) {
continue;
}
std::vector<Volumetric3D::MaterialProperty> properties;
std::vector<Volumetric3D::MaterialRefType> refTypes;
std::vector<double> values;
if (!model->get3dProperties(r, t, p, rElemCenter, properties, refTypes, values)) {
// point (r, t, p) not in model range
continue;
}
if (!_3Dprepared()) {
prepare3D();
}
// deal with VP and VS
std::vector<Volumetric3D::MaterialProperty> propertiesTIso;
std::vector<Volumetric3D::MaterialRefType> refTypesTIso;
std::vector<double> valuesTIso;
for (int iprop = 0; iprop < properties.size(); iprop++) {
if (properties[iprop] == Volumetric3D::MaterialProperty::VP) {
propertiesTIso.push_back(Volumetric3D::MaterialProperty::VPV);
propertiesTIso.push_back(Volumetric3D::MaterialProperty::VPH);
refTypesTIso.push_back(refTypes[iprop]);
refTypesTIso.push_back(refTypes[iprop]);
valuesTIso.push_back(values[iprop]);
valuesTIso.push_back(values[iprop]);
} else if (properties[iprop] == Volumetric3D::MaterialProperty::VS) {
propertiesTIso.push_back(Volumetric3D::MaterialProperty::VSV);
propertiesTIso.push_back(Volumetric3D::MaterialProperty::VSH);
refTypesTIso.push_back(refTypes[iprop]);
refTypesTIso.push_back(refTypes[iprop]);
valuesTIso.push_back(values[iprop]);
valuesTIso.push_back(values[iprop]);
} else {
propertiesTIso.push_back(properties[iprop]);
refTypesTIso.push_back(refTypes[iprop]);
valuesTIso.push_back(values[iprop]);
}
}
// change values
for (int iprop = 0; iprop < propertiesTIso.size(); iprop++) {
// initialize anisotropy
if (!mFullAniso && propertiesTIso[iprop] >= Volumetric3D::MaterialProperty::C11) {
initAniso();
}
// // check
// if (mFullAniso) {
// if (propertiesTIso[iprop] <= Volumetric3D::MaterialProperty::ANIS_ETA) {
// throw std::runtime_error("Material::addVolumetric3D || "
// "Velocity, density and eta can no longer be changed once "
// "full anisotropy has been activated.");
// }
// }
RDRow4 &row1D = *prop1DPtr[propertiesTIso[iprop]];
RDMatXN &mat3D = *prop3DPtr[propertiesTIso[iprop]];
Volumetric3D::MaterialRefType ref_type = refTypesTIso[iprop];
double value3D = valuesTIso[iprop];
if (ref_type == Volumetric3D::MaterialRefType::Absolute) {
mat3D(alpha, ipnt) = value3D;
} else if (ref_type == Volumetric3D::MaterialRefType::Reference1D) {
double ref1D = Mapping::interpolate(row1D, xieta);
mat3D(alpha, ipnt) = ref1D * (1. + value3D);
} else if (ref_type == Volumetric3D::MaterialRefType::Reference3D) {
mat3D(alpha, ipnt) *= 1. + value3D;
} else {
double ref1D = Mapping::interpolate(row1D, xieta);
mat3D(alpha, ipnt) = (mat3D(alpha, ipnt) - ref1D) * (1. + value3D) + ref1D;
}
}
}
}
}
}
// form mass point sampling
if (_3Dprepared()) {
for (int ipol = 0; ipol <= nPol; ipol++) {
for (int jpol = 0; jpol <= nPol; jpol++) {
int ipnt = ipol * nPntEdge + jpol;
int nr_mass = mMyQuad->getPointNr(ipol, jpol);
mRhoMass3D[ipnt] = XMath::linearResampling(nr_mass, mRho3D.col(ipnt));
mVpFluid3D[ipnt] = XMath::linearResampling(nr_mass, mVpv3D.col(ipnt));
}
}
}
// rotate anisotropy from geographic to source-centred
if (mFullAniso) {
rotateAniso(srcLat, srcLon, srcDep);
}
}
arPP_RDColX Material::computeElementalMass() const {
arPP_RDColX mass, J;
// Jacobian of topography
if (mMyQuad->hasRelabelling()) {
J = mMyQuad->getRelabelling().getMassJacobian();
} else {
J = mRhoMass3D; // just to use the size
for (int ipnt = 0; ipnt < nPntElem; ipnt++) {
J[ipnt].setOnes();
}
}
// general mass term
const RDRowN &iFact = mMyQuad->getIntegralFactor();
for (int ipnt = 0; ipnt < nPntElem; ipnt++) {
if (mMyQuad->isFluid()) {
mass[ipnt] = (mRhoMass3D[ipnt].array() * mVpFluid3D[ipnt].array().pow(2.)).pow(-1.).matrix();
} else {
mass[ipnt] = mRhoMass3D[ipnt];
}
mass[ipnt].array() *= iFact(ipnt) * J[ipnt].array();
}
return mass;
}
Acoustic *Material::createAcoustic(bool elem1D) const {
const RDRowN &iFact = mMyQuad->getIntegralFactor();
RDMatXN fluidK;
if (_3Dprepared()) {
fluidK = mRho3D.array().pow(-1.);
} else {
fluidK = mRho3D.replicate(mMyQuad->getNr(), 1).array().pow(-1.);
}
for (int ipnt = 0; ipnt < nPntElem; ipnt++) {
fluidK.col(ipnt) *= iFact(ipnt);
}
if (mMyQuad->hasRelabelling()) {
fluidK.array() *= mMyQuad->getRelabelling().getStiffJacobian().array();
}
if (elem1D) {
RDMatPP kstruct;
XMath::structuredUseFirstRow(fluidK, kstruct);
return new Acoustic1D(kstruct.cast<Real>());
} else {
return new Acoustic3D(fluidK.cast<Real>());
}
}
Elastic *Material::createElastic(bool elem1D, const AttBuilder *attBuild) const {
if (mFullAniso) {
return createElasticAniso(elem1D, attBuild);
}
// elasticity tensor
const RDRowN &iFact = mMyQuad->getIntegralFactor();
RDMatXN vpv3D, vph3D;
RDMatXN vsv3D, vsh3D;
RDMatXN rho3D;
RDMatXN eta3D;
RDMatXN qkp3D, qmu3D;
if (_3Dprepared()) {
vpv3D = mVpv3D;
vph3D = mVph3D;
vsv3D = mVsv3D;
vsh3D = mVsh3D;
rho3D = mRho3D;
eta3D = mEta3D;
qkp3D = mQkp3D;
qmu3D = mQmu3D;
} else {
vpv3D = mVpv3D.replicate(mMyQuad->getNr(), 1);
vph3D = mVph3D.replicate(mMyQuad->getNr(), 1);
vsv3D = mVsv3D.replicate(mMyQuad->getNr(), 1);
vsh3D = mVsh3D.replicate(mMyQuad->getNr(), 1);
rho3D = mRho3D.replicate(mMyQuad->getNr(), 1);
eta3D = mEta3D.replicate(mMyQuad->getNr(), 1);
qkp3D = mQkp3D.replicate(mMyQuad->getNr(), 1);
qmu3D = mQmu3D.replicate(mMyQuad->getNr(), 1);
}
RDMatXN A(rho3D), C(rho3D), F(rho3D), L(rho3D), N(rho3D);
for (int ipnt = 0; ipnt < nPntElem; ipnt++) {
// A C L N
A.col(ipnt).array() *= vph3D.col(ipnt).array().pow(2.) * iFact(ipnt);
C.col(ipnt).array() *= vpv3D.col(ipnt).array().pow(2.) * iFact(ipnt);
L.col(ipnt).array() *= vsv3D.col(ipnt).array().pow(2.) * iFact(ipnt);
N.col(ipnt).array() *= vsh3D.col(ipnt).array().pow(2.) * iFact(ipnt);
}
// F
F = eta3D.schur(A - 2. * L);
// must do relabelling before attenuation
if (mMyQuad->hasRelabelling()) {
const RDMatXN &J = mMyQuad->getRelabelling().getStiffJacobian();
A = A.schur(J);
C = C.schur(J);
F = F.schur(J);
L = L.schur(J);
N = N.schur(J);
}
// attenuation
Attenuation1D *att1D = 0;
Attenuation3D *att3D = 0;
if (attBuild) {
// Voigt average
RDMatXN kappa = (4. * A + C + 4. * F - 4. * N) / 9.;
RDMatXN mu = (A + C - 2. * F + 6. * L + 5. * N) / 15.;
A -= (kappa + 4. / 3. * mu);
C -= (kappa + 4. / 3. * mu);
F -= (kappa - 2. / 3. * mu);
L -= mu;
N -= mu;
if (elem1D) {
att1D = attBuild->createAttenuation1D(qkp3D, qmu3D, kappa, mu, mMyQuad);
} else {
att3D = attBuild->createAttenuation3D(qkp3D, qmu3D, kappa, mu, mMyQuad);
}
A += (kappa + 4. / 3. * mu);
C += (kappa + 4. / 3. * mu);
F += (kappa - 2. / 3. * mu);
L += mu;
N += mu;
}
// Elastic pointers
if (elem1D) {
RDMatPP A0, C0, F0, L0, N0;
XMath::structuredUseFirstRow(A, A0);
XMath::structuredUseFirstRow(C, C0);
XMath::structuredUseFirstRow(F, F0);
XMath::structuredUseFirstRow(L, L0);
XMath::structuredUseFirstRow(N, N0);
if (isIsotropic()) {
return new Isotropic1D(F0.cast<Real>(), L0.cast<Real>(), att1D);
} else {
return new TransverselyIsotropic1D(A0.cast<Real>(), C0.cast<Real>(),
F0.cast<Real>(), L0.cast<Real>(), N0.cast<Real>(), att1D);
}
} else {
if (isIsotropic()) {
return new Isotropic3D(F.cast<Real>(), L.cast<Real>(), att3D);
} else {
return new TransverselyIsotropic3D(A.cast<Real>(), C.cast<Real>(),
F.cast<Real>(), L.cast<Real>(), N.cast<Real>(), att3D);
}
}
}
Elastic *Material::createElasticAniso(bool elem1D, const AttBuilder *attBuild) const {
// elasticity tensor
const RDRowN &iFact = mMyQuad->getIntegralFactor();
RDMatXN C11_3D(mC11_3D), C12_3D(mC12_3D), C13_3D(mC13_3D), C14_3D(mC14_3D), C15_3D(mC15_3D), C16_3D(mC16_3D);
RDMatXN C22_3D(mC22_3D), C23_3D(mC23_3D), C24_3D(mC24_3D), C25_3D(mC25_3D), C26_3D(mC26_3D);
RDMatXN C33_3D(mC33_3D), C34_3D(mC34_3D), C35_3D(mC35_3D), C36_3D(mC36_3D);
RDMatXN C44_3D(mC44_3D), C45_3D(mC45_3D), C46_3D(mC46_3D);
RDMatXN C55_3D(mC55_3D), C56_3D(mC56_3D);
RDMatXN C66_3D(mC66_3D);
for (int ipnt = 0; ipnt < nPntElem; ipnt++) {
C11_3D.col(ipnt) *= iFact(ipnt);
C12_3D.col(ipnt) *= iFact(ipnt);
C13_3D.col(ipnt) *= iFact(ipnt);
C14_3D.col(ipnt) *= iFact(ipnt);
C15_3D.col(ipnt) *= iFact(ipnt);
C16_3D.col(ipnt) *= iFact(ipnt);
C22_3D.col(ipnt) *= iFact(ipnt);
C23_3D.col(ipnt) *= iFact(ipnt);
C24_3D.col(ipnt) *= iFact(ipnt);
C25_3D.col(ipnt) *= iFact(ipnt);
C26_3D.col(ipnt) *= iFact(ipnt);
C33_3D.col(ipnt) *= iFact(ipnt);
C34_3D.col(ipnt) *= iFact(ipnt);
C35_3D.col(ipnt) *= iFact(ipnt);
C36_3D.col(ipnt) *= iFact(ipnt);
C44_3D.col(ipnt) *= iFact(ipnt);
C45_3D.col(ipnt) *= iFact(ipnt);
C46_3D.col(ipnt) *= iFact(ipnt);
C55_3D.col(ipnt) *= iFact(ipnt);
C56_3D.col(ipnt) *= iFact(ipnt);
C66_3D.col(ipnt) *= iFact(ipnt);
}
// must do relabelling before attenuation
if (mMyQuad->hasRelabelling()) {
const RDMatXN &J = mMyQuad->getRelabelling().getStiffJacobian();
C11_3D = C11_3D.schur(J);
C12_3D = C12_3D.schur(J);
C13_3D = C13_3D.schur(J);
C14_3D = C14_3D.schur(J);
C15_3D = C15_3D.schur(J);
C16_3D = C16_3D.schur(J);
C22_3D = C22_3D.schur(J);
C23_3D = C23_3D.schur(J);
C24_3D = C24_3D.schur(J);
C25_3D = C25_3D.schur(J);
C26_3D = C26_3D.schur(J);
C33_3D = C33_3D.schur(J);
C34_3D = C34_3D.schur(J);
C35_3D = C35_3D.schur(J);
C36_3D = C36_3D.schur(J);
C44_3D = C44_3D.schur(J);
C45_3D = C45_3D.schur(J);
C46_3D = C46_3D.schur(J);
C55_3D = C55_3D.schur(J);
C56_3D = C56_3D.schur(J);
C66_3D = C66_3D.schur(J);
}
// attenuation
Attenuation1D *att1D = 0;
Attenuation3D *att3D = 0;
if (attBuild) {
// Voigt average
// https://materialsproject.org/wiki/index.php/Elasticity_calculations
RDMatXN kappa = (C11_3D + C22_3D + C33_3D + 2. * (C12_3D + C23_3D + C13_3D)) / 9.;
RDMatXN mu = (C11_3D + C22_3D + C33_3D - (C12_3D + C23_3D + C13_3D) + 3. * (C44_3D + C55_3D + C66_3D)) / 15.;
C11_3D -= (kappa + 4. / 3. * mu);
C22_3D -= (kappa + 4. / 3. * mu);
C33_3D -= (kappa + 4. / 3. * mu);
C12_3D -= (kappa - 2. / 3. * mu);
C23_3D -= (kappa - 2. / 3. * mu);
C13_3D -= (kappa - 2. / 3. * mu);
C44_3D -= mu;
C55_3D -= mu;
C66_3D -= mu;
if (elem1D) {
att1D = attBuild->createAttenuation1D(mQkp3D, mQmu3D, kappa, mu, mMyQuad);
} else {
att3D = attBuild->createAttenuation3D(mQkp3D, mQmu3D, kappa, mu, mMyQuad);
}
C11_3D += (kappa + 4. / 3. * mu);
C22_3D += (kappa + 4. / 3. * mu);
C33_3D += (kappa + 4. / 3. * mu);
C12_3D += (kappa - 2. / 3. * mu);
C23_3D += (kappa - 2. / 3. * mu);
C13_3D += (kappa - 2. / 3. * mu);
C44_3D += mu;
C55_3D += mu;
C66_3D += mu;
}
// Elastic pointers
if (elem1D) {
RDMatPP C11_1D, C12_1D, C13_1D, C14_1D, C15_1D, C16_1D;
RDMatPP C22_1D, C23_1D, C24_1D, C25_1D, C26_1D;
RDMatPP C33_1D, C34_1D, C35_1D, C36_1D;
RDMatPP C44_1D, C45_1D, C46_1D;
RDMatPP C55_1D, C56_1D;
RDMatPP C66_1D;
XMath::structuredUseFirstRow(C11_3D, C11_1D);
XMath::structuredUseFirstRow(C12_3D, C12_1D);
XMath::structuredUseFirstRow(C13_3D, C13_1D);
XMath::structuredUseFirstRow(C14_3D, C14_1D);
XMath::structuredUseFirstRow(C15_3D, C15_1D);
XMath::structuredUseFirstRow(C16_3D, C16_1D);
XMath::structuredUseFirstRow(C22_3D, C22_1D);
XMath::structuredUseFirstRow(C23_3D, C23_1D);
XMath::structuredUseFirstRow(C24_3D, C24_1D);
XMath::structuredUseFirstRow(C25_3D, C25_1D);
XMath::structuredUseFirstRow(C26_3D, C26_1D);
XMath::structuredUseFirstRow(C33_3D, C33_1D);
XMath::structuredUseFirstRow(C34_3D, C34_1D);
XMath::structuredUseFirstRow(C35_3D, C35_1D);
XMath::structuredUseFirstRow(C36_3D, C36_1D);
XMath::structuredUseFirstRow(C44_3D, C44_1D);
XMath::structuredUseFirstRow(C45_3D, C45_1D);
XMath::structuredUseFirstRow(C46_3D, C46_1D);
XMath::structuredUseFirstRow(C55_3D, C55_1D);
XMath::structuredUseFirstRow(C56_3D, C56_1D);
XMath::structuredUseFirstRow(C66_3D, C66_1D);
return new Anisotropic1D(
C11_1D.cast<Real>(), C12_1D.cast<Real>(), C13_1D.cast<Real>(), C14_1D.cast<Real>(), C15_1D.cast<Real>(), C16_1D.cast<Real>(),
C22_1D.cast<Real>(), C23_1D.cast<Real>(), C24_1D.cast<Real>(), C25_1D.cast<Real>(), C26_1D.cast<Real>(),
C33_1D.cast<Real>(), C34_1D.cast<Real>(), C35_1D.cast<Real>(), C36_1D.cast<Real>(),
C44_1D.cast<Real>(), C45_1D.cast<Real>(), C46_1D.cast<Real>(),
C55_1D.cast<Real>(), C56_1D.cast<Real>(),
C66_1D.cast<Real>(),
att1D);
} else {
return new Anisotropic3D(
C11_3D.cast<Real>(), C12_3D.cast<Real>(), C13_3D.cast<Real>(), C14_3D.cast<Real>(), C15_3D.cast<Real>(), C16_3D.cast<Real>(),
C22_3D.cast<Real>(), C23_3D.cast<Real>(), C24_3D.cast<Real>(), C25_3D.cast<Real>(), C26_3D.cast<Real>(),
C33_3D.cast<Real>(), C34_3D.cast<Real>(), C35_3D.cast<Real>(), C36_3D.cast<Real>(),
C44_3D.cast<Real>(), C45_3D.cast<Real>(), C46_3D.cast<Real>(),
C55_3D.cast<Real>(), C56_3D.cast<Real>(),
C66_3D.cast<Real>(),
att3D);
}
}
double Material::getVMaxRef() const {
return std::max(mVph1D.maxCoeff(), mVpv1D.maxCoeff());
}
RDColX Material::getVMax() const {
RDMatXN vpv3D, vph3D;
if (_3Dprepared()) {
vpv3D = mVpv3D;
vph3D = mVph3D;
} else {
vpv3D = mVpv3D.replicate(mMyQuad->getNr(), 1);
vph3D = mVph3D.replicate(mMyQuad->getNr(), 1);
}
const RDColX &vpvMax = vpv3D.rowwise().maxCoeff();
const RDColX &vphMax = vph3D.rowwise().maxCoeff();
return (vpvMax.array().max(vphMax.array())).matrix();
}
bool Material::isFluidPar1D() const {
return XMath::equalRows(mVpv3D) && XMath::equalRows(mRho3D);
}
bool Material::isSolidPar1D(bool attenuation) const {
bool result = false;
if (mFullAniso) {
result = XMath::equalRows(mC11_3D, 1e-7) && XMath::equalRows(mC12_3D, 1e-7) && XMath::equalRows(mC13_3D, 1e-7) && XMath::equalRows(mC14_3D, 1e-7) && XMath::equalRows(mC15_3D, 1e-7) && XMath::equalRows(mC16_3D, 1e-7) &&
XMath::equalRows(mC22_3D, 1e-7) && XMath::equalRows(mC23_3D, 1e-7) && XMath::equalRows(mC24_3D, 1e-7) && XMath::equalRows(mC25_3D, 1e-7) && XMath::equalRows(mC26_3D, 1e-7) &&
XMath::equalRows(mC33_3D, 1e-7) && XMath::equalRows(mC34_3D, 1e-7) && XMath::equalRows(mC35_3D, 1e-7) && XMath::equalRows(mC36_3D, 1e-7) &&
XMath::equalRows(mC44_3D, 1e-7) && XMath::equalRows(mC45_3D, 1e-7) && XMath::equalRows(mC46_3D, 1e-7) &&
XMath::equalRows(mC55_3D, 1e-7) && XMath::equalRows(mC56_3D, 1e-7) &&
XMath::equalRows(mC66_3D, 1e-7) &&
XMath::equalRows(mRho3D);
} else {
result = XMath::equalRows(mVpv3D) && XMath::equalRows(mVph3D) &&
XMath::equalRows(mVsv3D) && XMath::equalRows(mVsh3D) &&
XMath::equalRows(mRho3D) && XMath::equalRows(mEta3D);
}
if (attenuation) {
result = result && XMath::equalRows(mQkp3D) && XMath::equalRows(mQmu3D);
}
return result;
}
bool Material::isIsotropic() const {
if (mFullAniso) {
return false;
}
return (mVpv3D - mVph3D).norm() < tinyDouble * mVpv3D.norm() &&
(mVsv3D - mVsh3D).norm() < tinyDouble * mVsv3D.norm() &&
(mEta3D - RDMatXN::Ones(mEta3D.rows(), mEta3D.cols())).norm() < tinyDouble;
}
RDMatXN Material::getProperty(const std::string &vname, int refType) {
int Nr = mMyQuad->getNr();
// name
std::string varname = vname;
if (boost::iequals(vname, "vp")) {
varname = "vpv";
}
if (boost::iequals(vname, "vs")) {
varname = "vsv";
}
RDRow4 data1D;
RDMatXN data3D;
if (boost::iequals(varname, "vpv")) {
data1D = mVpv1D;
data3D = mVpv3D;
} else if (boost::iequals(varname, "vsv")) {
data1D = mVsv1D;
data3D = mVsv3D;
} else if (boost::iequals(varname, "vph")) {
data1D = mVph1D;
data3D = mVph3D;
} else if (boost::iequals(varname, "vsh")) {
data1D = mVsh1D;
data3D = mVsh3D;
} else if (boost::iequals(varname, "rho")) {
data1D = mRho1D;
data3D = mRho3D;
} else if (boost::iequals(varname, "eta")) {
data1D = mEta1D;
data3D = mEta3D;
} else if (boost::iequals(varname, "qkappa")) {
data1D = mQkp1D;
data3D = mQkp3D;
} else if (boost::iequals(varname, "qmu")) {
data1D = mQmu1D;
data3D = mQmu3D;
} else if (mFullAniso) {
if (boost::iequals(varname, "c11")) {
data1D = mC11_1D;
data3D = mC11_3D;
} else if (boost::iequals(varname, "c12")) {
data1D = mC12_1D;
data3D = mC12_3D;
} else if (boost::iequals(varname, "c13")) {
data1D = mC13_1D;
data3D = mC13_3D;
} else if (boost::iequals(varname, "c14")) {
data1D = mC14_1D;
data3D = mC14_3D;
} else if (boost::iequals(varname, "c15")) {
data1D = mC15_1D;
data3D = mC15_3D;
} else if (boost::iequals(varname, "c16")) {
data1D = mC16_1D;
data3D = mC16_3D;
} else if (boost::iequals(varname, "c22")) {
data1D = mC22_1D;
data3D = mC22_3D;
} else if (boost::iequals(varname, "c23")) {
data1D = mC23_1D;
data3D = mC23_3D;
} else if (boost::iequals(varname, "c24")) {
data1D = mC24_1D;
data3D = mC24_3D;
} else if (boost::iequals(varname, "c25")) {
data1D = mC25_1D;
data3D = mC25_3D;
} else if (boost::iequals(varname, "c26")) {
data1D = mC26_1D;
data3D = mC26_3D;
} else if (boost::iequals(varname, "c33")) {
data1D = mC33_1D;
data3D = mC33_3D;
} else if (boost::iequals(varname, "c34")) {
data1D = mC34_1D;
data3D = mC34_3D;
} else if (boost::iequals(varname, "c35")) {
data1D = mC35_1D;
data3D = mC35_3D;
} else if (boost::iequals(varname, "c36")) {
data1D = mC36_1D;
data3D = mC36_3D;
} else if (boost::iequals(varname, "c44")) {
data1D = mC44_1D;
data3D = mC44_3D;
} else if (boost::iequals(varname, "c45")) {
data1D = mC45_1D;
data3D = mC45_3D;
} else if (boost::iequals(varname, "c46")) {
data1D = mC46_1D;
data3D = mC46_3D;
} else if (boost::iequals(varname, "c55")) {
data1D = mC55_1D;
data3D = mC55_3D;
} else if (boost::iequals(varname, "c56")) {
data1D = mC56_1D;
data3D = mC56_3D;
} else if (boost::iequals(varname, "c66")) {
data1D = mC66_1D;
data3D = mC66_3D;
}
} else {
throw std::runtime_error("Material::getProperty || Unknown field variable name: " + vname);
}
if (data3D.rows() != Nr) {
data3D = data3D.replicate(Nr, 1);
}
// 3D
if (refType == SlicePlot::PropertyRefTypes::Property3D) {
return data3D;
}
// fill 1D
RDMatXN data1DXN(Nr, nPntElem);
for (int ipol = 0; ipol <= nPol; ipol++) {
for (int jpol = 0; jpol <= nPol; jpol++) {
int ipnt = ipol * nPntEdge + jpol;
const RDCol2 &xieta = SpectralConstants::getXiEta(ipol, jpol, mMyQuad->isAxial());
data1DXN.col(ipnt).fill(Mapping::interpolate(data1D, xieta));
}
}
// 1D
if (refType == SlicePlot::PropertyRefTypes::Property1D) {
return data1DXN;
}
// perturb
RDMatXN data1DBase = data1DXN.array().max(tinyDouble).matrix(); // in fluid, vs = 0
return ((data3D - data1DXN).array() / data1DBase.array()).matrix();
}
void Material::initAniso() {
if (mMyQuad->isFluid()) {
throw std::runtime_error("Material::initAniso || Cannot activate full anisotropy in fluid domain.");
}
// 1D elasticity tensor
RDRow4 A_1D = mRho1D.schur(mVph1D).schur(mVph1D);
RDRow4 C_1D = mRho1D.schur(mVpv1D).schur(mVpv1D);
RDRow4 L_1D = mRho1D.schur(mVsv1D).schur(mVsv1D);
RDRow4 N_1D = mRho1D.schur(mVsh1D).schur(mVsh1D);
RDRow4 F_1D = mEta1D.schur(A_1D - 2. * L_1D);
mC11_1D = mC22_1D = A_1D;
mC33_1D = C_1D;
mC44_1D = mC55_1D = L_1D;
mC66_1D = N_1D;
mC12_1D = A_1D - 2. * N_1D;
mC13_1D = mC23_1D = F_1D;
mC14_1D = mC15_1D = mC16_1D = RDRow4::Zero();
mC24_1D = mC25_1D = mC26_1D = RDRow4::Zero();
mC34_1D = mC35_1D = mC36_1D = RDRow4::Zero();
mC45_1D = mC46_1D = mC56_1D = RDRow4::Zero();
// 3D elasticity tensor
RDMatXN A_3D = mRho3D.schur(mVph3D).schur(mVph3D);
RDMatXN C_3D = mRho3D.schur(mVpv3D).schur(mVpv3D);
RDMatXN L_3D = mRho3D.schur(mVsv3D).schur(mVsv3D);
RDMatXN N_3D = mRho3D.schur(mVsh3D).schur(mVsh3D);
RDMatXN F_3D = mEta3D.schur(A_3D - 2. * L_3D);
mC11_3D = mC22_3D = A_3D;
mC33_3D = C_3D;
mC44_3D = mC55_3D = L_3D;
mC66_3D = N_3D;
mC12_3D = A_3D - 2. * N_3D;
mC13_3D = mC23_3D = F_3D;
mC14_3D = mC15_3D = mC16_3D = RDMatXN::Zero(A_3D.rows(), A_3D.cols());
mC24_3D = mC25_3D = mC26_3D = RDMatXN::Zero(A_3D.rows(), A_3D.cols());
mC34_3D = mC35_3D = mC36_3D = RDMatXN::Zero(A_3D.rows(), A_3D.cols());
mC45_3D = mC46_3D = mC56_3D = RDMatXN::Zero(A_3D.rows(), A_3D.cols());
// initialized
mFullAniso = true;
}
void Material::rotateAniso(double srcLat, double srcLon, double srcDep) {
RDMatXX inCijkl(6, 6);
// 3D
for (int alpha = 0; alpha < mC11_3D.rows(); alpha++) {
// azimuth of the slice
double phi = 2. * pi / mC11_3D.rows() * alpha;
// loop over GLL points
for (int ipol = 0; ipol <= nPol; ipol++) {
for (int jpol = 0; jpol <= nPol; jpol++) {
int ipnt = ipol * nPntEdge + jpol;
inCijkl(1 - 1, 1 - 1) = mC11_3D(alpha, ipnt);
inCijkl(1 - 1, 2 - 1) = mC12_3D(alpha, ipnt);
inCijkl(1 - 1, 3 - 1) = mC13_3D(alpha, ipnt);
inCijkl(1 - 1, 4 - 1) = mC14_3D(alpha, ipnt);
inCijkl(1 - 1, 5 - 1) = mC15_3D(alpha, ipnt);
inCijkl(1 - 1, 6 - 1) = mC16_3D(alpha, ipnt);
inCijkl(2 - 1, 1 - 1) = mC12_3D(alpha, ipnt);
inCijkl(2 - 1, 2 - 1) = mC22_3D(alpha, ipnt);
inCijkl(2 - 1, 3 - 1) = mC23_3D(alpha, ipnt);
inCijkl(2 - 1, 4 - 1) = mC24_3D(alpha, ipnt);
inCijkl(2 - 1, 5 - 1) = mC25_3D(alpha, ipnt);
inCijkl(2 - 1, 6 - 1) = mC26_3D(alpha, ipnt);
inCijkl(3 - 1, 1 - 1) = mC13_3D(alpha, ipnt);
inCijkl(3 - 1, 2 - 1) = mC23_3D(alpha, ipnt);
inCijkl(3 - 1, 3 - 1) = mC33_3D(alpha, ipnt);
inCijkl(3 - 1, 4 - 1) = mC34_3D(alpha, ipnt);
inCijkl(3 - 1, 5 - 1) = mC35_3D(alpha, ipnt);
inCijkl(3 - 1, 6 - 1) = mC36_3D(alpha, ipnt);
inCijkl(4 - 1, 1 - 1) = mC14_3D(alpha, ipnt);
inCijkl(4 - 1, 2 - 1) = mC24_3D(alpha, ipnt);
inCijkl(4 - 1, 3 - 1) = mC34_3D(alpha, ipnt);
inCijkl(4 - 1, 4 - 1) = mC44_3D(alpha, ipnt);
inCijkl(4 - 1, 5 - 1) = mC45_3D(alpha, ipnt);
inCijkl(4 - 1, 6 - 1) = mC46_3D(alpha, ipnt);
inCijkl(5 - 1, 1 - 1) = mC15_3D(alpha, ipnt);
inCijkl(5 - 1, 2 - 1) = mC25_3D(alpha, ipnt);
inCijkl(5 - 1, 3 - 1) = mC35_3D(alpha, ipnt);
inCijkl(5 - 1, 4 - 1) = mC45_3D(alpha, ipnt);
inCijkl(5 - 1, 5 - 1) = mC55_3D(alpha, ipnt);
inCijkl(5 - 1, 6 - 1) = mC56_3D(alpha, ipnt);
inCijkl(6 - 1, 1 - 1) = mC16_3D(alpha, ipnt);
inCijkl(6 - 1, 2 - 1) = mC26_3D(alpha, ipnt);
inCijkl(6 - 1, 3 - 1) = mC36_3D(alpha, ipnt);
inCijkl(6 - 1, 4 - 1) = mC46_3D(alpha, ipnt);
inCijkl(6 - 1, 5 - 1) = mC56_3D(alpha, ipnt);
inCijkl(6 - 1, 6 - 1) = mC66_3D(alpha, ipnt);
// compute backazimuth
const RDCol2 &xieta = SpectralConstants::getXiEta(ipol, jpol, mMyQuad->isAxial());
RDCol2 rtheta = Geodesy::rtheta(mMyQuad->mapping(xieta));
RDCol3 rtpS, rtpG;
rtpS(0) = rtheta(0);
rtpS(1) = rtheta(1);
rtpS(2) = phi;
rtpG = Geodesy::rotateSrc2Glob(rtpS, srcLat, srcLon, srcDep);
double recDep = Geodesy::getROuter() - rtheta(0);
double recLat = Geodesy::theta2Lat_d(rtpG(1), recDep);
double recLon = Geodesy::phi2Lon(rtpG(2));
double baz = Geodesy::backAzimuth(srcLat, srcLon, srcDep, recLat, recLon, recDep);
// global => source centred RTZ (theta, phi, r)
const RDMatXX &outCijkl = bondTransformation(inCijkl, 0., 0., -baz);
// by convention, input is in RTZ
// // (r, theta, phi) => (R, T, Z)
// const RDMatXX &RTZ_Cijkl_x = bondTransformation(rtp_Cijkl, 0., 0., pi/2.);
// const RDMatXX &outCijkl = bondTransformation(RTZ_Cijkl_x, pi/2., 0., 0.);
// copy back
mC11_3D(alpha, ipnt) = outCijkl(1 - 1, 1 - 1);
mC12_3D(alpha, ipnt) = outCijkl(1 - 1, 2 - 1);
mC13_3D(alpha, ipnt) = outCijkl(1 - 1, 3 - 1);
mC14_3D(alpha, ipnt) = outCijkl(1 - 1, 4 - 1);
mC15_3D(alpha, ipnt) = outCijkl(1 - 1, 5 - 1);
mC16_3D(alpha, ipnt) = outCijkl(1 - 1, 6 - 1);
mC22_3D(alpha, ipnt) = outCijkl(2 - 1, 2 - 1);
mC23_3D(alpha, ipnt) = outCijkl(2 - 1, 3 - 1);
mC24_3D(alpha, ipnt) = outCijkl(2 - 1, 4 - 1);
mC25_3D(alpha, ipnt) = outCijkl(2 - 1, 5 - 1);
mC26_3D(alpha, ipnt) = outCijkl(2 - 1, 6 - 1);
mC33_3D(alpha, ipnt) = outCijkl(3 - 1, 3 - 1);
mC34_3D(alpha, ipnt) = outCijkl(3 - 1, 4 - 1);
mC35_3D(alpha, ipnt) = outCijkl(3 - 1, 5 - 1);
mC36_3D(alpha, ipnt) = outCijkl(3 - 1, 6 - 1);
mC44_3D(alpha, ipnt) = outCijkl(4 - 1, 4 - 1);
mC45_3D(alpha, ipnt) = outCijkl(4 - 1, 5 - 1);
mC46_3D(alpha, ipnt) = outCijkl(4 - 1, 6 - 1);
mC55_3D(alpha, ipnt) = outCijkl(5 - 1, 5 - 1);
mC56_3D(alpha, ipnt) = outCijkl(5 - 1, 6 - 1);
mC66_3D(alpha, ipnt) = outCijkl(6 - 1, 6 - 1);
}
}
}
}
RDMatXX Material::bondTransformation(RDMatXX inCijkl, double alpha, double beta, double gamma) {
RDMat33 R1, R2, R3, R;
R1 << 1., 0., 0.,
0., cos(alpha), sin(alpha),
0., -sin(alpha), cos(alpha);
R2 << cos(beta), 0., sin(beta),
0., 1., 0.,
-sin(beta), 0, cos(beta);
R3 << cos(gamma), sin(gamma), 0.,
-sin(gamma), cos(gamma), 0.,
0., 0., 1.;
R = R1 * R2 * R3;
RDMat33 K1, K2, K3, K4;
K1.array() = R.array().pow(2.);
K2 << R(0, 1) * R(0, 2), R(0, 2) * R(0, 0), R(0, 0) * R(0, 1),
R(1, 1) * R(1, 2), R(1, 2) * R(1, 0), R(1, 0) * R(1, 1),
R(2, 1) * R(2, 2), R(2, 2) * R(2, 0), R(2, 0) * R(2, 1);
K3 << R(1, 0) * R(2, 0), R(1, 1) * R(2, 1), R(1, 2) * R(2, 2),
R(2, 0) * R(0, 0), R(2, 1) * R(0, 1), R(2, 2) * R(0, 2),
R(0, 0) * R(1, 0), R(0, 1) * R(1, 1), R(0, 2) * R(1, 2);
K4 << R(1, 1) * R(2, 2) + R(1, 2) * R(2, 1),
R(1, 2) * R(2, 0) + R(1, 0) * R(2, 2),
R(1, 0) * R(2, 1) + R(1, 1) * R(2, 0),
R(2, 1) * R(0, 2) + R(2, 2) * R(0, 1),
R(2, 2) * R(0, 0) + R(2, 0) * R(0, 2),
R(2, 0) * R(0, 1) + R(2, 1) * R(0, 0),
R(0, 1) * R(1, 2) + R(0, 2) * R(1, 1),
R(0, 2) * R(1, 0) + R(0, 0) * R(1, 2),
R(0, 0) * R(1, 1) + R(0, 1) * R(1, 0);
RDMatXX K(6, 6);
K.block(0, 0, 3, 3) = K1;
K.block(0, 3, 3, 3) = 2. * K2;
K.block(3, 0, 3, 3) = K3;
K.block(3, 3, 3, 3) = K4;
RDMatXX outCijkl(K * inCijkl * K.transpose());
return outCijkl;
}
void Material::prepare3D() {
int Nr = mMyQuad->getNr();
mVpv3D = RDMatXN::Zero(Nr, nPE);
mVph3D = RDMatXN::Zero(Nr, nPE);
mVsv3D = RDMatXN::Zero(Nr, nPE);
mVsh3D = RDMatXN::Zero(Nr, nPE);
mRho3D = RDMatXN::Zero(Nr, nPE);
mEta3D = RDMatXN::Zero(Nr, nPE);
mQkp3D = RDMatXN::Zero(Nr, nPE);
mQmu3D = RDMatXN::Zero(Nr, nPE);
for (int ipol = 0; ipol <= nPol; ipol++) {
for (int jpol = 0; jpol <= nPol; jpol++) {
int ipnt = ipol * nPntEdge + jpol;
const RDCol2 &xieta = SpectralConstants::getXiEta(ipol, jpol, mMyQuad->isAxial());
// fill with 1D
mVpv3D.col(ipnt).fill(Mapping::interpolate(mVpv1D, xieta));
mVph3D.col(ipnt).fill(Mapping::interpolate(mVph1D, xieta));
mVsv3D.col(ipnt).fill(Mapping::interpolate(mVsv1D, xieta));
mVsh3D.col(ipnt).fill(Mapping::interpolate(mVsh1D, xieta));
mRho3D.col(ipnt).fill(Mapping::interpolate(mRho1D, xieta));
mEta3D.col(ipnt).fill(Mapping::interpolate(mEta1D, xieta));
mQkp3D.col(ipnt).fill(Mapping::interpolate(mQkp1D, xieta));
mQmu3D.col(ipnt).fill(Mapping::interpolate(mQmu1D, xieta));
// rho for mass
int NrP = mMyQuad->getPointNr(ipol, jpol);
mRhoMass3D[ipnt] = RDColX::Constant(NrP, mRho3D.col(ipnt)(0));
mVpFluid3D[ipnt] = RDColX::Constant(NrP, mVpv3D.col(ipnt)(0));
}
}
}
bool Material::_3Dprepared() const {
return mVpv3D.rows() == mMyQuad->getNr();
}
| 42.044728 | 226 | 0.521733 | kuangdai |
1eabf91a314f9702cb7772c950fd43ef7adf4377 | 796 | cc | C++ | content/browser/renderer_host/input/web_input_event_util_posix.cc | hefen1/chromium | 52f0b6830e000ca7c5e9aa19488af85be792cc88 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | content/browser/renderer_host/input/web_input_event_util_posix.cc | hefen1/chromium | 52f0b6830e000ca7c5e9aa19488af85be792cc88 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | content/browser/renderer_host/input/web_input_event_util_posix.cc | hefen1/chromium | 52f0b6830e000ca7c5e9aa19488af85be792cc88 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 2 | 2020-04-04T13:34:56.000Z | 2020-11-04T07:17:52.000Z | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/browser/renderer_host/input/web_input_event_util_posix.h"
namespace content {
blink::WebInputEvent::Modifiers GetLocationModifiersFromWindowsKeyCode(
ui::KeyboardCode key_code) {
switch (key_code) {
case ui::VKEY_LCONTROL:
case ui::VKEY_LSHIFT:
case ui::VKEY_LMENU:
case ui::VKEY_LWIN:
return blink::WebKeyboardEvent::IsLeft;
case ui::VKEY_RCONTROL:
case ui::VKEY_RSHIFT:
case ui::VKEY_RMENU:
case ui::VKEY_RWIN:
return blink::WebKeyboardEvent::IsRight;
default:
return static_cast<blink::WebInputEvent::Modifiers>(0);
}
}
} // namespace content
| 28.428571 | 75 | 0.724874 | hefen1 |
1eb00784a5ef046d2a1e0be6f40b651ff008ce48 | 2,348 | cc | C++ | mindspore/lite/src/ops/populate/v0/full_connection_populate_v0.cc | PowerOlive/mindspore | bda20724a94113cedd12c3ed9083141012da1f15 | [
"Apache-2.0"
] | 3,200 | 2020-02-17T12:45:41.000Z | 2022-03-31T20:21:16.000Z | mindspore/lite/src/ops/populate/v0/full_connection_populate_v0.cc | zimo-geek/mindspore | 665ec683d4af85c71b2a1f0d6829356f2bc0e1ff | [
"Apache-2.0"
] | 176 | 2020-02-12T02:52:11.000Z | 2022-03-28T22:15:55.000Z | mindspore/lite/src/ops/populate/v0/full_connection_populate_v0.cc | zimo-geek/mindspore | 665ec683d4af85c71b2a1f0d6829356f2bc0e1ff | [
"Apache-2.0"
] | 621 | 2020-03-09T01:31:41.000Z | 2022-03-30T03:43:19.000Z | /**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "schema/model_v0_generated.h"
#include "src/ops/populate/populate_register.h"
#include "nnacl/matmul_parameter.h"
namespace mindspore {
namespace lite {
namespace {
OpParameter *PopulateFullconnectionParameter(const void *prim) {
auto *primitive = static_cast<const schema::v0::Primitive *>(prim);
MS_ASSERT(primitive != nullptr);
auto full_connection_prim = primitive->value_as_FullConnection();
if (full_connection_prim == nullptr) {
MS_LOG(ERROR) << "full_connection_prim is nullptr";
return nullptr;
}
auto *matmul_param = reinterpret_cast<MatMulParameter *>(malloc(sizeof(MatMulParameter)));
if (matmul_param == nullptr) {
MS_LOG(ERROR) << "malloc MatMulParameter failed.";
return nullptr;
}
memset(matmul_param, 0, sizeof(MatMulParameter));
matmul_param->op_parameter_.type_ = schema::PrimitiveType_FullConnection;
matmul_param->b_transpose_ = true;
matmul_param->a_transpose_ = false;
matmul_param->has_bias_ = full_connection_prim->hasBias();
if (full_connection_prim->activationType() == schema::v0::ActivationType_RELU) {
matmul_param->act_type_ = ActType_Relu;
} else if (full_connection_prim->activationType() == schema::v0::ActivationType_RELU6) {
matmul_param->act_type_ = ActType_Relu6;
} else {
matmul_param->act_type_ = ActType_No;
}
matmul_param->use_axis_ = full_connection_prim->useAxis();
matmul_param->axis_ = full_connection_prim->axis();
return reinterpret_cast<OpParameter *>(matmul_param);
}
} // namespace
Registry g_fullConnectionV0ParameterRegistry(schema::v0::PrimitiveType_FullConnection, PopulateFullconnectionParameter,
SCHEMA_V0);
} // namespace lite
} // namespace mindspore
| 39.133333 | 119 | 0.741482 | PowerOlive |
1eb07fafc0052579ec61cad976befdf1579188f3 | 7,406 | cpp | C++ | samples/suzanne.cpp | N500/filament | 3073b03d56e43643a04956780359f651a85f618b | [
"Apache-2.0"
] | 13,885 | 2018-08-03T17:46:24.000Z | 2022-03-31T14:26:19.000Z | samples/suzanne.cpp | N500/filament | 3073b03d56e43643a04956780359f651a85f618b | [
"Apache-2.0"
] | 2,298 | 2018-08-04T04:12:01.000Z | 2022-03-31T20:06:25.000Z | samples/suzanne.cpp | N500/filament | 3073b03d56e43643a04956780359f651a85f618b | [
"Apache-2.0"
] | 1,500 | 2018-08-03T23:34:27.000Z | 2022-03-30T13:43:10.000Z | /*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <filament/Engine.h>
#include <filament/IndirectLight.h>
#include <filament/LightManager.h>
#include <filament/Material.h>
#include <filament/RenderableManager.h>
#include <filament/Scene.h>
#include <filament/TextureSampler.h>
#include <filament/TransformManager.h>
#include <filament/View.h>
#include <utils/EntityManager.h>
#include <filameshio/MeshReader.h>
#include <image/KtxBundle.h>
#include <image/KtxUtility.h>
#include <filamentapp/Config.h>
#include <filamentapp/FilamentApp.h>
#include <filamentapp/IBL.h>
#include <getopt/getopt.h>
#include <utils/Path.h>
#include <stb_image.h>
#include <iostream>
#include "generated/resources/resources.h"
#include "generated/resources/monkey.h"
using namespace filament;
using namespace image;
using namespace filament::math;
struct App {
Material* material;
MaterialInstance* materialInstance;
filamesh::MeshReader::Mesh mesh;
mat4f transform;
Texture* albedo;
Texture* normal;
Texture* roughness;
Texture* metallic;
Texture* ao;
};
static const char* IBL_FOLDER = "assets/ibl/lightroom_14b";
static void printUsage(char* name) {
std::string exec_name(utils::Path(name).getName());
std::string usage(
"SHOWCASE renders a Suzanne model with S3TC textures.\n"
"Usage:\n"
" SHOWCASE [options]\n"
"Options:\n"
" --help, -h\n"
" Prints this message\n\n"
" --api, -a\n"
" Specify the backend API: opengl (default), vulkan, or metal\n"
);
const std::string from("SHOWCASE");
for (size_t pos = usage.find(from); pos != std::string::npos; pos = usage.find(from, pos)) {
usage.replace(pos, from.length(), exec_name);
}
std::cout << usage;
}
static int handleCommandLineArguments(int argc, char* argv[], Config* config) {
static constexpr const char* OPTSTR = "ha:";
static const struct option OPTIONS[] = {
{ "help", no_argument, nullptr, 'h' },
{ "api", required_argument, nullptr, 'a' },
{ nullptr, 0, nullptr, 0 }
};
int opt;
int option_index = 0;
while ((opt = getopt_long(argc, argv, OPTSTR, OPTIONS, &option_index)) >= 0) {
std::string arg(optarg ? optarg : "");
switch (opt) {
default:
case 'h':
printUsage(argv[0]);
exit(0);
case 'a':
if (arg == "opengl") {
config->backend = Engine::Backend::OPENGL;
} else if (arg == "vulkan") {
config->backend = Engine::Backend::VULKAN;
} else if (arg == "metal") {
config->backend = Engine::Backend::METAL;
} else {
std::cerr << "Unrecognized backend. Must be 'opengl'|'vulkan'|'metal'.\n";
}
break;
}
}
return optind;
}
static Texture* loadNormalMap(Engine* engine, const uint8_t* normals, size_t nbytes) {
int w, h, n;
unsigned char* data = stbi_load_from_memory(normals, nbytes, &w, &h, &n, 3);
Texture* normalMap = Texture::Builder()
.width(uint32_t(w))
.height(uint32_t(h))
.levels(0xff)
.format(Texture::InternalFormat::RGB8)
.build(*engine);
Texture::PixelBufferDescriptor buffer(data, size_t(w * h * 3),
Texture::Format::RGB, Texture::Type::UBYTE,
(Texture::PixelBufferDescriptor::Callback) &stbi_image_free);
normalMap->setImage(*engine, 0, std::move(buffer));
normalMap->generateMipmaps(*engine);
return normalMap;
}
int main(int argc, char** argv) {
Config config;
config.title = "suzanne";
config.iblDirectory = FilamentApp::getRootAssetsPath() + IBL_FOLDER;
handleCommandLineArguments(argc, argv, &config);
App app;
auto setup = [config, &app](Engine* engine, View* view, Scene* scene) {
auto& tcm = engine->getTransformManager();
auto& rcm = engine->getRenderableManager();
auto& em = utils::EntityManager::get();
// Create textures. The KTX bundles are freed by KtxUtility.
auto albedo = new image::KtxBundle(MONKEY_ALBEDO_S3TC_DATA, MONKEY_ALBEDO_S3TC_SIZE);
auto ao = new image::KtxBundle(MONKEY_AO_DATA, MONKEY_AO_SIZE);
auto metallic = new image::KtxBundle(MONKEY_METALLIC_DATA, MONKEY_METALLIC_SIZE);
auto roughness = new image::KtxBundle(MONKEY_ROUGHNESS_DATA, MONKEY_ROUGHNESS_SIZE);
app.albedo = ktx::createTexture(engine, albedo, true);
app.ao = ktx::createTexture(engine, ao, false);
app.metallic = ktx::createTexture(engine, metallic, false);
app.roughness = ktx::createTexture(engine, roughness, false);
app.normal = loadNormalMap(engine, MONKEY_NORMAL_DATA, MONKEY_NORMAL_SIZE);
TextureSampler sampler(TextureSampler::MinFilter::LINEAR_MIPMAP_LINEAR,
TextureSampler::MagFilter::LINEAR);
// Instantiate material.
app.material = Material::Builder()
.package(RESOURCES_TEXTUREDLIT_DATA, RESOURCES_TEXTUREDLIT_SIZE).build(*engine);
app.materialInstance = app.material->createInstance();
app.materialInstance->setParameter("albedo", app.albedo, sampler);
app.materialInstance->setParameter("ao", app.ao, sampler);
app.materialInstance->setParameter("metallic", app.metallic, sampler);
app.materialInstance->setParameter("normal", app.normal, sampler);
app.materialInstance->setParameter("roughness", app.roughness, sampler);
auto ibl = FilamentApp::get().getIBL()->getIndirectLight();
ibl->setIntensity(100000);
ibl->setRotation(mat3f::rotation(0.5f, float3{ 0, 1, 0 }));
// Add geometry into the scene.
app.mesh = filamesh::MeshReader::loadMeshFromBuffer(engine, MONKEY_SUZANNE_DATA, nullptr,
nullptr, app.materialInstance);
auto ti = tcm.getInstance(app.mesh.renderable);
app.transform = mat4f{ mat3f(1), float3(0, 0, -4) } * tcm.getWorldTransform(ti);
rcm.setCastShadows(rcm.getInstance(app.mesh.renderable), false);
scene->addEntity(app.mesh.renderable);
tcm.setTransform(ti, app.transform);
};
auto cleanup = [&app](Engine* engine, View*, Scene*) {
engine->destroy(app.materialInstance);
engine->destroy(app.mesh.renderable);
engine->destroy(app.material);
engine->destroy(app.albedo);
engine->destroy(app.normal);
engine->destroy(app.roughness);
engine->destroy(app.metallic);
engine->destroy(app.ao);
};
FilamentApp::get().run(config, setup, cleanup);
return 0;
}
| 37.03 | 97 | 0.635431 | N500 |
1eb33682f3eb3cfd3ff55740a2c528520dbc0b1f | 331 | cpp | C++ | C语言程序设计基础/meiju.cpp | xiabee/BIT-CS | 5d8d8331e6b9588773991a872c259e430ef1eae1 | [
"Apache-2.0"
] | 63 | 2021-01-10T02:32:17.000Z | 2022-03-30T04:08:38.000Z | C语言程序设计基础/meiju.cpp | xiabee/BIT-CS | 5d8d8331e6b9588773991a872c259e430ef1eae1 | [
"Apache-2.0"
] | 2 | 2021-06-09T05:38:58.000Z | 2021-12-14T13:53:54.000Z | C语言程序设计基础/meiju.cpp | xiabee/BIT-CS | 5d8d8331e6b9588773991a872c259e430ef1eae1 | [
"Apache-2.0"
] | 20 | 2021-01-12T11:49:36.000Z | 2022-03-26T11:04:58.000Z | #include<stdio.h>
#include<math.h>
double a,b,c,d;
double f(double x)
{
return a*sin(x)*sin(x) + b*cos(x)*cos(x) +
c*sin(x) + d*cos(x);
}
int main()
{
double L,R,i;
scanf("%d%d%d%d%lf%lf",&a,&b,&c,&d,&L,&R);
double ans=f(1);
for(i=L; i<=R; i+=0.1)
ans= f(i)>ans ? f(i) : ans;
printf("%.1lf\n",ans);
return 0;
}
| 15.761905 | 44 | 0.519637 | xiabee |
1eb52945757c16dcf9574a6a9ddc466f0a3c729b | 4,135 | cpp | C++ | opencl/test/unit_test/aub_tests/command_stream/copy_engine_aub_tests_xehp_and_later.cpp | mattcarter2017/compute-runtime | 1f52802aac02c78c19d5493dd3a2402830bbe438 | [
"Intel",
"MIT"
] | null | null | null | opencl/test/unit_test/aub_tests/command_stream/copy_engine_aub_tests_xehp_and_later.cpp | mattcarter2017/compute-runtime | 1f52802aac02c78c19d5493dd3a2402830bbe438 | [
"Intel",
"MIT"
] | null | null | null | opencl/test/unit_test/aub_tests/command_stream/copy_engine_aub_tests_xehp_and_later.cpp | mattcarter2017/compute-runtime | 1f52802aac02c78c19d5493dd3a2402830bbe438 | [
"Intel",
"MIT"
] | null | null | null | /*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/test/unit_test/aub_tests/command_stream/copy_engine_aub_tests_xehp_and_later.h"
#include "shared/test/common/test_macros/test.h"
using namespace NEO;
using SingleTileCopyEngineTests = CopyEngineXeHPAndLater<1>;
HWTEST_F(SingleTileCopyEngineTests, givenNotCompressedBufferWhenBltExecutedThenCompressDataAndResolve) {
givenNotCompressedBufferWhenBltExecutedThenCompressDataAndResolveImpl<FamilyType>();
}
HWTEST_F(SingleTileCopyEngineTests, givenHostPtrWhenBlitCommandToCompressedBufferIsDispatchedThenCopiedDataIsValid) {
givenHostPtrWhenBlitCommandToCompressedBufferIsDispatchedThenCopiedDataIsValidImpl<FamilyType>();
}
HWTEST_F(SingleTileCopyEngineTests, givenDstHostPtrWhenBlitCommandFromCompressedBufferIsDispatchedThenCopiedDataIsValid) {
givenDstHostPtrWhenBlitCommandFromCompressedBufferIsDispatchedThenCopiedDataIsValidImpl<FamilyType>();
}
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineTests, givenDstHostPtrWhenBlitCommandFromNotCompressedBufferIsDispatchedThenCopiedDataIsValid) {
givenDstHostPtrWhenBlitCommandFromNotCompressedBufferIsDispatchedThenCopiedDataIsValidImpl<FamilyType>();
}
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineTests, givenSrcHostPtrWhenBlitCommandToNotCompressedBufferIsDispatchedThenCopiedDataIsValid) {
givenSrcHostPtrWhenBlitCommandToNotCompressedBufferIsDispatchedThenCopiedDataIsValidImpl<FamilyType>();
}
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineTests, givenBufferWithOffsetWhenHostPtrBlitCommandIsDispatchedFromHostPtrThenDataIsCorrectlyCopied) {
givenBufferWithOffsetWhenHostPtrBlitCommandIsDispatchedFromHostPtrThenDataIsCorrectlyCopiedImpl<FamilyType>();
}
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineTests, givenBufferWithOffsetWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopied) {
givenBufferWithOffsetWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopiedImpl<FamilyType>();
}
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineTests, givenOffsetsWhenBltExecutedThenCopiedDataIsValid) {
givenOffsetsWhenBltExecutedThenCopiedDataIsValidImpl<FamilyType>();
}
HWTEST_F(SingleTileCopyEngineTests, givenSrcCompressedBufferWhenBlitCommandToDstCompressedBufferIsDispatchedThenCopiedDataIsValid) {
givenSrcCompressedBufferWhenBlitCommandToDstCompressedBufferIsDispatchedThenCopiedDataIsValidImpl<FamilyType>();
}
HWTEST_F(SingleTileCopyEngineTests, givenCompressedBufferWhenAuxTranslationCalledThenResolveAndCompress) {
givenCompressedBufferWhenAuxTranslationCalledThenResolveAndCompressImpl<FamilyType>();
}
using SingleTileCopyEngineSystemMemoryTests = CopyEngineXeHPAndLater<1, false>;
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineSystemMemoryTests, givenSrcSystemBufferWhenBlitCommandToDstSystemBufferIsDispatchedThenCopiedDataIsValid) {
givenSrcSystemBufferWhenBlitCommandToDstSystemBufferIsDispatchedThenCopiedDataIsValidImpl<FamilyType>();
}
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineTests, givenReadBufferRectWithOffsetWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopied) {
givenReadBufferRectWithOffsetWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopiedImpl<FamilyType>();
}
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineTests, givenWriteBufferRectWithOffsetWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopied) {
givenWriteBufferRectWithOffsetWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopiedImpl<FamilyType>();
}
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineTests, givenCopyBufferRectWithOffsetWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopied) {
givenCopyBufferRectWithOffsetWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopiedImpl<FamilyType>();
}
HWCMDTEST_F(IGFX_XE_HP_CORE, SingleTileCopyEngineTests, givenCopyBufferRectWithBigSizesWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopied) {
givenCopyBufferRectWithBigSizesWhenHostPtrBlitCommandIsDispatchedToHostPtrThenDataIsCorrectlyCopiedImpl<FamilyType>();
}
| 53.701299 | 158 | 0.903507 | mattcarter2017 |
1eb55fa4ae0191760f4615afb116c1efd0d25563 | 670 | cpp | C++ | snippets/stl-6.cpp | district10/snippet-manager | bebe45a601368947168e3ee6e6ab8c1fc2ee2055 | [
"MIT"
] | 7 | 2018-08-04T09:28:19.000Z | 2020-10-19T17:46:34.000Z | snippets/stl-6.cpp | district10/snippet-manager | bebe45a601368947168e3ee6e6ab8c1fc2ee2055 | [
"MIT"
] | null | null | null | snippets/stl-6.cpp | district10/snippet-manager | bebe45a601368947168e3ee6e6ab8c1fc2ee2055 | [
"MIT"
] | 2 | 2018-07-31T04:14:55.000Z | 2020-04-02T01:22:39.000Z | /// ptc ,partition_copy
std::partition_copy(std::begin(%\m C%), std::end(%\m C%), std::begin(%\c), std::end(%\c));
/// pst ,partial_sort
std::partial_sort(std::begin(%\m C%), std::end(%\m C%), std::end(%\m C%));
/// fnd ,find
auto pos = std::find(std::begin(%\m C%), std::end(%\m C%), %\c);
if (pos != std::end(%\m C%)) {
%\c
}
/// fre ,for_each
std::for_each(std::begin(%\m C%), std::end(%\m C%), [](%\c) {
%\c
});
/// mne ,min_element
auto pos = std::min_element(std::begin(%\m C%), std::end(%\m C%));
/// fne ,find_end
auto pos = std::find_std::end(std::begin(%\m C%), std::end(%\m C%), std::begin(%\c), std::end(%\c));
if (pos != std::end(%\m C%)) {
%\c
}
| 31.904762 | 100 | 0.526866 | district10 |
1eb76061f8a582692e239a691630e62fec3b3923 | 2,433 | hxx | C++ | opencascade/BRepBuilderAPI_VertexInspector.hxx | mgreminger/OCP | 92eacb99497cd52b419c8a4a8ab0abab2330ed42 | [
"Apache-2.0"
] | null | null | null | opencascade/BRepBuilderAPI_VertexInspector.hxx | mgreminger/OCP | 92eacb99497cd52b419c8a4a8ab0abab2330ed42 | [
"Apache-2.0"
] | null | null | null | opencascade/BRepBuilderAPI_VertexInspector.hxx | mgreminger/OCP | 92eacb99497cd52b419c8a4a8ab0abab2330ed42 | [
"Apache-2.0"
] | null | null | null | // Created on: 2011-11-24
// Created by: ANNA MASALSKAYA
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef BRepBuilderAPI_VertexInspector_HeaderFile
#define BRepBuilderAPI_VertexInspector_HeaderFile
#include <TColStd_ListOfInteger.hxx>
#include <NCollection_Vector.hxx>
#include <gp_XY.hxx>
#include <gp_XYZ.hxx>
#include <NCollection_CellFilter.hxx>
typedef NCollection_Vector<gp_XYZ> VectorOfPoint;
//=======================================================================
//! Class BRepBuilderAPI_VertexInspector
//! derived from NCollection_CellFilter_InspectorXYZ
//! This class define the Inspector interface for CellFilter algorithm,
//! working with gp_XYZ points in 3d space.
//! Used in search of coincidence points with a certain tolerance.
//=======================================================================
class BRepBuilderAPI_VertexInspector : public NCollection_CellFilter_InspectorXYZ
{
public:
typedef Standard_Integer Target;
//! Constructor; remembers the tolerance
BRepBuilderAPI_VertexInspector (const Standard_Real theTol):myTol(theTol*theTol)
{}
//! Keep the points used for comparison
void Add (const gp_XYZ& thePnt)
{
myPoints.Append (thePnt);
}
//! Clear the list of adjacent points
void ClearResList()
{
myResInd.Clear();
}
//! Set current point to search for coincidence
void SetCurrent (const gp_XYZ& theCurPnt)
{
myCurrent = theCurPnt;
}
//! Get list of indexes of points adjacent with the current
const TColStd_ListOfInteger& ResInd()
{
return myResInd;
}
//! Implementation of inspection method
Standard_EXPORT NCollection_CellFilter_Action Inspect (const Standard_Integer theTarget);
private:
Standard_Real myTol;
TColStd_ListOfInteger myResInd;
VectorOfPoint myPoints;
gp_XYZ myCurrent;
};
#endif
| 31.192308 | 92 | 0.722154 | mgreminger |
1eb7985d0bcc137b07de3907f540ee9b9bf8fba6 | 2,635 | cpp | C++ | src/libraries/edgeMesh/edgeFormats/vtk/VTKedgeFormat.cpp | MrAwesomeRocks/caelus-cml | 55b6dc5ba47d0e95c07412d9446ac72ac11d7fd7 | [
"mpich2"
] | null | null | null | src/libraries/edgeMesh/edgeFormats/vtk/VTKedgeFormat.cpp | MrAwesomeRocks/caelus-cml | 55b6dc5ba47d0e95c07412d9446ac72ac11d7fd7 | [
"mpich2"
] | null | null | null | src/libraries/edgeMesh/edgeFormats/vtk/VTKedgeFormat.cpp | MrAwesomeRocks/caelus-cml | 55b6dc5ba47d0e95c07412d9446ac72ac11d7fd7 | [
"mpich2"
] | null | null | null | /*---------------------------------------------------------------------------*\
Copyright (C) 2011 OpenFOAM Foundation
-------------------------------------------------------------------------------
License
This file is part of CAELUS.
CAELUS 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.
CAELUS 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 CAELUS. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "VTKedgeFormat.hpp"
#include "OFstream.hpp"
#include "clock.hpp"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void CML::fileFormats::VTKedgeFormat::writeHeader
(
Ostream& os,
const pointField& pointLst
)
{
// Write header
os << "# vtk DataFile Version 2.0" << nl
<< "featureEdgeMesh written " << clock::dateTime().c_str() << nl
<< "ASCII" << nl
<< nl
<< "DATASET POLYDATA" << nl;
// Write vertex coords
os << "POINTS " << pointLst.size() << " float" << nl;
forAll(pointLst, ptI)
{
const point& pt = pointLst[ptI];
os << pt.x() << ' ' << pt.y() << ' ' << pt.z() << nl;
}
}
void CML::fileFormats::VTKedgeFormat::writeEdges
(
Ostream& os,
const UList<edge>& edgeLst
)
{
os << "LINES " << edgeLst.size() << ' ' << 3*edgeLst.size() << nl;
forAll(edgeLst, edgeI)
{
const edge& e = edgeLst[edgeI];
os << "2 " << e[0] << ' ' << e[1] << nl;
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
CML::fileFormats::VTKedgeFormat::VTKedgeFormat()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void CML::fileFormats::VTKedgeFormat::write
(
const fileName& filename,
const edgeMesh& eMesh
)
{
OFstream os(filename);
if (!os.good())
{
FatalErrorInFunction
<< "Cannot open file for writing " << filename
<< exit(FatalError);
}
writeHeader(os, eMesh.points());
writeEdges(os, eMesh.edges());
}
// ************************************************************************* //
| 27.164948 | 79 | 0.499431 | MrAwesomeRocks |
1eb8edac94392d03ea02d20df8a1f446909bb3ed | 8,297 | cpp | C++ | src/uniform_spacetime_be_identity.cpp | zap150/besthea | b7a9bb80a936f380af2d2c2e7ee3cc713d3792ca | [
"BSD-3-Clause"
] | null | null | null | src/uniform_spacetime_be_identity.cpp | zap150/besthea | b7a9bb80a936f380af2d2c2e7ee3cc713d3792ca | [
"BSD-3-Clause"
] | null | null | null | src/uniform_spacetime_be_identity.cpp | zap150/besthea | b7a9bb80a936f380af2d2c2e7ee3cc713d3792ca | [
"BSD-3-Clause"
] | 1 | 2021-09-15T01:59:34.000Z | 2021-09-15T01:59:34.000Z | /*
Copyright (c) 2020, VSB - Technical University of Ostrava and Graz University of
Technology
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 names of VSB - Technical University of Ostrava and Graz
University of Technology 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 VSB - TECHNICAL UNIVERSITY OF OSTRAVA AND
GRAZ UNIVERSITY OF TECHNOLOGY 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 "besthea/uniform_spacetime_be_identity.h"
#include "besthea/basis_tri_p0.h"
#include "besthea/basis_tri_p1.h"
#include "besthea/quadrature.h"
template< class test_space_type, class trial_space_type >
besthea::bem::uniform_spacetime_be_identity< test_space_type,
trial_space_type >::uniform_spacetime_be_identity( test_space_type &
test_space,
trial_space_type & trial_space, int order_regular )
: _data( ),
_test_space( &test_space ),
_trial_space( &trial_space ),
_order_regular( order_regular ) {
auto & test_basis = _test_space->get_basis( );
auto & trial_basis = _trial_space->get_basis( );
const auto & st_mesh = _test_space->get_mesh( );
set_block_dim( st_mesh.get_n_temporal_elements( ) );
set_dim_domain( trial_basis.dimension_global( ) );
set_dim_range( test_basis.dimension_global( ) );
}
template< class test_space_type, class trial_space_type >
besthea::bem::uniform_spacetime_be_identity< test_space_type,
trial_space_type >::~uniform_spacetime_be_identity( ) {
}
template< class test_space_type, class trial_space_type >
void besthea::bem::uniform_spacetime_be_identity< test_space_type,
trial_space_type >::assemble( ) {
std::vector< los > ii;
std::vector< los > jj;
std::vector< sc > vv;
assemble_triplets( ii, jj, vv );
lo n_rows = _test_space->get_basis( ).dimension_global( );
lo n_columns = _trial_space->get_basis( ).dimension_global( );
_data.set_from_triplets( n_rows, n_columns, ii, jj, vv );
}
template< class test_space_type, class trial_space_type >
void besthea::bem::uniform_spacetime_be_identity< test_space_type,
trial_space_type >::assemble( matrix_type & global_matrix ) const {
std::vector< los > ii;
std::vector< los > jj;
std::vector< sc > vv;
assemble_triplets( ii, jj, vv );
lo n_rows = _test_space->get_basis( ).dimension_global( );
lo n_columns = _trial_space->get_basis( ).dimension_global( );
global_matrix.set_from_triplets( n_rows, n_columns, ii, jj, vv );
}
template< class test_space_type, class trial_space_type >
void besthea::bem::uniform_spacetime_be_identity< test_space_type,
trial_space_type >::assemble_triplets( std::vector< los > & ii,
std::vector< los > & jj, std::vector< sc > & vv ) const {
auto & test_basis = _test_space->get_basis( );
auto & trial_basis = _trial_space->get_basis( );
const auto & st_mesh = _test_space->get_mesh( );
sc timestep = st_mesh.get_timestep( );
lo n_loc_rows = test_basis.dimension_local( );
lo n_loc_columns = trial_basis.dimension_local( );
lo n_elements = st_mesh.get_n_spatial_elements( );
std::vector< lo > test_l2g( n_loc_rows );
std::vector< lo > trial_l2g( n_loc_columns );
ii.reserve( n_elements * n_loc_rows * n_loc_columns );
jj.reserve( n_elements * n_loc_rows * n_loc_columns );
vv.reserve( n_elements * n_loc_rows * n_loc_columns );
const std::vector< sc, besthea::allocator_type< sc > > & x1_ref
= quadrature::triangle_x1( _order_regular );
const std::vector< sc, besthea::allocator_type< sc > > & x2_ref
= quadrature::triangle_x2( _order_regular );
const std::vector< sc, besthea::allocator_type< sc > > & w
= quadrature::triangle_w( _order_regular );
lo size = w.size( );
sc value, test, trial, area;
linear_algebra::coordinates< 3 > n;
for ( lo i_elem = 0; i_elem < n_elements; ++i_elem ) {
st_mesh.get_spatial_normal( i_elem, n );
area = st_mesh.spatial_area( i_elem );
test_basis.local_to_global( i_elem, test_l2g );
trial_basis.local_to_global( i_elem, trial_l2g );
for ( lo i_loc_test = 0; i_loc_test < n_loc_rows; ++i_loc_test ) {
for ( lo i_loc_trial = 0; i_loc_trial < n_loc_columns; ++i_loc_trial ) {
value = 0.0;
for ( lo i_quad = 0; i_quad < size; ++i_quad ) {
test = test_basis.evaluate(
i_elem, i_loc_test, x1_ref[ i_quad ], x2_ref[ i_quad ], n.data( ) );
trial = trial_basis.evaluate( i_elem, i_loc_trial, x1_ref[ i_quad ],
x2_ref[ i_quad ], n.data( ) );
value += w[ i_quad ] * test * trial;
}
ii.push_back( test_l2g[ i_loc_test ] );
jj.push_back( trial_l2g[ i_loc_trial ] );
vv.push_back( value * timestep * area );
}
}
}
}
template< class test_space_type, class trial_space_type >
void besthea::bem::uniform_spacetime_be_identity< test_space_type,
trial_space_type >::apply( const block_vector_type & x, block_vector_type & y,
bool trans, sc alpha, sc beta ) const {
lo block_dim = ( _test_space->get_mesh( ) ).get_n_temporal_elements( );
for ( lo diag = 0; diag < block_dim; ++diag ) {
_data.apply( x.get_block( diag ), y.get_block( diag ), trans, alpha, beta );
}
}
template< class test_space_type, class trial_space_type >
void besthea::bem::uniform_spacetime_be_identity< test_space_type,
trial_space_type >::apply( const distributed_block_vector_type & x,
distributed_block_vector_type & y, bool trans, sc alpha, sc beta ) const {
lo block_dim = ( _test_space->get_mesh( ) ).get_n_temporal_elements( );
for ( lo diag = 0; diag < block_dim; ++diag ) {
if ( y.am_i_owner( diag ) && x.am_i_owner( diag ) ) {
_data.apply(
x.get_block( diag ), y.get_block( diag ), trans, alpha, beta );
}
}
}
template class besthea::bem::uniform_spacetime_be_identity<
besthea::bem::uniform_spacetime_be_space< besthea::bem::basis_tri_p0 >,
besthea::bem::uniform_spacetime_be_space< besthea::bem::basis_tri_p0 > >;
template class besthea::bem::uniform_spacetime_be_identity<
besthea::bem::uniform_spacetime_be_space< besthea::bem::basis_tri_p0 >,
besthea::bem::uniform_spacetime_be_space< besthea::bem::basis_tri_p1 > >;
template class besthea::bem::uniform_spacetime_be_identity<
besthea::bem::uniform_spacetime_be_space< besthea::bem::basis_tri_p1 >,
besthea::bem::uniform_spacetime_be_space< besthea::bem::basis_tri_p1 > >;
// Needed for L2 projection which is const
template class besthea::bem::uniform_spacetime_be_identity<
const besthea::bem::uniform_spacetime_be_space< besthea::bem::basis_tri_p0 >,
const besthea::bem::uniform_spacetime_be_space<
besthea::bem::basis_tri_p0 > >;
template class besthea::bem::uniform_spacetime_be_identity<
const besthea::bem::uniform_spacetime_be_space< besthea::bem::basis_tri_p0 >,
const besthea::bem::uniform_spacetime_be_space<
besthea::bem::basis_tri_p1 > >;
template class besthea::bem::uniform_spacetime_be_identity<
const besthea::bem::uniform_spacetime_be_space< besthea::bem::basis_tri_p1 >,
const besthea::bem::uniform_spacetime_be_space<
besthea::bem::basis_tri_p1 > >;
| 44.368984 | 80 | 0.731951 | zap150 |
1eb9d76983e39fb2b97243f0bf26b4d703fe6360 | 1,689 | cpp | C++ | src/RNG.cpp | komatura/Voltage-noise-generator | 31332f9ae4a0ce5a2a259ad136b75d67831da637 | [
"MIT"
] | null | null | null | src/RNG.cpp | komatura/Voltage-noise-generator | 31332f9ae4a0ce5a2a259ad136b75d67831da637 | [
"MIT"
] | null | null | null | src/RNG.cpp | komatura/Voltage-noise-generator | 31332f9ae4a0ce5a2a259ad136b75d67831da637 | [
"MIT"
] | 1 | 2018-07-27T22:38:43.000Z | 2018-07-27T22:38:43.000Z | #include "RNG.h"
#include <chrono>
unsigned int RNG::_seed = chrono::system_clock::now().time_since_epoch().count();
mt19937 RNG::_RNGBase;
Real_RNG RNG::_floatGen = nullptr;
Int_RNG RNG::_intGen = nullptr;
Real_Normal_RNG RNG::_normalFloatGen = nullptr;
void RNG::Initialize() {
_RNGBase.seed(_seed);
_floatGen.reset(new uniform_real_distribution<double>(0.0, 1.0));
_intGen.reset(new uniform_int_distribution<int>(0, 10000000));
_normalFloatGen.reset(new normal_distribution<double>(0, 0.2));
}
void RNG::Clear() {
_floatGen.release();
_intGen.release();
_normalFloatGen.release();
}
void RNG::setMaxValue(const int& max) {
uniform_int_distribution<int>::param_type params(0, max);
_intGen->param(params);
}
int RNG::getInt() {
return _intGen->operator()(_RNGBase);
}
int RNG::getInt(const int& max) {
return (max / 100) * _intGen->operator()(_RNGBase);
}
int RNG::getInt(const int& min, const int& max) {
return (max / 100) * _intGen->operator()(_RNGBase) + min;
}
double RNG::getDouble() {
return _floatGen->operator()(_RNGBase);
}
double RNG::getDouble(const double& max) {
return (max / 100.0) * _floatGen->operator()(_RNGBase);
}
double RNG::getDouble(const double& min, const double& max) {
return (max / 100.0) * _floatGen->operator()(_RNGBase) + min;
}
unsigned int RNG::getSeed() {
return _seed;
}
double RNG::getDoubleFloat() {
return _normalFloatGen->operator()(_RNGBase);
}
void RNG::setSigma(const double& sigma) {
// _normalFloatGen.reset(new normal_distribution<double>(0, sigma));
normal_distribution<double>::param_type params(0.0, sigma);
_normalFloatGen->param(params);
// _normalFloatGen->reset();
} | 20.349398 | 81 | 0.703375 | komatura |
1ebd5ccb4500d7b1441fc1c721a0782502940cfe | 876 | cpp | C++ | plugins/qnx/_hook_ui_color.cpp | mmuman/skinobe | c3aa05a650161d59749f9e468a5ee895fd8d6498 | [
"MIT"
] | 1 | 2019-03-01T05:32:17.000Z | 2019-03-01T05:32:17.000Z | plugins/sequel/_hook_ui_color.cpp | mmuman/skinobe | c3aa05a650161d59749f9e468a5ee895fd8d6498 | [
"MIT"
] | null | null | null | plugins/sequel/_hook_ui_color.cpp | mmuman/skinobe | c3aa05a650161d59749f9e468a5ee895fd8d6498 | [
"MIT"
] | null | null | null | #include <stdio.h>
#include <OS.h>
#include <InterfaceDefs.h>
#ifdef __cplusplus
extern "C" {
#endif
static const rgb_color gonxColors[10] =
{
{0, 0, 0, 255}, // null color
{239, 235, 231, 255}, // B_PANEL_BACKGROUND_COLOR
{239, 235, 231, 255}, // B_MENU_BACKGROUND_COLOR
{255, 203, 0, 255}, // B_WINDOW_TAB_COLOR
//{115, 120, 184, 255}, // B_KEYBOARD_NAVIGATION_COLOR
{80, 114, 154, 255}, // B_KEYBOARD_NAVIGATION_COLOR
{51, 102, 152, 255}, // B_DESKTOP_COLOR
{247, 247, 247, 255}, // B_MENU_SELECTION_BACKGROUND_COLOR
{0, 0, 30, 255}, // B_MENU_ITEM_TEXT_COLOR
{0, 0, 50, 255}, // B_MENU_SELECTED_ITEM_TEXT_COLOR
{0, 255, 255, 255} //
};
rgb_color hooked_ui_color__F11color_which(color_which which)
{
int iwhich = *(int *)&which;
puts("ui_color() hook called");
if (iwhich < 0 || iwhich > 9)
iwhich = 0;
return gonxColors[iwhich];
}
#ifdef __cplusplus
}
#endif
| 23.675676 | 60 | 0.689498 | mmuman |
3630afa4a87715974b8ec5b25ca81e148e323c96 | 994 | cpp | C++ | gym/102784/F.cpp | albexl/codeforces-gym-submissions | 2a51905c50fcf5d7f417af81c4c49ca5217d0753 | [
"MIT"
] | 1 | 2021-07-16T19:59:39.000Z | 2021-07-16T19:59:39.000Z | gym/102784/F.cpp | albexl/codeforces-gym-submissions | 2a51905c50fcf5d7f417af81c4c49ca5217d0753 | [
"MIT"
] | null | null | null | gym/102784/F.cpp | albexl/codeforces-gym-submissions | 2a51905c50fcf5d7f417af81c4c49ca5217d0753 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <random>
#include <chrono>
using namespace std;
using namespace __gnu_pbds;
#define endl '\n'
typedef long long ll;
typedef pair<int, int> pii;
// typedef tree<int, null_type,less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
// template<typename T>
// static T randint(T lo, T hi){
// return uniform_int_distribution<T>(lo, hi)(rng);
// }
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
// freopen("settling.in", "r", stdin);
// freopen("settling.out", "w", stdout);
ll a, b;
cin >> a >> b;
ll ans = 0, num = 0;
for(ll i = 62; i >= 0; i--){
ll b1 = (a & (1ll << i)) != 0;
if(b1)
ans += (1ll << i);
else{
ll n_num = num | (1ll << i);
if(n_num <= b){
num += (1ll << i);
ans += (1ll << i);
}
}
}
cout << ans << endl;
return 0;
} | 19.490196 | 102 | 0.603622 | albexl |
363177a43a385f5312278583ef45f023df1bc59c | 22,100 | cpp | C++ | imdexp/src/ImdExp.cpp | olivierchatry/iri3d | cae98c61d9257546d0fc81e69709297d04a17a14 | [
"MIT"
] | 2 | 2022-01-02T08:12:29.000Z | 2022-02-12T22:15:11.000Z | imdexp/src/ImdExp.cpp | olivierchatry/iri3d | cae98c61d9257546d0fc81e69709297d04a17a14 | [
"MIT"
] | null | null | null | imdexp/src/ImdExp.cpp | olivierchatry/iri3d | cae98c61d9257546d0fc81e69709297d04a17a14 | [
"MIT"
] | 1 | 2022-01-02T08:09:51.000Z | 2022-01-02T08:09:51.000Z |
/********************************************************************
created: 2003/02/03
created: 4:2:2003 20:17
filename: e:\_dev\tmp\imdexp\src\imdexp.cpp
file path: e:\_dev\tmp\imdexp\src
file base: imdexp
file ext: cpp
author: Chatry Olivier alias gruiiik
purpose: Main exporter function.
*********************************************************************/
#include <stdafx.h>
#include <imd2/imd2.hpp>
#include <utility>
/*
* consttructor destructor
*/
ImdExp::ImdExp() : _material_list(0), _log(0)
{
}
ImdExp::~ImdExp()
{
}
//////////////////////////////////////////////////////////////////////////
/*
* return pointer to max interface
*/
Interface *ImdExp::GetInterface()
{
return ip;
}
/*
* give number of file extension handled by the plugin
* for instance, we only handle imd file.
*/
int ImdExp::ExtCount()
{
return 1;
}
/*
* give the string of given extension.
* Because we handle only one extension, we
* just return a string without any test.
*/
const TCHAR *ImdExp::Ext(int n)
{
return GetString(IDS_IMDEXTENSION);
}
/*
* Long description of our plugin
*/
const TCHAR *ImdExp::LongDesc()
{
return GetString(IDS_LONGDESCRIPTION);
}
/*
* Short description of our plugin
*/
const TCHAR *ImdExp::ShortDesc()
{
return GetString(IDS_SHORTDESCRIPTION);
}
/*
* My name :)
*/
const TCHAR *ImdExp::AuthorName()
{
return GetString(IDS_ME);
}
/*
* Stupid copyright (i hate copyright :)) message
*/
const TCHAR *ImdExp::CopyrightMessage()
{
return GetString(IDS_COPYRIGHT);
}
/*
* Version of our plugin
*/
unsigned int ImdExp::Version()
{
return IMDEXP_VERSION;
}
//////////////////////////////////////////////////////////////////////////
// callback def.
#include "callback.h"
//////////////////////////////////////////////////////////////////////////
/*
* About our plugin, just create a sample dialog box
* from IDD_ABOUTBOX resource.
*/
void ImdExp::ShowAbout(HWND hwnd)
{
DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_DIALOGABOUT), hwnd, AboutBoxDlgProc, 0);
}
/*
* Other message function, return empty string
*/
const TCHAR *ImdExp::OtherMessage1()
{
return _T("");
}
const TCHAR *ImdExp::OtherMessage2()
{
return _T("");
}
void ImdExp::PopulateTreeView(HWND hwnd, INode *node, HTREEITEM parent)
{
_node_count++;
if (node == 0)
node = ip->GetRootNode();
char buffer[512];
ObjectState os = node->EvalWorldState(0);
sprintf(buffer, "%s", node->GetName());
HTREEITEM me = AddNode(hwnd, IDC_TREESCENE, buffer, parent);
for (int c = 0; c < node->NumberOfChildren(); c++)
PopulateTreeView(hwnd, node->GetChildNode(c), me);
}
/*
* Suported option, only export for instance.
*/
BOOL ImdExp::SupportsOptions(int ext, DWORD options)
{
assert(ext == 0);
return (options == SCENE_EXPORT_SELECTED) ? TRUE : FALSE;
}
//////////////////////////////////////////////////////////////////////////
// utility function
//////////////////////////////////////////////////////////////////////////
Modifier *ImdExp::FindModifier(INode *node, Class_ID &class_id)
{
Object *object = node->GetObjectRef();
if (object == 0)
return 0;
while (object->SuperClassID() == GEN_DERIVOB_CLASS_ID)
{
IDerivedObject *derived_object = static_cast<IDerivedObject *>(object);
for (int mi = 0; mi < derived_object->NumModifiers(); ++mi)
{
Modifier *m = derived_object->GetModifier(mi);
Loger::Get().Printf("[ImdExp::FindModifier] Find Modifier %s", m->GetName());
if (m->ClassID() == class_id)
return m;
}
object = derived_object->GetObjRef();
}
return 0;
}
//////////////////////////////////////////////////////////////////////////
// mesh importer
//////////////////////////////////////////////////////////////////////////
void ImdExp::ImportMeshData(INode *node, ObjectState &os)
{
// import only triangular data.
// bones are processed in another loop.
if (!IsNodeBone(node))
ImportTriangularData(node, os);
}
Matrix3 ImdExp::GetNodeOffsetTM(INode *node)
{
Matrix3 offset_tm(1);
Point3 pos = node->GetObjOffsetPos();
offset_tm.PreTranslate(pos);
Quat quat = node->GetObjOffsetRot();
PreRotateMatrix(offset_tm, quat);
ScaleValue scale_value = node->GetObjOffsetScale();
ApplyScaling(offset_tm, scale_value);
return offset_tm;
}
/*
* Export data
*/
void ImdExp::ImportDataFromMax(INode *node)
{
// node->Selected()
ObjectState os = node->EvalWorldState(_plugin_config._begin_frame);
if (os.obj)
{
switch (os.obj->SuperClassID())
{
case GEOMOBJECT_CLASS_ID:
ImportMeshData(node, os);
break;
case CAMERA_CLASS_ID:
break;
case LIGHT_CLASS_ID:
ImportLightData(node, os);
break;
case SHAPE_CLASS_ID:
break;
case HELPER_CLASS_ID:
case BONE_CLASS_ID:
break;
}
}
for (int c = 0; c < node->NumberOfChildren(); c++)
ImportDataFromMax(node->GetChildNode(c));
}
/*
* Free all allocated data
*/
void ImdExp::FreeAll()
{
element_list_it_t it;
Loger::Get().Print("++ [ImdExp::FreeAll]");
for (it = _elements.begin(); it != _elements.end(); ++it)
delete (*it);
_elements.resize(0);
Loger::Get().Print("-- [ImdExp::FreeAll]");
}
unsigned short ImdExp::CountElementOf(element_type type)
{
element_list_it_t it;
unsigned short count = 0;
for (it = _elements.begin(); it != _elements.end(); ++it)
{
if ((*it)->_type == type)
count++;
}
return count;
}
std::string ImdExp::GetFilePath(std::string str)
{
size_t pos_sep = str.find_last_of("\\/");
return str.substr(0, pos_sep + 1);
}
std::string ImdExp::GetFileName(std::string str)
{
size_t pos_sep = str.find_last_of("\\/") + 1;
return str.substr(pos_sep);
}
std::string ImdExp::GetFileNameWithoutExtension(std::string str)
{
size_t pos_sep = str.find_last_of("\\/") + 1;
size_t pos_point = str.find_last_of(".");
return str.substr(pos_sep, pos_point - pos_sep);
}
int ImdExp::TruncateValueToPower2(int value)
{
int bit = 32;
while (bit--)
if (value >> bit)
return (1 << bit);
return 0;
}
//////////////////////////////////////////////////////////////////////////
// write our imd2 file.
void ImdExp::ExportImd2Material(imd2_object_t &object, std::string &path)
{
ImportedMaterial::material_data_list_it_t it;
int count = 0;
ilInit();
iluInit();
ilutInit();
iluImageParameter(ILU_FILTER, ILU_BILINEAR);
for (it = _material_list->_material_data.begin(); it != _material_list->_material_data.end(); ++it)
{
MaterialData *material_data = *it;
char *file_name_path;
memset(object.imd2_material[count].file_name, 0, IMD2_MAX_NAME);
file_name_path = material_data->_diffuse_map;
if (file_name_path == 0)
file_name_path = material_data->_env_map;
if (file_name_path == 0)
{
_log->Printf("!!! Invalid texture file name for material %s\n", material_data->_name);
continue;
}
// copy bitmap file to imd2 folder.
std::string file_name = GetFileNameWithoutExtension(file_name_path);
std::string new_file_name_path(path);
file_name += ".png";
new_file_name_path += file_name;
ILuint image_id;
ilGenImages(1, &image_id);
ilBindImage(image_id);
iluLoadImage(file_name_path);
int convert_width = TruncateValueToPower2(ilGetInteger(IL_IMAGE_WIDTH));
int convert_height = TruncateValueToPower2(ilGetInteger(IL_IMAGE_WIDTH));
int middle = 0;
if (convert_height != convert_width)
middle = TruncateValueToPower2((convert_width + convert_height) / 2);
else
middle = convert_width;
if (middle > 512)
middle = 512;
if (middle < 8)
middle = 8;
ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
iluScale(middle, middle, 1);
DeleteFile(new_file_name_path.c_str());
ilSaveImage((ILstring)new_file_name_path.c_str());
ilDeleteImages(1, &image_id);
strncpy(object.imd2_material[count].file_name, file_name.c_str(), IMD2_MAX_NAME - 1);
// defin material id !!!
object.imd2_material[count].material_id = (int)(material_data);
_log->Printf("inserting material file [%s]", object.imd2_material[count].file_name);
material_data->_diffuse_map = strdup(new_file_name_path.c_str());
material_data->_env_map = 0;
count++;
}
}
void MatrixToFloatP(float *m, Matrix3 &max_mat)
{
Point3 p = max_mat.GetRow(0);
m[0] = p.x;
m[1] = p.y;
m[2] = p.z;
m[3] = 0.0f;
p = max_mat.GetRow(1);
m[4] = p.x;
m[5] = p.y;
m[6] = p.z;
m[7] = 0.0f;
p = max_mat.GetRow(2);
m[8] = p.x;
m[9] = p.y;
m[10] = p.z;
m[11] = 0.0f;
p = max_mat.GetRow(3);
m[12] = p.x;
m[13] = p.y;
m[14] = p.z;
m[15] = 1.0f;
}
void ImdExp::ExportImd2Mesh(imd2_object_t &object)
{
element_list_it_t it;
// allocate data
object.imd2_object_header.have_skin = false;
object.imd2_mesh = new imd2_mesh_t[object.imd2_object_header.num_mesh];
imd2_mesh_t *mesh = object.imd2_mesh;
memset(mesh, 0, object.imd2_object_header.num_mesh * sizeof(imd2_mesh_t));
for (it = _elements.begin(); it != _elements.end(); ++it)
{
ImportedElements *el = *it;
if (el->_type == mesh_element)
{
ImportedMesh *imesh = (ImportedMesh *)el;
strncpy(mesh->imd2_mesh_header.name, imesh->_name.c_str(), IMD2_MAX_NAME - 1);
size_t vertex_count = imesh->_mesh_data[0]._vertex.size();
mesh->imd2_mesh_header.num_vertex = (short)vertex_count;
object.imd2_object_header.have_skin |= imesh->_skin != 0;
mesh->imd2_mesh_header.have_skin = imesh->_skin != 0;
mesh->user_data = new char[imesh->_user_properties.size() + 1];
strcpy(mesh->user_data, imesh->_user_properties.c_str());
mesh->imd2_mesh_header.material_id = (int)imesh->_material;
mesh->imd2_face.num_section = (unsigned short)imesh->_strip.size();
mesh->imd2_face.imd2_section = new imd2_face_section_t[mesh->imd2_face.num_section];
for (int index_strip = 0; index_strip < mesh->imd2_face.num_section; ++index_strip)
{
mesh->imd2_face.imd2_section[index_strip].num_indice = (unsigned short)imesh->_strip[index_strip]._face_index.size();
mesh->imd2_face.imd2_section[index_strip].indice = new unsigned short[mesh->imd2_face.imd2_section[index_strip].num_indice];
for (size_t index_face = 0; index_face < imesh->_strip[index_strip]._face_index.size(); ++index_face)
mesh->imd2_face.imd2_section[index_strip].indice[index_face] = imesh->_strip[index_strip]._face_index[index_face];
}
//////////////////////////////////////////////////////////////////////////
// copy vertex data
if (!_plugin_config._sample_matrix)
{
mesh->imd2_vertex = new imd2_vertex_t[vertex_count * object.imd2_object_header.num_anim];
mesh->imd2_matrix = 0;
// save object matrix.
for (int index_anim = 0; index_anim < object.imd2_object_header.num_anim; ++index_anim)
for (size_t index_vertex = 0; index_vertex < vertex_count; ++index_vertex)
{
size_t offset = vertex_count * index_anim + index_vertex;
MeshData &mesh_data = imesh->_mesh_data[index_anim];
std::swap(mesh_data._vertex[index_vertex].y, mesh_data._vertex[index_vertex].z);
std::swap(mesh_data._normal[index_vertex].y, mesh_data._normal[index_vertex].z);
mesh_data._vertex[index_vertex] = mesh_data._matrix * mesh_data._vertex[index_vertex];
Matrix3 tmp = mesh_data._matrix;
tmp.NoTrans();
mesh_data._normal[index_vertex] = tmp * mesh_data._normal[index_vertex];
memcpy(mesh->imd2_vertex[offset].normal, mesh_data._normal[index_vertex], sizeof(float) * 3);
memcpy(mesh->imd2_vertex[offset].pos, mesh_data._vertex[index_vertex], sizeof(float) * 3);
uint r = (uint)(imesh->_mesh_color_mapping._color[index_vertex].x * 255) & 0xff;
uint g = (uint)(imesh->_mesh_color_mapping._color[index_vertex].y * 255) & 0xff;
uint b = (uint)(imesh->_mesh_color_mapping._color[index_vertex].z * 255) & 0xff;
mesh->imd2_vertex[offset].color = (r << 16 | g << 8 | b);
mesh->imd2_vertex[offset].uv[0] = imesh->_mesh_color_mapping._mapping[index_vertex]._uv.x;
mesh->imd2_vertex[offset].uv[1] = 1.0f - imesh->_mesh_color_mapping._mapping[index_vertex]._uv.y;
}
}
else
{
mesh->imd2_vertex = new imd2_vertex_t[vertex_count];
mesh->imd2_matrix = new imd2_matrix_t[object.imd2_object_header.num_anim];
for (size_t index_vertex = 0; index_vertex < vertex_count; ++index_vertex)
{
MeshData &mesh_data = imesh->_mesh_data[0];
std::swap(mesh_data._vertex[index_vertex].y, mesh_data._vertex[index_vertex].z);
std::swap(mesh_data._normal[index_vertex].y, mesh_data._normal[index_vertex].z);
memcpy(mesh->imd2_vertex[index_vertex].normal, mesh_data._normal[index_vertex], sizeof(float) * 3);
memcpy(mesh->imd2_vertex[index_vertex].pos, mesh_data._vertex[index_vertex], sizeof(float) * 3);
uint r = (uint)(imesh->_mesh_color_mapping._color[index_vertex].x * 255) & 0xff;
uint g = (uint)(imesh->_mesh_color_mapping._color[index_vertex].y * 255) & 0xff;
uint b = (uint)(imesh->_mesh_color_mapping._color[index_vertex].z * 255) & 0xff;
mesh->imd2_vertex[index_vertex].color = (r << 16 | g << 8 | b);
mesh->imd2_vertex[index_vertex].uv[0] = imesh->_mesh_color_mapping._mapping[index_vertex]._uv.x;
mesh->imd2_vertex[index_vertex].uv[1] = 1.0f - imesh->_mesh_color_mapping._mapping[index_vertex]._uv.y;
}
for (int index_anim = 0; index_anim < object.imd2_object_header.num_anim; ++index_anim)
{
Matrix3 &max_mat = imesh->_mesh_data[index_anim]._matrix;
float *m = mesh->imd2_matrix[index_anim].m;
MatrixToFloatP(m, max_mat);
}
}
//////////////////////////////////////////////////////////////////////////
// exporting skining information if needed;
if (object.imd2_object_header.have_skin && imesh->_skin)
{
int skinned_vertex = 0;
int count_bones = 0;
// first count all bone linked to this vertex.
int vertex_count = mesh->imd2_mesh_header.num_vertex;
mesh->imd2_skin = new imd2_skin_t[vertex_count];
for (int index_vertex = 0; index_vertex != vertex_count; ++index_vertex)
{
count_bones = 0;
ImportedSkin *skin = imesh->_skin;
ImportedSkin::skin_data_list_t &s_list = skin->_skin_data;
ImportedSkin::skin_data_list_it_t it(s_list.begin());
for (; it != s_list.end(); ++it)
{
std::vector<PointWeight>::iterator it_w(it->second._point_weight.begin());
for (; it_w != it->second._point_weight.end(); ++it_w)
if (it_w->_point_index == index_vertex)
count_bones++;
}
mesh->imd2_skin[index_vertex].num_bones_assigned = count_bones;
mesh->imd2_skin[index_vertex].weight = new imd2_weight_t[count_bones];
count_bones = 0;
it = s_list.begin();
for (; it != s_list.end(); ++it)
{
std::vector<PointWeight>::iterator it_w(it->second._point_weight.begin());
for (; it_w != it->second._point_weight.end(); ++it_w)
if (it_w->_point_index == index_vertex)
{
int bone_index = it->second._bone_index;
mesh->imd2_skin[index_vertex].weight[count_bones].weight = it_w->_weight;
mesh->imd2_skin[index_vertex].weight[count_bones].bone_index = bone_index;
count_bones++;
skinned_vertex++;
}
}
}
mesh->imd2_mesh_header.num_skinned = skinned_vertex;
}
mesh++;
}
}
object.imd2_object_header.num_bones = GetNumBones(ip->GetRootNode());
Loger::Get().Printf("End converting to imd2, Num bones = %d", object.imd2_object_header.num_bones);
}
void ImdExp::ExportImd2Tag(imd2_object_t &object)
{
element_list_it_t it;
// allocate data
object.imd2_tag = new imd2_tag_t[object.imd2_object_header.num_tag];
imd2_tag_t *tag = object.imd2_tag;
memset(tag, 0, object.imd2_object_header.num_tag * sizeof(imd2_tag_t));
for (it = _elements.begin(); it != _elements.end(); ++it)
{
ImportedElements *el = *it;
if (el->_type == tag_element)
{
ImportedTag *itag = (ImportedTag *)el;
strncpy(tag->name, itag->_name.c_str(), IMD2_MAX_NAME - 1);
tag->user_data = new char[itag->_user_properties.size() + 1];
tag->tag_data = new imd2_tag_data_t[object.imd2_object_header.num_anim];
strcpy(tag->user_data, itag->_user_properties.c_str());
for (int index_anim = 0; index_anim < object.imd2_object_header.num_anim; ++index_anim)
{
tag->tag_data[index_anim].pos[0] = itag->_tag_data[index_anim]->_pos.x;
tag->tag_data[index_anim].pos[1] = itag->_tag_data[index_anim]->_pos.y;
tag->tag_data[index_anim].pos[2] = itag->_tag_data[index_anim]->_pos.z;
}
tag++;
}
}
}
void ImdExp::SaveObjectFile(const TCHAR *c_file_name)
{
std::string file_name(c_file_name);
std::string name;
std::string path;
imd2_object_t *object = new imd2_object_t;
memset(object, 0, sizeof(imd2_object_t));
// got path.
_file_name = file_name;
object->imd2_object_header.matrix_sampling = _plugin_config._sample_matrix;
_log->Printf("---------------------------");
name = GetFileNameWithoutExtension(file_name);
_log->Printf("Object name = %s", name.c_str());
path = GetFilePath(file_name);
_log->Printf("Path = %s", path.c_str());
strncpy(object->imd2_object_header.name, name.c_str(), IMD2_MAX_NAME - 1);
object->imd2_object_header.num_anim = _plugin_config._end_frame - _plugin_config._begin_frame + 1;
object->imd2_object_header.num_mesh = CountElementOf(mesh_element);
if (_material_list == 0)
object->imd2_object_header.num_material = 0;
else
{
object->imd2_object_header.num_material = (unsigned short)_material_list->_material_data.size();
object->imd2_material = new imd2_material_t[object->imd2_object_header.num_material];
ExportImd2Material(*object, path);
}
object->imd2_object_header.num_tag = CountElementOf(tag_element);
object->imd2_object_header.num_light = 0; // ountElementOf(light_element); // TODO.
ExportImd2Mesh(*object);
ExportImd2Tag(*object);
save_imd2(object, c_file_name);
free_imd2(object);
}
int ImdExp::GetNumBones(INode *node)
{
int count = 0;
if (IsNodeBone(node))
count += 1;
for (int i = 0; i < node->NumberOfChildren(); i++)
count += GetNumBones(node->GetChildNode(i));
return count;
}
Matrix3 &ImdExp::FixCoordSys(Matrix3 &tm)
{
// swap 2nd and 3rd rows
Point3 row = tm.GetRow(1);
tm.SetRow(1, tm.GetRow(2));
tm.SetRow(2, row);
// swap 2nd and 3rd columns
Point4 column = tm.GetColumn(1);
tm.SetColumn(1, tm.GetColumn(2));
tm.SetColumn(2, column);
tm.SetRow(0, tm.GetRow(0));
tm.SetColumn(0, tm.GetColumn(0));
return tm;
}
Point3 &ImdExp::FixCoordSys(Point3 &pnt)
{
float tmp;
tmp = pnt.y;
pnt.y = pnt.z;
pnt.z = tmp;
return pnt;
}
void ImdExp::RecursiveSaveBone(imd2_bone_file_t *imd2_bone, BoneData *data, int &index, int parent)
{
imd2_bone->bones[index].imd2_bone_header.bone_index = data->_bone_index;
imd2_bone->bones[index].imd2_bone_header.bone_parent = parent;
memset(imd2_bone->bones[index].imd2_bone_header.name, 0, IMD2_MAX_NAME);
strncpy(imd2_bone->bones[index].imd2_bone_header.name, data->_name.c_str(), IMD2_MAX_NAME - 1);
imd2_bone->bones[index].imd2_bone_header.name[IMD2_MAX_NAME - 1] = 0;
int anim_count = imd2_bone->imd2_bone_file_header.anim_count;
imd2_bone->bones[index].imd2_bone_anim = new imd2_bone_anim_t[anim_count];
int parent_index = imd2_bone->bones[index].imd2_bone_header.bone_index;
for (int i = 0; i < anim_count; ++i)
{
imd2_bone_anim_t *anim = &(imd2_bone->bones[index].imd2_bone_anim[i]);
MatrixToFloatP(anim->matrix, data->_animation[i].matrix);
}
index++;
size_t child_count = data->_bone_child.size();
for (size_t b = 0; b < child_count; ++b)
RecursiveSaveBone(imd2_bone, &(data->_bone_child[b]), index, parent_index);
}
void ImdExp::SaveBoneFile(const TCHAR *c_file_name, ImportedBone *bones)
{
int bone_count = GetNumBones(ip->GetRootNode());
imd2_bone_file_t *imd2_bone = new imd2_bone_file_t;
int index = 0;
imd2_bone->imd2_bone_file_header.anim_count = _plugin_config._end_bone_frame - _plugin_config._begin_bone_frame + 1;
imd2_bone->imd2_bone_file_header.bone_count = bone_count;
imd2_bone->bones = new imd2_bone_t[bone_count];
for (size_t i = 0; i < bones->_bone_data.size(); ++i)
{
RecursiveSaveBone(imd2_bone, &(bones->_bone_data[i]), index);
continue;
}
save_imd2_bone(imd2_bone, c_file_name);
free_imd2_bone(imd2_bone);
// count bones.
}
/*
* Main export function
*/
int ImdExp::DoExport(const TCHAR *name, ExpInterface *ei, Interface *i, BOOL suppressPrompts /* =FALSE */, DWORD options /* =0 */)
{
BOOL showPrompts = suppressPrompts ? FALSE : TRUE;
ip = i;
_file_name = name;
_bone_file_name = _file_name.substr(0, _file_name.find_last_of("."));
_bone_file_name += ".imdbone";
LoadConfig();
if (DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_DIALOGCONFIG), ip->GetMAXHWnd(), ExportDlgProc, (LPARAM)this) != IDOK)
return 0;
SaveConfig();
if (_plugin_config._log_window)
{
Loger::Get().Create(hInstance, _plugin_config._dos_log_window);
Loger::Get().Show();
Loger::Get().EnableOk(false);
}
_log = &(Loger::Get());
if (_plugin_config._export_object)
ImportDataFromMax(ip->GetRootNode());
// bones import
if (_plugin_config._export_bones)
{
ImportedBone *bones = ImportBoneData();
if (bones != 0)
{
_elements.push_back(bones);
SaveBoneFile(_bone_file_name.c_str(), bones);
}
}
if (_plugin_config._export_object)
SaveObjectFile(name);
Loger::Get().EnableOk();
FreeAll();
return 1;
} | 33.283133 | 132 | 0.643891 | olivierchatry |
363321ef4049d2b92a142206c5fb7b5af503c479 | 3,571 | hpp | C++ | src/proteus/observation/tracing.hpp | Xilinx/inference-server | 7477b7dc420ce4cd0d7e1d9914b71898e97d6814 | [
"Apache-2.0"
] | 4 | 2021-11-03T21:32:55.000Z | 2022-02-17T17:13:16.000Z | src/proteus/observation/tracing.hpp | Xilinx/inference-server | 7477b7dc420ce4cd0d7e1d9914b71898e97d6814 | [
"Apache-2.0"
] | null | null | null | src/proteus/observation/tracing.hpp | Xilinx/inference-server | 7477b7dc420ce4cd0d7e1d9914b71898e97d6814 | [
"Apache-2.0"
] | 2 | 2022-03-05T20:01:33.000Z | 2022-03-25T06:00:35.000Z | // Copyright 2021 Xilinx Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/**
* @file
* @brief Defines tracing in Proteus
*/
#ifndef GUARD_PROTEUS_OBSERVATION_TRACING
#define GUARD_PROTEUS_OBSERVATION_TRACING
#include <memory> // for shared_ptr, uniqu...
#include <stack> // for stack
#include "proteus/build_options.hpp" // for PROTEUS_ENABLE_TR...
#include "proteus/core/predict_api.hpp" // for RequestParameters
#include "proteus/helpers/declarations.hpp" // for StringMap
// IWYU pragma: no_forward_declare proteus::RequestParameters
#ifdef PROTEUS_ENABLE_TRACING
// opentelemetry needs this definition prior to any header inclusions if the
// library was compiled with this flag set, which it is in the Docker build
#define HAVE_CPP_STDLIB
#include <opentelemetry/common/attribute_value.h> // for AttributeValue
#include <opentelemetry/nostd/shared_ptr.h>
#include <opentelemetry/std/string_view.h> // for string_view
#include <opentelemetry/trace/span.h> // for span
#include <opentelemetry/trace/span_startoptions.h> // for StartSpanOptions
namespace proteus {
/// initialize tracing globally
void startTracer();
/// clean up the tracing prior to shutdown
void stopTracer();
/**
* @brief The Trace object abstracts the details of how tracing is implemented.
* This object should not be created directly (use startTrace()).
*
*/
class Trace final {
public:
explicit Trace(
const char* name,
const opentelemetry::v1::trace::StartSpanOptions& options = {});
~Trace();
Trace(Trace const&) = delete; ///< Copy constructor
Trace& operator=(const Trace&) = delete; ///< Copy assignment constructor
Trace(Trace&& other) = delete; ///< Move constructor
Trace& operator=(Trace&& other) = delete; ///< Move assignment constructor
/// start a new span with the given name
void startSpan(const char* name);
/// set an attribute in the active span in the trace
void setAttribute(opentelemetry::nostd::string_view key,
const opentelemetry::common::AttributeValue& value);
/// set all parameters as attributes in the active span in the trace
void setAttributes(RequestParameters* parameters);
/// ends all spans except the last one and returns its context for propagation
StringMap propagate();
/// Ends the active span in the trace
void endSpan();
/// Ends the trace
void endTrace();
private:
std::stack<opentelemetry::nostd::shared_ptr<opentelemetry::trace::Span>>
spans_;
// std::unique_ptr<opentelemetry::trace::Scope> scope_;
};
using TracePtr = std::unique_ptr<Trace>;
/// Start a trace with the given name
TracePtr startTrace(const char* name);
/**
* @brief Start a trace with context from HTTP headers
*
* @param name name of the trace
* @param http_headers headers from HTTP request to extract context from
* @return TracePtr
*/
TracePtr startTrace(const char* name, const StringMap& http_headers);
} // namespace proteus
#endif
#endif // GUARD_PROTEUS_OBSERVATION_TRACING
| 32.171171 | 80 | 0.724447 | Xilinx |
3635153692425bbee319815b8082362e37273878 | 380 | cpp | C++ | docs/mfc/codesnippet/CPP/cobarray-class_12.cpp | jmittert/cpp-docs | cea5a8ee2b4764b2bac4afe5d386362ffd64e55a | [
"CC-BY-4.0",
"MIT"
] | 14 | 2018-01-28T18:10:55.000Z | 2021-11-16T13:21:18.000Z | docs/mfc/codesnippet/CPP/cobarray-class_12.cpp | jmittert/cpp-docs | cea5a8ee2b4764b2bac4afe5d386362ffd64e55a | [
"CC-BY-4.0",
"MIT"
] | null | null | null | docs/mfc/codesnippet/CPP/cobarray-class_12.cpp | jmittert/cpp-docs | cea5a8ee2b4764b2bac4afe5d386362ffd64e55a | [
"CC-BY-4.0",
"MIT"
] | 2 | 2018-11-01T12:33:08.000Z | 2021-11-16T13:21:19.000Z | CObArray arr;
CAge* pa1;
CAge* pa2;
arr.Add(pa1 = new CAge(21)); // Element 0
arr.Add(pa2 = new CAge(40)); // Element 1
ASSERT(arr.GetSize() == 2);
arr.RemoveAll(); // Pointers removed but objects not deleted.
ASSERT(arr.GetSize() == 0);
delete pa1;
delete pa2; // Cleans up memory. | 34.545455 | 70 | 0.5 | jmittert |
3639fe15dc674230ac5cc6730cbb3b449380b4ff | 20,853 | cpp | C++ | DK/DKFoundation/DKStringW.cpp | Hongtae/DKGL | 0dee0f0e211ad151db3943792ea29979cc8420f6 | [
"BSD-3-Clause"
] | 14 | 2015-09-12T01:32:05.000Z | 2021-10-13T02:52:53.000Z | DK/DKFoundation/DKStringW.cpp | Hongtae/DKGL | 0dee0f0e211ad151db3943792ea29979cc8420f6 | [
"BSD-3-Clause"
] | null | null | null | DK/DKFoundation/DKStringW.cpp | Hongtae/DKGL | 0dee0f0e211ad151db3943792ea29979cc8420f6 | [
"BSD-3-Clause"
] | 3 | 2015-11-10T03:12:49.000Z | 2018-10-15T15:38:31.000Z | //
// File: DKStringW.cpp
// Author: Hongtae Kim (tiff2766@gmail.com)
//
// Copyright (c) 2004-2014 Hongtae Kim. All rights reserved.
//
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <wctype.h>
#include <wchar.h>
#include "DKArray.h"
#include "DKSet.h"
#include "DKStringW.h"
#include "DKStringU8.h"
#include "DKBuffer.h"
#ifdef _WIN32
#define wcstoll _wcstoi64
#define wcstoull _wcstoui64
#endif
#ifdef __ANDROID__
#warning "CHECK 'wcstoll', 'wcstoull' FOR ANDROID!"
long long int wcstoll(const wchar_t* str, wchar_t** endptr, int base)
{
return DKFoundation::DKStringU8(str).ToInteger();
}
unsigned long long int wcstoull(const wchar_t* str, wchar_t** endptr, int base)
{
return DKFoundation::DKStringU8(str).ToUnsignedInteger();
}
#endif
namespace DKFoundation
{
namespace Private
{
namespace
{
const DKStringW::CharacterSet& WhitespaceCharacterSet(void)
{
static const struct WCSet
{
WCSet(void)
{
const DKUniCharW whitespaces[] = {
0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x0020, 0x0085, 0x00a0,
0x1680, 0x180e, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005,
0x2006, 0x2007, 0x2008, 0x2009, 0x200a, 0x2028, 0x2029, 0x202f,
0x205f, 0x3000
};
const size_t numChars = sizeof(whitespaces) / sizeof(DKUniCharW);
set.Insert(whitespaces, numChars);
}
DKStringW::CharacterSet set;
} whitespaceCharacterSet;
return whitespaceCharacterSet.set;
}
inline DKUniCharW LowercaseChar(DKUniCharW c)
{
if (c >= L'A' && c <= L'Z')
c = (c - L'A') + L'a';
return c;
}
inline int CompareCaseInsensitive(const DKUniCharW* a, const DKUniCharW* b)
{
if (a == b)
return 0;
if (a == NULL)
a = L"";
if (b == NULL)
b = L"";
const DKUniCharW *p = a;
const DKUniCharW *q = b;
int cmp = 0;
for ( ; *p || *q; ++p, ++q)
{
cmp = LowercaseChar(*p) - LowercaseChar(*q);
if (cmp != 0)
return cmp;
}
return LowercaseChar(*p) - LowercaseChar(*q);
}
inline int CompareCaseSensitive(const DKUniCharW* a, const DKUniCharW* b)
{
if (a == b)
return 0;
if (a == NULL)
a = L"";
if (b == NULL)
b = L"";
const DKUniCharW *p = a;
const DKUniCharW *q = b;
int cmp = 0;
for ( ; *p || *q; ++p, ++q)
{
cmp = (*p) - (*q);
if (cmp != 0)
return cmp;
}
return (*p) - (*q);
}
}
}
}
using namespace DKFoundation;
const DKStringW& DKStringW::EmptyString()
{
static DKStringW s = L"";
return s;
}
DKStringEncoding DKStringW::SystemEncoding(void)
{
return DKStringWEncoding();
}
// DKStringW class
DKStringW::DKStringW(void)
: stringData(NULL)
{
}
DKStringW::DKStringW(DKStringW&& str)
: stringData(NULL)
{
stringData = str.stringData;
str.stringData = NULL;
}
DKStringW::DKStringW(const DKStringW& str)
: stringData(NULL)
{
this->SetValue(str);
}
DKStringW::DKStringW(const DKUniCharW* str, size_t len)
: stringData(NULL)
{
this->SetValue(str, len);
}
DKStringW::DKStringW(const DKUniChar8* str, size_t len)
: stringData(NULL)
{
this->SetValue(str, len);
}
DKStringW::DKStringW(const void* str, size_t len, DKStringEncoding e)
: stringData(NULL)
{
this->SetValue(str, len, e);
}
DKStringW::DKStringW(DKUniCharW c)
: stringData(NULL)
{
this->SetValue(&c, 1);
}
DKStringW::DKStringW(DKUniChar8 c)
: stringData(NULL)
{
this->SetValue(&c, 1);
}
DKStringW::~DKStringW(void)
{
if (stringData)
DKMemoryHeapFree(stringData);
}
DKStringW DKStringW::Format(const DKUniChar8* fmt, ...)
{
DKStringW ret = L"";
if (fmt && fmt[0])
{
va_list ap;
va_start(ap, fmt);
ret = FormatV(fmt, ap);
va_end(ap);
}
return ret;
}
DKStringW DKStringW::Format(const DKUniCharW* fmt, ...)
{
DKStringW ret = L"";
if (fmt && fmt[0])
{
va_list ap;
va_start(ap, fmt);
ret = FormatV(fmt, ap);
va_end(ap);
}
return ret;
}
DKStringW DKStringW::FormatV(const DKUniChar8* fmt, va_list v)
{
DKStringW ret = L"";
if (fmt && fmt[0])
{
#ifdef __GNUC__
va_list v2;
va_copy(v2, v);
DKStringFormatV(ret, fmt, v);
va_end(v2);
#else
DKStringFormatV(ret, fmt, v);
#endif
}
return ret;
}
DKStringW DKStringW::FormatV(const DKUniCharW* fmt, va_list v)
{
DKStringW ret = L"";
if (fmt && fmt[0])
{
#ifdef __GNUC__
va_list v2;
va_copy(v2, v);
DKStringFormatV(ret, fmt, v);
va_end(v2);
#else
DKStringFormatV(ret, fmt, v);
#endif
}
return ret;
}
size_t DKStringW::Length(void) const
{
size_t len = 0;
if (stringData)
{
while (stringData[len])
len++;
}
return len;
}
size_t DKStringW::Bytes(void) const
{
return Length() * sizeof(DKUniCharW);
}
long DKStringW::Find(DKUniCharW c, long begin) const
{
if (begin < 0) begin = 0;
const DKUniCharW *data = stringData;
size_t len = Length();
for (long i = begin; i < (long)len; ++i)
{
if (data[i] == c)
return (long)i;
}
return -1;
}
long DKStringW::Find(const DKUniCharW* str, long begin) const
{
if (str == NULL)
return -1;
if (begin < 0) begin = 0;
long strLength = (long)wcslen(str);
long maxLength = (long)Length() - strLength;
for (long i = begin; i <= maxLength; ++i)
{
if (wcsncmp(&stringData[i], str, strLength) == 0)
return (long)i;
}
return -1;
}
long DKStringW::Find(const DKStringW& str, long begin) const
{
return Find((const DKUniCharW*)str, begin);
}
long DKStringW::FindWhitespaceCharacter(long begin) const
{
return FindAnyCharactersInSet(Private::WhitespaceCharacterSet(), begin);
}
long DKStringW::FindAnyCharactersInSet(const CharacterSet& cs, long begin) const
{
if (cs.Count() > 0)
{
size_t len = Length();
for (size_t i = begin; i < len; ++i)
{
if (cs.Contains(this->stringData[i]))
return (long)i;
}
}
return -1;
}
DKStringW DKStringW::Right(long index) const
{
DKStringW string;
size_t len = Length();
if (index < (long)len)
{
if (index < 0)
index = 0;
int count = len - index;
if (count < 0)
count = 0;
DKUniCharW* tmp = (DKUniCharW*)DKMemoryHeapAlloc((len+1) * sizeof(DKUniCharW));
memset(tmp, 0, sizeof(DKUniCharW) * (len+1));
wcsncpy(tmp, &stringData[index], count);
string = tmp;
DKMemoryHeapFree(tmp);
}
return string;
}
DKStringW DKStringW::Left(size_t count) const
{
DKStringW string;
if (count > 0)
{
size_t len = Length();
if (count > len)
count = len;
DKUniCharW* tmp = (DKUniCharW*)DKMemoryHeapAlloc((len+1) * sizeof(DKUniCharW));
memset(tmp, 0 , sizeof(DKUniCharW) * (len+1));
wcsncpy(tmp, stringData, count);
string = tmp;
DKMemoryHeapFree(tmp);
}
return string;
}
DKStringW DKStringW::Mid(long index, size_t count) const
{
DKStringW string = L"";
if (count == 0)
return string;
size_t len = Length();
if (count > 0 && index + count < len)
{
DKUniCharW* buff = (DKUniCharW*)DKMemoryHeapAlloc((count+1) * sizeof(DKUniCharW));
wcsncpy(buff, &stringData[index], count);
buff[count] = 0;
string = buff;
DKMemoryHeapFree(buff);
}
else
{
string = Right(index);
}
return string;
}
DKStringW DKStringW::LowercaseString(void) const
{
if (stringData)
{
DKUniCharW *buff = (DKUniCharW*)DKMemoryHeapAlloc((Length()+1) * sizeof(DKUniCharW));
int i;
for (i = 0 ; stringData[i] != 0; ++i)
{
buff[i] = towlower(stringData[i]);
}
buff[i] = 0;
DKStringW ret = buff;
DKMemoryHeapFree(buff);
return ret;
}
return DKStringW(L"");
}
DKStringW DKStringW::UppercaseString(void) const
{
if (stringData)
{
DKUniCharW *buff = (DKUniCharW*)DKMemoryHeapAlloc((Length()+1) * sizeof(DKUniCharW));
int i;
for (i = 0 ; stringData[i] != 0; ++i)
{
buff[i] = towupper(stringData[i]);
}
buff[i] = 0;
DKStringW ret = buff;
DKMemoryHeapFree(buff);
return ret;
}
return DKStringW(L"");
}
int DKStringW::Compare(const DKUniCharW* str) const
{
return Private::CompareCaseSensitive(stringData, str);
}
int DKStringW::Compare(const DKStringW& str) const
{
return Private::CompareCaseSensitive(stringData, str.stringData);
}
int DKStringW::CompareNoCase(const DKUniCharW* str) const
{
return Private::CompareCaseInsensitive(stringData, str);
}
int DKStringW::CompareNoCase(const DKStringW& str) const
{
return Private::CompareCaseInsensitive(stringData, str.stringData);
}
int DKStringW::Replace(const DKUniCharW c1, const DKUniCharW c2)
{
if (!stringData)
return 0;
if (c1 == c2)
return 0;
int result = 0;
if (c1)
{
if (c2)
{
for (size_t i = 0; stringData[i]; ++i)
{
if (stringData[i] == c1)
{
stringData[i] = c2;
++result;
}
}
}
else
{
size_t len = Length();
DKUniCharW* tmp = (DKUniCharW*)DKMemoryHeapAlloc((len+1) * sizeof(DKUniCharW));
size_t tmpLen = 0;
for (size_t i = 0; stringData[i]; ++i)
{
if (stringData[i] == c1)
++result;
else
tmp[tmpLen++] = stringData[i];
}
tmp[tmpLen] = 0;
this->SetValue(tmp, tmpLen);
DKMemoryHeapFree(tmp);
}
}
return result;
}
int DKStringW::Replace(const DKUniCharW* strOld, const DKUniCharW* strNew)
{
if (strOld == NULL || strOld[0] == 0)
return 0;
size_t len = Length();
if (len == 0)
return 0;
if (strNew == NULL)
strNew = L"";
size_t len1 = (size_t)wcslen(strOld);
if (len < len1)
return 0;
long index = Find(strOld);
if (index < 0)
return 0;
DKStringW prev = Left(index) + strNew;
DKStringW next = Right(index + len1);
int ret = next.Replace(strOld, strNew) + 1;
this->SetValue(prev + next);
return ret;
}
int DKStringW::Replace(const DKStringW& src, const DKStringW& dst)
{
return Replace((const DKUniCharW*)src, (const DKUniCharW*)dst);
}
DKStringW& DKStringW::Insert(long index, const DKUniCharW* str)
{
if (str == NULL)
return *this;
size_t len = Length();
if (index > (long)len)
{
return Append(str);
}
int newStrLen = (int)wcslen(str);
if (newStrLen)
{
DKUniCharW* tmp = (DKUniCharW*)DKMemoryHeapAlloc((len + newStrLen + 4) * sizeof(DKUniCharW));
memset(tmp, 0, sizeof(DKUniCharW) * (len + newStrLen + 4));
if (index > 0)
{
wcsncpy(tmp, stringData, index);
}
wcscat(tmp, str);
wcscat(tmp, &stringData[index]);
this->SetValue(tmp);
DKMemoryHeapFree(tmp);;
}
return *this;
}
DKStringW& DKStringW::Insert(long index, DKUniCharW ch)
{
return Insert(index, (const DKUniCharW*)DKStringW(ch));
}
DKStringW DKStringW::FilePathString(void) const
{
DKStringW str(*this);
#ifdef _WIN32
str.Replace(L'/', L'\\');
#else
str.Replace(L'\\', L'/');
#endif
return str;
}
DKStringW DKStringW::FilePathStringByAppendingPath(const DKStringW& path) const
{
DKStringW str(*this);
str.TrimWhitespaces();
size_t len = str.Length();
if (len > 0)
{
size_t pathLen = path.Length();
if (pathLen > 0)
{
const wchar_t* pathStr = path;
while (pathStr[0] == L'/' || pathStr[0] == L'\\')
pathStr++;
if (pathStr[0])
{
if (str[len - 1] != L'/' && str[len - 1] != L'\\')
{
str.Append(L"/");
}
str.Append(pathStr);
}
}
}
else
{
str = path;
str.TrimWhitespaces();
}
return str.FilePathString();
}
DKStringW DKStringW::LastPathComponent(void) const
{
DKStringW result = L"/";
StringArray strs = PathComponents();
size_t c = strs.Count();
if (c > 0)
result = strs.Value(c - 1);
return result;
}
DKStringW::StringArray DKStringW::PathComponents(void) const
{
CharacterSet cs = {L'/', L'\\'};
return SplitByCharactersInSet(cs, true);
}
bool DKStringW::IsWhitespaceCharacterAtIndex(long index) const
{
DKASSERT_DEBUG(Length() > index);
return Private::WhitespaceCharacterSet().Contains(stringData[index]);
}
DKStringW& DKStringW::TrimWhitespaces(void)
{
size_t len = Length();
if (len == 0)
return *this;
size_t begin = 0;
// finding whitespaces at beginning.
while (begin < len)
{
if (!this->IsWhitespaceCharacterAtIndex(begin))
break;
begin++;
}
if (begin < len)
{
size_t end = len-1;
// finding whitespaces at ending.
while (end > begin)
{
if (!this->IsWhitespaceCharacterAtIndex(end))
break;
end--;
}
if (end >= begin)
{
DKStringW tmp = this->Mid(begin, end - begin + 1);
return SetValue(tmp);
}
}
else
{
// string is whitespaces entirely.
return this->SetValue(L"");
}
return *this;
}
DKStringW& DKStringW::RemoveWhitespaces(long begin, long count)
{
begin = Max(begin, 0);
size_t length = Length();
if (begin >= length)
return *this;
if (count < 0)
count = length - begin;
else
count = Min<long>(length - begin, count);
if (count <= 0)
return *this;
DKUniCharW* buffer = (DKUniCharW*)DKMemoryHeapAlloc((count+2) * sizeof(DKUniCharW));
size_t bufferIndex = 0;
for (long i = 0; i < count; i++)
{
if (!IsWhitespaceCharacterAtIndex(i + begin))
{
buffer[bufferIndex++] = stringData[i+begin];
}
}
buffer[bufferIndex] = NULL;
DKStringW tmp = DKStringW(buffer) + Right(begin + count);
DKMemoryHeapFree(buffer);
return *this = tmp;
}
bool DKStringW::HasPrefix(const DKStringW& str) const
{
return str.Compare(this->Left( str.Length() )) == 0;
}
bool DKStringW::HasSuffix(const DKStringW& str) const
{
return str.Compare(this->Right( this->Length() - str.Length() )) == 0;
}
DKStringW& DKStringW::RemovePrefix(const DKStringW& str)
{
if (HasPrefix(str))
{
this->SetValue( this->Right( str.Length() ) );
}
return *this;
}
DKStringW& DKStringW::RemoveSuffix(const DKStringW& str)
{
if (HasSuffix(str))
{
this->SetValue( this->Left( this->Length() - str.Length()) );
}
return *this;
}
DKStringW& DKStringW::Append(const DKStringW& str)
{
return Append((const DKUniCharW*)str);
}
DKStringW& DKStringW::Append(const DKUniCharW* str, size_t len)
{
if (str && str[0])
{
size_t len1 = Length();
size_t len2 = 0;
for (len2 = 0; str[len2] && len2 < len; len2++) {}
size_t totalLen = len1 + len2;
if (totalLen > 0)
{
DKUniCharW* buff = (DKUniCharW*)DKMemoryHeapAlloc((len1 + len2 + 1) * sizeof(DKUniCharW));
memset(buff, 0, sizeof(DKUniCharW) * (len1 + len2 + 1));
if (stringData && stringData[0])
{
wcscat(buff, stringData);
//wcscat_s(pNewBuff, nLen+nLen2+4, stringData);
}
wcscat(buff, str);
//wcscat_s(pNewBuff, nLen+nLen2+4, str);
if (stringData)
DKMemoryHeapFree(stringData);
stringData = buff;
}
}
return *this;
}
DKStringW& DKStringW::Append(const DKUniChar8* str, size_t len)
{
DKStringW s = L"";
DKStringSetValue(s, str, len);
return this->Append(s);
}
DKStringW& DKStringW::Append(const void* str, size_t bytes, DKStringEncoding e)
{
DKStringW s = L"";
DKStringSetValue(s, str, bytes, e);
return this->Append(s);
}
DKStringW& DKStringW::SetValue(const DKStringW& str)
{
if (str.stringData == this->stringData)
return *this;
if (this->stringData)
DKMemoryHeapFree(this->stringData);
this->stringData = NULL;
size_t len = str.Length();
if (len > 0)
{
DKASSERT_DEBUG(str.stringData != NULL);
this->stringData = (DKUniCharW*)DKMemoryHeapAlloc((len+1) * sizeof(DKUniCharW));
wcscpy(this->stringData, str.stringData);
}
return *this;
}
DKStringW& DKStringW::SetValue(const DKUniCharW* str, size_t len)
{
if (str == stringData && len >= this->Length())
return *this;
DKUniCharW* buff = NULL;
if (str && str[0])
{
for (size_t i = 0; i < len; ++i)
{
if (str[i] == 0)
{
len = i;
break;
}
}
if (len > 0)
{
buff = (DKUniCharW*)DKMemoryHeapAlloc((len+1) * sizeof(DKUniCharW));
memcpy(buff, str, len * sizeof(DKUniCharW));
buff[len] = NULL;
}
}
if (stringData)
DKMemoryHeapFree(stringData);
stringData = buff;
return *this;
}
DKStringW& DKStringW::SetValue(const DKUniChar8* str, size_t len)
{
if (str && str[0])
DKStringSetValue(*this, str, len);
else
SetValue((const DKUniCharW*)NULL, 0);
return *this;
}
DKStringW& DKStringW::SetValue(const void* str, size_t bytes, DKStringEncoding e)
{
DKStringSetValue(*this, str, bytes, e);
return *this;
}
// assignment operators
DKStringW& DKStringW::operator = (DKStringW&& str)
{
if (this != &str)
{
if (stringData)
DKMemoryHeapFree(stringData);
stringData = str.stringData;
str.stringData = NULL;
}
return *this;
}
DKStringW& DKStringW::operator = (const DKStringW& str)
{
if (this != &str)
return this->SetValue(str);
return *this;
}
DKStringW& DKStringW::operator = (const DKUniCharW* str)
{
return this->SetValue(str);
}
DKStringW& DKStringW::operator = (const DKUniChar8* str)
{
return this->SetValue(str);
}
DKStringW& DKStringW::operator = (DKUniCharW ch)
{
return this->SetValue(&ch, 1);
}
DKStringW& DKStringW::operator = (DKUniChar8 ch)
{
return this->SetValue(&ch, 1);
}
// conversion operators
DKStringW::operator const DKUniCharW*(void) const
{
if (this && this->stringData)
return (const DKUniCharW*)this->stringData;
return L"";
}
// concatention operators
DKStringW& DKStringW::operator += (const DKStringW& str)
{
return Append(str);
}
DKStringW& DKStringW::operator += (const DKUniCharW* str)
{
return Append(str);
}
DKStringW& DKStringW::operator += (const DKUniChar8* str)
{
return Append(str);
}
DKStringW& DKStringW::operator += (DKUniCharW ch)
{
return Append(&ch, 1);
}
DKStringW& DKStringW::operator += (DKUniChar8 ch)
{
return Append(&ch, 1);
}
DKStringW DKStringW::operator + (const DKStringW& str) const
{
return DKStringW(*this).Append(str);
}
DKStringW DKStringW::operator + (const DKUniCharW* str) const
{
return DKStringW(*this).Append(str);
}
DKStringW DKStringW::operator + (const DKUniChar8* str) const
{
return DKStringW(*this).Append(str);
}
DKStringW DKStringW::operator + (DKUniCharW c) const
{
return DKStringW(*this).Append(&c, 1);
}
DKStringW DKStringW::operator + (DKUniChar8 c) const
{
return DKStringW(*this).Append(&c, 1);
}
DKObject<DKData> DKStringW::Encode(DKStringEncoding e) const
{
DKObject<DKBuffer> data = DKObject<DKBuffer>::New();
DKStringEncode(data, *this, e);
return data.SafeCast<DKData>();
}
long long DKStringW::ToInteger(void) const
{
if (stringData && stringData[0])
return wcstoll(stringData, 0, 0);
return 0LL;
}
unsigned long long DKStringW::ToUnsignedInteger(void) const
{
if (stringData && stringData[0])
return wcstoull(stringData, 0, 0);
return 0ULL;
}
double DKStringW::ToRealNumber(void) const
{
if (stringData && stringData[0])
return wcstod(stringData, 0);
return 0.0;
}
DKStringW::IntegerArray DKStringW::ToIntegerArray(const DKStringW& delimiter, bool ignoreEmptyString) const
{
StringArray strings = Split(delimiter, ignoreEmptyString);
IntegerArray result;
result.Reserve(strings.Count());
for (size_t i = 0; i < strings.Count(); ++i)
result.Add(strings.Value(i).ToInteger());
return result;
}
DKStringW::UnsignedIntegerArray DKStringW::ToUnsignedIntegerArray(const DKStringW& delimiter, bool ignoreEmptyString) const
{
StringArray strings = Split(delimiter, ignoreEmptyString);
UnsignedIntegerArray result;
result.Reserve(strings.Count());
for (size_t i = 0; i < strings.Count(); ++i)
result.Add(strings.Value(i).ToUnsignedInteger());
return result;
}
DKStringW::RealNumberArray DKStringW::ToRealNumberArray(const DKStringW& delimiter, bool ignoreEmptyString) const
{
StringArray strings = Split(delimiter, ignoreEmptyString);
RealNumberArray result;
result.Reserve(strings.Count());
for (size_t i = 0; i < strings.Count(); ++i)
result.Add(strings.Value(i).ToRealNumber());
return result;
}
DKStringW::StringArray DKStringW::Split(const DKStringW& delimiter, bool ignoreEmptyString) const
{
StringArray strings;
size_t len = Length();
size_t dlen = delimiter.Length();
if (dlen == 0)
{
strings.Add(*this);
return strings;
}
long begin = 0;
while (begin < len)
{
long next = this->Find(delimiter, begin);
if (next >= begin)
{
DKStringW subString = this->Mid(begin, next - begin);
if (ignoreEmptyString == false || subString.Length() > 0)
strings.Add(this->Mid(begin, next - begin));
begin = next + dlen;
}
else
{
DKStringW subString = this->Right(begin);
if (subString.Length() > 0)
strings.Add(subString);
break;
}
}
return strings;
}
DKStringW::StringArray DKStringW::SplitByCharactersInSet(const CharacterSet& cs, bool ignoreEmptyString) const
{
StringArray strings;
size_t len = Length();
size_t numCs = cs.Count();
if (numCs == 0)
{
strings.Add(*this);
return strings;
}
long begin = 0;
while (begin < len)
{
long next = this->FindAnyCharactersInSet(cs, begin);
if (next >= begin)
{
DKStringW subString = this->Mid(begin, next - begin);
if (ignoreEmptyString == false || subString.Length() > 0)
strings.Add(subString);
begin = next + 1;
}
else
{
DKStringW subString = this->Right(begin);
if (subString.Length() > 0)
strings.Add(subString);
break;
}
}
return strings;
}
DKStringW::StringArray DKStringW::SplitByWhitespace(void) const
{
return SplitByCharactersInSet(Private::WhitespaceCharacterSet(), true);
}
| 19.525281 | 123 | 0.659617 | Hongtae |
363a201147aa5ae98710b3a407578705b3b99b50 | 1,709 | cpp | C++ | src/Background.cpp | valvy/BlockSnake | c4f0f99617d4976a37ca4e93cefe7ccdbca05a1c | [
"BSD-2-Clause"
] | 2 | 2021-06-28T12:00:57.000Z | 2021-06-28T23:46:31.000Z | src/Background.cpp | valvy/BlockSnake | c4f0f99617d4976a37ca4e93cefe7ccdbca05a1c | [
"BSD-2-Clause"
] | null | null | null | src/Background.cpp | valvy/BlockSnake | c4f0f99617d4976a37ca4e93cefe7ccdbca05a1c | [
"BSD-2-Clause"
] | null | null | null | #include "Background.hpp"
#include "Math/Matrix4x4.hpp"
#include "Math/Utilities.hpp"
Background::Background(AssetManager* assetManager,std::string texture){
this->assetManager = assetManager;
this->texture = assetManager->loadTexture("./Assets/Textures/" + texture);
this->doesCollide = false;
this->primitive = this->assetManager->loadQuad();
this->backGroundProgram = this->assetManager->loadProgram("./Assets/Shaders/BackgroundV.glsl", "./Assets/Shaders/BackgroundF.glsl");
this->mv_location = this->assetManager->getUniformLocation(this->backGroundProgram, "mv_matrix");
this->position = Vector3f(0,0,-2);
this->scale = Vector3f(2,2,2);
this->rotation = Vector3f(0,180,0);
}
void Background::update(float tpf){
}
void Background::draw(float aspect){
//Start with an identity matrix
Matrix4x4<GLfloat> cubeMatrix;
//scale it
cubeMatrix.scale(this->scale);
//Transpone the matrix
cubeMatrix = cubeMatrix.transpose();
//Add a new matrix and rotate it
Matrix4x4<GLfloat> rotation;
rotation.rotate(180, Axis::Y);
//Multiply it
cubeMatrix *= rotation;
cubeMatrix.setPosition(this->position);
cubeMatrix = cubeMatrix.transpose();//You have to transpose the matrix
//Add this for a perspective view
cubeMatrix *= Math::perspective<GLfloat>(50, aspect , 0.1f, 100000.0f);
//Actually render the background
this->assetManager->useProgram(this->backGroundProgram);
this->assetManager->bindTexture(this->texture);
glUniformMatrix4fv(this->mv_location, 1, GL_FALSE, &cubeMatrix.getRawData()[0]);
this->assetManager->renderPrimitive(this->primitive);
}
| 30.517857 | 136 | 0.693973 | valvy |
363b6761c2d571e3c8242874aae14ffecb346baa | 6,677 | cpp | C++ | Lambgine/lua/LambLua.cpp | lambage/Lambgine | e59836015469db797ef4706e42f65bebecfd86df | [
"MIT"
] | null | null | null | Lambgine/lua/LambLua.cpp | lambage/Lambgine | e59836015469db797ef4706e42f65bebecfd86df | [
"MIT"
] | null | null | null | Lambgine/lua/LambLua.cpp | lambage/Lambgine | e59836015469db797ef4706e42f65bebecfd86df | [
"MIT"
] | null | null | null | #include <stdafx.h>
#include "LambLua.h"
#include <Lambgine.h>
extern "C" {
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
}
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "LuaTest.h"
#include <luacppinterface.h>
#define EXIT_CONDITION -2
#if !defined(LUA_PROMPT)
#define LUA_PROMPT "> "
#define LUA_PROMPT2 ">> "
#endif
#define LUA_PROGNAME "lua"
#define LUA_MAXINPUT 512
#include <io.h>
#include <stdio.h>
#define lua_stdin_is_tty() _isatty(_fileno(stdin))
#define lua_readline(L,b,p) \
((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \
fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */
#define lua_saveline(L,idx) { (void)L; (void)idx; }
#define lua_freeline(L,b) { (void)L; (void)b; }
#include <stdio.h>
#define luai_writestring(s,l) fwrite((s), sizeof(char), (l), stdout)
#define luai_writeline() (luai_writestring("\n", 1), fflush(stdout))
static lua_State *globalL = NULL;
static const char *progname = LUA_PROGNAME;
/* mark in error messages for incomplete statements */
#define EOFMARK "<eof>"
#define marklen (sizeof(EOFMARK)/sizeof(char) - 1)
struct LambLua::LambLuaImpl
{
std::shared_ptr<lua_State> L = nullptr;
Lua lua;
LambLuaImpl() :
L(luaL_newstate(), lua_close),
lua(L)
{
lua.LoadStandardLibraries();
OpenTest(&lua);
}
~LambLuaImpl()
{
if (L.get() != nullptr)
{
lua_close(L.get());
}
}
static void lstop(lua_State *L, lua_Debug *ar) {
(void)ar; /* unused arg. */
lua_sethook(L, NULL, 0, 0);
luaL_error(L, "interrupted!");
}
static void laction(int i) {
signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
terminate process (default action) */
lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
}
static void l_message(const char *pname, const char *msg) {
if (pname) luai_writestringerror("%s: ", pname);
luai_writestringerror("%s\n", msg);
}
static int report(lua_State *L, int status) {
if (status != LUA_OK && !lua_isnil(L, -1)) {
const char *msg = lua_tostring(L, -1);
if (msg == NULL) msg = "(error object is not a string)";
l_message(progname, msg);
lua_pop(L, 1);
/* force a complete garbage collection in case of errors */
lua_gc(L, LUA_GCCOLLECT, 0);
}
return status;
}
/* the next function is called unprotected, so it must avoid errors */
static void finalreport(lua_State *L, int status) {
if (status != LUA_OK) {
const char *msg = (lua_type(L, -1) == LUA_TSTRING) ? lua_tostring(L, -1)
: NULL;
if (msg == NULL) msg = "(error object is not a string)";
l_message(progname, msg);
lua_pop(L, 1);
}
}
static int traceback(lua_State *L) {
const char *msg = lua_tostring(L, 1);
if (msg)
luaL_traceback(L, L, msg, 1);
else if (!lua_isnoneornil(L, 1)) { /* is there an error object? */
if (!luaL_callmeta(L, 1, "__tostring")) /* try its 'tostring' metamethod */
lua_pushliteral(L, "(no error message)");
}
return 1;
}
static int docall(lua_State *L, int narg, int nres) {
int status;
int base = lua_gettop(L) - narg; /* function index */
lua_pushcfunction(L, traceback); /* push traceback function */
lua_insert(L, base); /* put it under chunk and args */
globalL = L; /* to be available to 'laction' */
signal(SIGINT, laction);
status = lua_pcall(L, narg, nres, base);
signal(SIGINT, SIG_DFL);
lua_remove(L, base); /* remove traceback function */
return status;
}
static const char *get_prompt(lua_State *L, int firstline) {
const char *p;
lua_getglobal(L, firstline ? "_PROMPT" : "_PROMPT2");
p = lua_tostring(L, -1);
if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
return p;
}
static int incomplete(lua_State *L, int status) {
if (status == LUA_ERRSYNTAX) {
size_t lmsg;
const char *msg = lua_tolstring(L, -1, &lmsg);
if (lmsg >= marklen && strcmp(msg + lmsg - marklen, EOFMARK) == 0) {
lua_pop(L, 1);
return 1;
}
}
return 0; /* else... */
}
static int pushline(lua_State *L, int firstline) {
char buffer[LUA_MAXINPUT];
char *b = buffer;
size_t l;
const char *prmt = get_prompt(L, firstline);
int readstatus = lua_readline(L, b, prmt);
lua_pop(L, 1); /* remove result from 'get_prompt' */
if (readstatus == 0)
return 0; /* no input */
l = strlen(b);
if (l > 0 && b[l - 1] == '\n') /* line ends with newline? */
b[l - 1] = '\0'; /* remove it */
if (firstline && b[0] == '=') /* first line starts with `=' ? */
lua_pushfstring(L, "return %s", b + 1); /* change it to `return' */
else
lua_pushstring(L, b);
lua_freeline(L, b);
return 1;
}
static int loadline(lua_State *L) {
int status;
lua_settop(L, 0);
if (!pushline(L, 1))
return -1; /* no input */
for (;;) { /* repeat until gets a complete line */
size_t l;
const char *line = lua_tolstring(L, 1, &l);
if (strcmp(line, "q") == 0 || strcmp(line, "exit") == 0 || strcmp(line, "quit") == 0 || strcmp(line, "qut") == 0)
{
return EXIT_CONDITION;
}
status = luaL_loadbuffer(L, line, l, "=stdin");
if (!incomplete(L, status)) break; /* cannot try to add lines? */
if (!pushline(L, 0)) /* no more input? */
return -1;
lua_pushliteral(L, "\n"); /* add a new line... */
lua_insert(L, -2); /* ...between the two lines */
lua_concat(L, 3); /* join them */
}
lua_saveline(L, 1);
lua_remove(L, 1); /* remove line */
return status;
}
int DoTerminal()
{
int status;
const char *oldprogname = progname;
progname = NULL;
while ((status = loadline(L.get())) != -1) {
if (status == EXIT_CONDITION)
{
lua_settop(L.get(), 0); /* clear stack */
luai_writeline();
progname = oldprogname;
return LUA_OK;
}
if (status == LUA_OK) status = docall(L.get(), 0, LUA_MULTRET);
report(L.get(), status);
if (status == LUA_OK && lua_gettop(L.get()) > 0) { /* any result to print? */
luaL_checkstack(L.get(), LUA_MINSTACK, "too many results to print");
lua_getglobal(L.get(), "print");
lua_insert(L.get(), 1);
if (lua_pcall(L.get(), lua_gettop(L.get()) - 1, 0, 0) != LUA_OK)
l_message(progname, lua_pushfstring(L.get(),
"error calling " LUA_QL("print") " (%s)",
lua_tostring(L.get(), -1)));
}
}
lua_settop(L.get(), 0); /* clear stack */
luai_writeline();
progname = oldprogname;
return status;
}
};
LAMBGINE_API LambLua::LambLua() :
mImpl(std::make_unique<LambLua::LambLuaImpl>())
{
}
LAMBGINE_API LambLua::~LambLua()
{
}
LAMBGINE_API lua_State* LambLua::GetLuaState()
{
return mImpl->L.get();
}
LAMBGINE_API int LambLua::DoTerminal()
{
return mImpl->DoTerminal();
} | 25.779923 | 116 | 0.62603 | lambage |
364297fd6ce094d48185ede26f277e964433fe8c | 163 | hpp | C++ | src/components/tower_preview.hpp | Green-Sky/miniTD | b710c0e312dcd44ed3ac797c9b7931ab54972c3a | [
"MIT"
] | 7 | 2022-01-27T17:11:23.000Z | 2022-03-29T12:09:26.000Z | src/components/tower_preview.hpp | Green-Sky/miniTD | b710c0e312dcd44ed3ac797c9b7931ab54972c3a | [
"MIT"
] | null | null | null | src/components/tower_preview.hpp | Green-Sky/miniTD | b710c0e312dcd44ed3ac797c9b7931ab54972c3a | [
"MIT"
] | null | null | null | #pragma once
#include <cstdint>
namespace mini_td::Components {
struct TowerPreview {
float time_accu {0.f};
uint16_t art {0};
};
} // mini_td::Components
| 10.866667 | 31 | 0.693252 | Green-Sky |
364335c36bf3950bbae30ecb3de2a02fc08fe70b | 14,954 | cpp | C++ | cpp_project/problem-set/TradeMachingGithub.cpp | sinomiko/project | 00fadb0033645f103692f5b06c861939a9d4aa0e | [
"BSD-3-Clause"
] | 1 | 2018-12-30T14:07:42.000Z | 2018-12-30T14:07:42.000Z | cpp_project/problem-set/TradeMachingGithub.cpp | sinomiko/project | 00fadb0033645f103692f5b06c861939a9d4aa0e | [
"BSD-3-Clause"
] | null | null | null | cpp_project/problem-set/TradeMachingGithub.cpp | sinomiko/project | 00fadb0033645f103692f5b06c861939a9d4aa0e | [
"BSD-3-Clause"
] | null | null | null | #include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <string>
#include <bitset>
#include <cstdio>
#include <limits>
#include <vector>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <numeric>
#include <sstream>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <unordered_map>
using namespace std;
#define DONE 10
#define IOC 11
#define GFD 12
#define CANCEL 0
#define PRINT 1
#define BUY 2
#define SELL 3
#define MODIFY 4
#define COMMAND_SIZE 6
#define COMMAND_INDEX 0
#define ORDER_ID_INDEX_IN_BUY 4
#define ORDER_TYPE_INDEX_IN_BUY 1
#define ORDER_PRICE_INDEX_IN_BUY 2
#define ORDER_QUANTITY_INDEX_IN_BUY 3
#define ORDER_ID_INDEX_IN_SELL 4
#define ORDER_TYPE_INDEX_IN_SELL 1
#define ORDER_PRICE_INDEX_IN_SELL 2
#define ORDER_QUANTITY_INDEX_IN_SELL 3
#define ORDER_ID_IN_CANCEL 1
#define ORDER_ID_IN_MODIFY 1
#define ORDER_TYPE_IN_MODIFY 2
#define ORDER_PRICE_IN_MODIFY 3
#define ORDER_QUANTITY_IN_MODIFY 4
struct Order {
string id;
int type;
int price;
int quantity;
};
struct Action {
int action_type;
Order action_input;
};
struct Trade {
Order trade_1;
Order trade_2;
};
namespace Data {
vector<Trade> trades;
map<int, list<Order> > order_index_buy;
map<int, list<Order> > order_index_sell;
map<string, Order> order_buy;
map<string, Order> order_sell;
int in_order_map(map<string, Order> &map_order, Order order) {
return map_order.count(order.id);
}
int merge_order(map<string, Order> &map_order, Order order) {
if (map_order.count(order.id)) {
Order order_already_in = map_order[order.id];
map_order[order.id] = order;
}
else
map_order.insert(pair<string, Order>(order.id, order));
return 0;
}
int add_order_index(map<int, list<Order> > &map_list_order, Order order) {
if (map_list_order.count(order.price)) {
map_list_order[order.price].push_back(order);
}
else {
list<Order> order_list;
order_list.push_back(order);
map_list_order.insert(pair<int, list<Order> >(order.price, order_list));
}
return 0;
}
int add_buy(Order order) {
if (!in_order_map(order_buy, order)) {
merge_order(order_buy, order);
if (order.type == GFD)
add_order_index(order_index_buy, order);
return 0;
}
return 1;
}
int add_sell(Order order) {
if (!in_order_map(order_sell, order)) {
merge_order(order_sell, order);
if (order.type == GFD)
add_order_index(order_index_sell, order);
return 0;
}
return 1;
}
bool compare_up(int a, int b) {
return a<b;
}
bool compare_down(int a, int b) {
return a>b;
}
Trade make_trade(Order trade_1, Order trade_2) {
cout << "TRADE " << trade_1.id << " " << trade_1.price << " " << trade_1.quantity << " " << trade_2.id << " " << trade_2.price << " " << trade_2.quantity << endl;
struct Trade result = {
trade_1,
trade_2
};
return result;
}
Order do_buy(Order &order) {
vector<int> prices;
for (map< int, list<Order> >::iterator orders = order_index_sell.begin(); orders != order_index_sell.end(); ++orders) {
prices.push_back(orders->first);
}
sort(prices.begin(), prices.end(), compare_down);
for (vector<int>::iterator price = prices.begin(); price != prices.end(); ++price) {
for (list<Order>::iterator sell_order = order_index_sell[*price].begin(); sell_order != order_index_sell[*price].end(); ) {
if ((sell_order->quantity > order.quantity) && (sell_order->price <= order.price) && order.quantity > 0) {
// frash order list
sell_order->quantity -= order.quantity;
// frash order map
order_sell[sell_order->id].quantity = sell_order->quantity;
struct Order s_order = {
sell_order->id,
sell_order->type,
sell_order->price,
order.quantity
};
//frash trades list
trades.push_back(make_trade(s_order, order));
order.quantity = 0;
}
if ((sell_order->quantity <= order.quantity) && (sell_order->price <= order.price)) {
struct Order s_order = {
order.id,
order.type,
order.price,
sell_order->quantity
};
//frash trades list
trades.push_back(make_trade(*sell_order, s_order));
// frash order status
order.quantity -= sell_order->quantity;
// frash order list
sell_order->quantity = 0;
// frash order map
order_sell[sell_order->id].quantity = sell_order->quantity;
order_sell[sell_order->id].type = DONE;
}
if (sell_order->quantity == 0)
sell_order = order_index_sell[*price].erase(sell_order);
else
++sell_order;
if (order.quantity == 0) {
// frash order status
order.type = DONE;
return order;
}
}
}
return order;
}
Order do_sell(Order order) {
vector<int> prices;
for (map< int, list<Order> >::iterator orders = order_index_buy.begin(); orders != order_index_buy.end(); ++orders) {
prices.push_back(orders->first);
}
sort(prices.begin(), prices.end(), compare_down);
for (vector<int>::iterator price = prices.begin(); price != prices.end(); ++price) {
for (list<Order>::iterator buy_order = order_index_buy[*price].begin(); buy_order != order_index_buy[*price].end(); ) {
if ((buy_order->quantity > order.quantity) && (buy_order->price >= order.price) && order.quantity > 0) {
// frash order list
buy_order->quantity -= order.quantity;
// frash order map
order_buy[buy_order->id].quantity = buy_order->quantity;
struct Order b_order = {
buy_order->id,
buy_order->type,
buy_order->price,
order.quantity
};
//frash trades list
trades.push_back(make_trade(b_order, order));
order.quantity = 0;
}
if ((buy_order->quantity <= order.quantity) && (buy_order->price >= order.price)) {
struct Order b_order = {
order.id,
order.type,
order.price,
buy_order->quantity
};
//frash trades list
trades.push_back(make_trade(*buy_order, b_order));
// frash order status
order.quantity -= buy_order->quantity;
// frash order list
buy_order->quantity = 0;
// frash order map
order_buy[buy_order->id].quantity = buy_order->quantity;
order_buy[buy_order->id].type = DONE;
}
if (buy_order->quantity == 0)
buy_order = order_index_buy[*price].erase(buy_order);
else
++buy_order;
if (order.quantity == 0) {
// frash order status
order.type = DONE;
return order;
}
}
}
return order;
}
int do_modify(Order order) {
if (in_order_map(order_buy, order)) {
Order old_order = order_buy[order.id];
// remove from list
for (list<Order>::iterator buy_order = order_index_buy[old_order.price].begin(); buy_order != order_index_buy[old_order.price].end(); ) {
if (buy_order->id == old_order.id)
buy_order = order_index_buy[buy_order->price].erase(buy_order);
else
++buy_order;
}
// remove form map
order_buy.erase(order.id);
return 0;
}
if (in_order_map(order_sell, order)) {
Order old_order = order_sell[order.id];
// remove from list
for (list<Order>::iterator sell_order = order_index_sell[old_order.price].begin(); sell_order != order_index_sell[old_order.price].end(); ) {
if (sell_order->id == old_order.id)
sell_order = order_index_buy[sell_order->price].erase(sell_order);
else
++sell_order;
}
// remove form map
order_sell.erase(order.id);
return 0;
}
return 0;
}
int do_cancel(Order order) {
if (in_order_map(order_buy, order)) {
Order old_order = order_buy[order.id];
// remove from list
for (list<Order>::iterator buy_order = order_index_buy[old_order.price].begin(); buy_order != order_index_buy[old_order.price].end(); ) {
if (buy_order->id == old_order.id)
buy_order = order_index_buy[old_order.price].erase(buy_order);
else
++buy_order;
}
order_buy[order.id].quantity = 0;
order_buy[order.id].type = DONE;
}
if (in_order_map(order_sell, order)) {
Order old_order = order_sell[order.id];
// remove from list
for (list<Order>::iterator sell_order = order_index_sell[old_order.price].begin(); sell_order != order_index_sell[old_order.price].end(); ) {
if (sell_order->id == old_order.id)
sell_order = order_index_sell[sell_order->price].erase(sell_order);
else
++sell_order;
}
order_sell[order.id].quantity = 0;
order_sell[order.id].type = DONE;
}
return 0;
}
int do_print(Order) {
cout << "SELL:" << endl;
for (map< int, list<Order> >::iterator orders = order_index_sell.begin(); orders != order_index_sell.end(); ++orders) {
int all_quantity = 0;
for (list<Order>::iterator sell_order = orders->second.begin(); sell_order != orders->second.end(); sell_order++) {
all_quantity += sell_order->quantity;
}
if (all_quantity > 0)
cout << orders->first << " " << all_quantity << endl;
}
cout << "BUY:" << endl;
for (map< int, list<Order> >::reverse_iterator orders = order_index_buy.rbegin(); orders != order_index_buy.rend(); ++orders) {
int all_quantity = 0;
for (list<Order>::iterator buy_order = orders->second.begin(); buy_order != orders->second.end(); buy_order++) {
all_quantity += buy_order->quantity;
}
if (all_quantity > 0)
cout << orders->first << " " << all_quantity << endl;
}
return 0;
}
};
bool is_digits(const std::string &str)
{
return all_of(str.begin(), str.end(), ::isdigit);
}
Action buy_action_build(vector<string> words) {
Action result;
result.action_type = BUY;
struct Order order = {
words[ORDER_ID_INDEX_IN_BUY],
0,
is_digits(words[ORDER_PRICE_INDEX_IN_BUY]) ? stoi(words[ORDER_PRICE_INDEX_IN_BUY]) : 0,
is_digits(words[ORDER_QUANTITY_INDEX_IN_BUY]) ? stoi(words[ORDER_QUANTITY_INDEX_IN_BUY]) : 0
};
if (words[ORDER_TYPE_INDEX_IN_BUY] == "IOC")
order.type = IOC;
if (words[ORDER_TYPE_INDEX_IN_BUY] == "GFD")
order.type = GFD;
result.action_input = order;
return result;
}
Action sell_action_build(vector<string> words) {
Action result;
result.action_type = SELL;
struct Order order = {
words[ORDER_ID_INDEX_IN_SELL],
0,
is_digits(words[ORDER_PRICE_INDEX_IN_SELL]) ? stoi(words[ORDER_PRICE_INDEX_IN_SELL]) : 0,
is_digits(words[ORDER_QUANTITY_INDEX_IN_SELL]) ? stoi(words[ORDER_QUANTITY_INDEX_IN_SELL]) : 0
};
if (words[ORDER_TYPE_INDEX_IN_SELL] == "IOC")
order.type = IOC;
if (words[ORDER_TYPE_INDEX_IN_SELL] == "GFD")
order.type = GFD;
result.action_input = order;
return result;
}
Action cancel_action_build(vector<string> words) {
Action result;
result.action_type = CANCEL;
struct Order order = {
words[ORDER_ID_IN_CANCEL],
0,
0,
0,
};
result.action_input = order;
return result;
}
Action modify_action_build(vector<string> words) {
Action result;
result.action_type = MODIFY;
struct Order order = {
words[ORDER_ID_IN_MODIFY],
0,
is_digits(words[ORDER_PRICE_IN_MODIFY]) ? stoi(words[ORDER_PRICE_IN_MODIFY]) : 0,
is_digits(words[ORDER_QUANTITY_IN_MODIFY]) ? stoi(words[ORDER_QUANTITY_IN_MODIFY]) : 0
};
if (words[ORDER_TYPE_IN_MODIFY] == "BUY")
order.type = BUY;
if (words[ORDER_TYPE_IN_MODIFY] == "SELL")
order.type = SELL;
result.action_input = order;
return result;
}
Action print_action_build(vector<string> words) {
Action result;
result.action_type = PRINT;
return result;
}
Action input_analysis(std::string section) {
Action result;
istringstream iss(section), end;
vector<string> words(COMMAND_SIZE);
copy(istream_iterator<string>(iss), istream_iterator<string>(end), words.begin());
if (words[COMMAND_INDEX] == "BUY")
result = buy_action_build(words);
if (words[COMMAND_INDEX] == "SELL")
result = sell_action_build(words);
if (words[COMMAND_INDEX] == "CANCEL")
result = cancel_action_build(words);
if (words[COMMAND_INDEX] == "MODIFY")
result = modify_action_build(words);
if (words[COMMAND_INDEX] == "PRINT")
result = print_action_build(words);
return result;
}
int buy_process(Action action) {
if (!Data::in_order_map(Data::order_buy, action.action_input) && !Data::in_order_map(Data::order_sell, action.action_input)) {
struct Order order = Data::do_buy(action.action_input);
if (order.type != IOC)
Data::add_buy(order);
}
return 0;
}
int sell_process(Action action) {
if (!Data::in_order_map(Data::order_sell, action.action_input) && !Data::in_order_map(Data::order_buy, action.action_input)) {
struct Order order = Data::do_sell(action.action_input);
if (order.type != IOC)
Data::add_sell(order);
}
return 0;
}
int cancel_process(Action action) {
Data::do_cancel(action.action_input);
return 0;
}
int modify_process(Action action) {
Data::do_modify(action.action_input);
if (action.action_input.type == BUY) {
struct Order order = Data::do_buy(action.action_input);
if (order.type == BUY) {
if (order.price != 0)
order.type = GFD;
else
order.type = DONE;
Data::add_buy(order);
}
}
if (action.action_input.type == SELL) {
struct Order order = Data::do_sell(action.action_input);
if (order.type == SELL) {
if (order.price != 0)
order.type = GFD;
else
order.type = DONE;
Data::add_sell(order);
}
}
return 0;
}
int print_process(Action action) {
Data::do_print(action.action_input);
return 0;
}
int action_process(Action action) {
int result = 0;
if (action.action_type == BUY)
result = buy_process(action);
if (action.action_type == SELL)
result = sell_process(action);
if (action.action_type == CANCEL)
result = cancel_process(action);
if (action.action_type == MODIFY)
result = modify_process(action);
if (action.action_type == PRINT)
result = print_process(action);
return result;
}
int main() {
/* Enter your code here. Read input from STDIN. Print output to STDOUT */
string section;
while (getline(cin, section)) {
Action ac = input_analysis(section);
int result = action_process(ac);
}
return 0;
}
| 29.848303 | 166 | 0.635415 | sinomiko |
364a380c82e0b3bcd721ef5f9dbe562cc00723b6 | 2,761 | hpp | C++ | include/eve/function/fdim.hpp | leha-bot/eve | 30e7a7f6bcc5cf524a6c2cc624234148eee847be | [
"MIT"
] | 340 | 2020-09-16T21:12:48.000Z | 2022-03-28T15:40:33.000Z | include/eve/function/fdim.hpp | leha-bot/eve | 30e7a7f6bcc5cf524a6c2cc624234148eee847be | [
"MIT"
] | 383 | 2020-09-17T06:56:35.000Z | 2022-03-13T15:58:53.000Z | include/eve/function/fdim.hpp | leha-bot/eve | 30e7a7f6bcc5cf524a6c2cc624234148eee847be | [
"MIT"
] | 28 | 2021-02-27T23:11:23.000Z | 2022-03-25T12:31:29.000Z | //==================================================================================================
/*
EVE - Expressive Vector Engine
Copyright : EVE Contributors & Maintainers
SPDX-License-Identifier: MIT
*/
//==================================================================================================
#pragma once
#include <eve/detail/overload.hpp>
namespace eve
{
//================================================================================================
//! @addtogroup arithmetic
//! @{
//! @var fdim
//!
//! @brief Callable object computing the positive difference.
//!
//! **Required header:** `#include <eve/function/fdim.hpp>`
//!
//! #### Members Functions
//!
//! | Member | Effect |
//! |:-------------|:-----------------------------------------------------------|
//! | `operator()` | the fdim operation |
//! | `operator[]` | Construct a conditional version of current function object |
//!
//! ---
//!
//! ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
//! template< real_value T, real_value U> auto operator()( T x, U y ) const noexcept
//! requires compatible< T, U >;
//! ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//!
//! **Parameters**
//!
//!`x`, `y`: [values](@ref eve::value)
//!
//! **Return value**
//!
//!Returns the [elementwise](@ref glossary_elementwise) positive difference between `x` and `y`:
//! * if `x>y`, x-y is returned
//! * if `x<=y`, +0 is returned
//! * otherwise a `Nan` is returned
//!
//! ---
//!
//! ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
//! auto operator[]( conditional_expression auto cond ) const noexcept;
//! ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//!
//! Higher-order function generating a masked version of eve::fdim
//!
//! **Parameters**
//!
//! `cond` : conditional expression
//!
//! **Return value**
//!
//! A Callable object so that the expression `fdim[cond](x, ...)` is equivalent to `if_else(cond,fdim(x, ...),x)`
//!
//! ---
//!
//! #### Supported decorators
//!
//! * eve::diff<br>
//! **Required header:** `#include <eve/function/diff/fdim.hpp>`
//!
//! The expression `diff_1st(fim)(x,y)` and `diff_2nd(fim)(x,y)` computes the partial
//! derivatives of \f$f\f$, where \f$f\f$ is the function \f$(x,y) \rightarrow \ \max(0,x-y)\f$.
//!
//! #### Example
//!
//! @godbolt{doc/core/fdim.cpp}
//!
//! @}
//================================================================================================
EVE_MAKE_CALLABLE(fdim_, fdim);
}
#include <eve/module/real/core/function/regular/generic/fdim.hpp>
| 32.869048 | 116 | 0.410721 | leha-bot |
36506db240e2bb5b7778bf27e3b97cb1da5ac004 | 1,632 | cpp | C++ | cf/contest/1504/e/e.cpp | woshiluo/oi | 5637fb81b0e25013314783dc387f7fc93bf9d4b9 | [
"Apache-2.0"
] | null | null | null | cf/contest/1504/e/e.cpp | woshiluo/oi | 5637fb81b0e25013314783dc387f7fc93bf9d4b9 | [
"Apache-2.0"
] | null | null | null | cf/contest/1504/e/e.cpp | woshiluo/oi | 5637fb81b0e25013314783dc387f7fc93bf9d4b9 | [
"Apache-2.0"
] | null | null | null | // Woshiluo<woshiluo@woshiluo.site>
// 2021/04/03 22:59:31
// Blog: https://blog.woshiluo.com
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <iostream>
#include <algorithm>
typedef long long ll;
typedef unsigned long long ull;
template <class T>
T Max( T a, T b ) { return a > b? a: b; }
template <class T>
T Min( T a, T b ) { return a < b? a: b; }
template <class T>
void chk_Max( T &a, T b ) { if( b > a ) a = b; }
template <class T>
void chk_Min( T &a, T b ) { if( b < a ) a = b; }
template <typename T>
T read() {
T sum = 0, fl = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fl = -1;
for (; isdigit(ch); ch = getchar()) sum = sum * 10 + ch - '0';
return sum * fl;
}
const int N = 1e5 + 1e4;
const int INF = 0x3f3f3f3f;
struct City {
int id, a, c;
}cities[N];
bool cmp( City _a, City _b ) {
return _a.a < _b.a;
}
struct QNode {
int id, dis;
bool operator< ( const QNode &b ) const {
return this -> dis > b.dis;
}
};
int n;
int f[N];
bool vis[N];
std::vector<int> wait[N];
int fd_nxt( int cur ) {
int cur_a = cities[cur].c + cities[cur].a;
int left = cur + 1, rig = n, res = n + 1;
while( left <= rig ) {
int mid = ( left + rig ) >> 1;
if( cities[mid].a >= cur_a ) {
res = mid;
rig = mid - 1;
}
else
left = mid + 1;
}
return res;
}
int main() {
#ifdef woshiluo
freopen( "e.in", "r", stdin );
freopen( "e.out", "w", stdout );
#endif
scanf( "%d", &n );
for( int i = 1; i <= n; i ++ ) {
scanf( "%d%d", &cities[i].a, &cities[i].c );
cities[i].id = i;
}
std::sort( cities + 1, cities + n + 1, cmp );
}
| 19.2 | 63 | 0.554534 | woshiluo |
3650c0c2a411ab3b0d42845129a929bbbb19f189 | 2,752 | cpp | C++ | oneflow/api/python/functional/common.cpp | MaoXianXin/oneflow | 6caa52f3c5ba11a1d67f183bac4c1559b2a58ef5 | [
"Apache-2.0"
] | null | null | null | oneflow/api/python/functional/common.cpp | MaoXianXin/oneflow | 6caa52f3c5ba11a1d67f183bac4c1559b2a58ef5 | [
"Apache-2.0"
] | null | null | null | oneflow/api/python/functional/common.cpp | MaoXianXin/oneflow | 6caa52f3c5ba11a1d67f183bac4c1559b2a58ef5 | [
"Apache-2.0"
] | null | null | null | /*
Copyright 2020 The OneFlow Authors. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include "oneflow/api/python/functional/common.h"
namespace oneflow {
namespace one {
namespace functional {
namespace detail {
Maybe<void> PySliceUnpack(PyObject* object, Py_ssize_t* start, Py_ssize_t* stop, Py_ssize_t* step) {
PySliceObject* obj = (PySliceObject*)object;
if (obj->step == Py_None) {
*step = 1;
} else {
CHECK_OR_RETURN(_PyEval_SliceIndex(obj->step, step))
<< "Invalid slice " << PyStringAsString(PyObject_Repr(object));
CHECK_NE_OR_RETURN(*step, 0) << "slice step cannot be zero.";
if (*step < -PY_SSIZE_T_MAX) *step = -PY_SSIZE_T_MAX;
}
if (obj->start == Py_None) {
*start = *step < 0 ? PY_SSIZE_T_MAX : 0;
} else {
CHECK_OR_RETURN(_PyEval_SliceIndex(obj->start, start))
<< "Invalid slice " << PyStringAsString(PyObject_Repr(object));
}
if (obj->stop == Py_None) {
*stop = *step < 0 ? PY_SSIZE_T_MIN : PY_SSIZE_T_MAX;
} else {
CHECK_OR_RETURN(_PyEval_SliceIndex(obj->stop, stop))
<< "Invalid slice " << PyStringAsString(PyObject_Repr(object));
}
return Maybe<void>::Ok();
}
const char* PyStringAsString(PyObject* object) {
return PyBytes_AsString(PyUnicode_AsEncodedString(object, "utf-8", "~E~"));
}
Maybe<detail::IndexItem> UnpackIndexItem(PyObject* object) {
if (object == Py_Ellipsis) {
return std::make_shared<detail::IndexItem>(detail::EllipsisIndex{});
} else if (PySlice_Check(object)) {
Py_ssize_t start, end, step;
JUST(PySliceUnpack(object, &start, &end, &step));
return std::make_shared<detail::IndexItem>(start, end, step);
} else if (PyLong_Check(object) && object != Py_False && object != Py_True) {
return std::make_shared<detail::IndexItem>(static_cast<int64_t>(PyLong_AsLongLong(object)));
} else if (object == Py_False || object == Py_True) {
return std::make_shared<detail::IndexItem>(object == Py_True);
} else if (object == Py_None) {
return std::make_shared<detail::IndexItem>(detail::NoneIndex{});
}
UNIMPLEMENTED_THEN_RETURN() << "Invalid index " << PyStringAsString(PyObject_Repr(object));
}
} // namespace detail
} // namespace functional
} // namespace one
} // namespace oneflow
| 35.282051 | 100 | 0.704942 | MaoXianXin |
365131668b894866ab5264ef428ecff74a49cf92 | 2,260 | cpp | C++ | Polynomial/polylist.cpp | eouedraogo4/Polynomial | 2a7adba3119acb162525bf71a813e96e105627b0 | [
"MIT"
] | null | null | null | Polynomial/polylist.cpp | eouedraogo4/Polynomial | 2a7adba3119acb162525bf71a813e96e105627b0 | [
"MIT"
] | null | null | null | Polynomial/polylist.cpp | eouedraogo4/Polynomial | 2a7adba3119acb162525bf71a813e96e105627b0 | [
"MIT"
] | null | null | null | #include "polylist.h"
// Constructors
PolyList::PolyList(PolyList const& other) {
head = new PNode(*other.head);
tail = head->next;
len = other.len;
}
// Destructor
PolyList::~PolyList() {
while (head) {
tail = head;
head = head->next;
delete tail;
}
}
Status PolyList::Push(PolyList& PL, int n) {
Function f = new PNode(n);
f->next = PL.tail;
PL.head->next = f;
PL.tail = f;
PL.len++;
return OK;
}
Function& PolyList::GetFunction(PolyList const& PL, int pos) {
int i = 0;
Function f = PL.head;
while (i++ < pos && f->next != NULL)
f = f->next;
return f;
}
Status PolyList::Display(PolyList const& PL, int i) {
if (i <= 0 || i > PL.len) return ERROR;
Polynomial::Display(GetFunction(PL, i)->data);
return OK;
}
Status PolyList::DisplayAll(PolyList const& PL) {
Function f = PL.tail;
int i = 1;
while (f != NULL) {
std::cout << "f" << i++ << "(x) = "; Polynomial::Display(f->data); std::cout << '\n';
f = f->next;
}
return OK;
}
Function PolyList::Add(Function const& f, Function const& g) {
Function res = new PNode();
res->data = Polynomial::Add(f->data, g->data);
return res;
}
Function PolyList::Sub(Function const& f, Function const& g) {
Function res = new PNode();
res->data = Polynomial::Sub(f->data, g->data);
return res;
}
Function PolyList::Mul(Function const& f, Function const& g) {
Function res = new PNode();
res->data = Polynomial::Mul(f->data, g->data);
return res;
}
Status PolyList::Delete(PolyList& PL, int pos, Polynomial& p) {
if (pos <= 0 || pos > PL.len) return ERROR;
Function f = GetFunction(PL, pos - 1);
Function tmp = f->next;
f = f->next->next;
p = tmp->data;
delete tmp;
PL.tail = PL.head->next;
PL.len--;
return OK;
}
double PolyList::Calculate(PolyList const& PL, int i, int x, Function& f) {
if (i <= 0 || i > PL.len) return 0;
f = GetFunction(PL, i);
return Polynomial::Image(f->data,x);
}
Function PolyList::Derivative(PolyList const& PL, int i, Function& f) {
if (i <= 0 || i > PL.len) return ERROR;
f = GetFunction(PL, i);
return new PNode(Polynomial::Derivative(f->data));
} | 24.565217 | 93 | 0.582743 | eouedraogo4 |
3653cc0b5e6fea3c18e6fd4a1e824a64bd097e8f | 8,703 | cpp | C++ | stratum/job.cpp | now2more/yiimp | 3506d3b0b8304e020d4ae01d11149ff6e49836c3 | [
"MIT"
] | 15 | 2018-01-12T16:21:45.000Z | 2021-04-28T19:20:51.000Z | stratum/job.cpp | now2more/yiimp | 3506d3b0b8304e020d4ae01d11149ff6e49836c3 | [
"MIT"
] | 7 | 2021-04-29T23:11:30.000Z | 2022-01-17T09:33:13.000Z | stratum/job.cpp | now2more/yiimp | 3506d3b0b8304e020d4ae01d11149ff6e49836c3 | [
"MIT"
] | 28 | 2020-11-07T02:28:52.000Z | 2022-03-13T01:56:13.000Z |
#include "stratum.h"
//client->difficulty_remote = 0;
//debuglog(" returning %x, %s, %s\n", job->id, client->sock->ip, #condition); \
#define RETURN_ON_CONDITION(condition, ret) \
if(condition) \
{ \
return ret; \
}
static bool job_assign_client(YAAMP_JOB *job, YAAMP_CLIENT *client, double maxhash)
{
RETURN_ON_CONDITION(client->deleted, true);
RETURN_ON_CONDITION(client->jobid_next, true);
RETURN_ON_CONDITION(client->jobid_locked && client->jobid_locked != job->id, true);
RETURN_ON_CONDITION(client_find_job_history(client, job->id), true);
RETURN_ON_CONDITION(maxhash > 0 && job->speed + client->speed > maxhash, true);
if(!g_autoexchange && maxhash >= 0. && client->coinid != job->coind->id) {
//debuglog("prevent client %c on %s, not the right coin\n",
// client->username[0], job->coind->symbol);
return true;
}
if(job->remote)
{
YAAMP_REMOTE *remote = job->remote;
if(g_stratum_reconnect)
{RETURN_ON_CONDITION(!client->extranonce_subscribe && !client->reconnectable, true);}
else
{RETURN_ON_CONDITION(!client->extranonce_subscribe, true);}
RETURN_ON_CONDITION(client->reconnecting, true);
RETURN_ON_CONDITION(job->count >= YAAMP_JOB_MAXSUBIDS, false);
// RETURN_ON_CONDITION(client->difficulty_actual > remote->difficulty_actual, false);
double difficulty_remote = client->difficulty_remote;
if(remote->difficulty_actual < client->difficulty_actual)
{
RETURN_ON_CONDITION(client->difficulty_fixed, true);
RETURN_ON_CONDITION(remote->difficulty_actual*4 < client->difficulty_actual, true);
difficulty_remote = remote->difficulty_actual;
}
else if(remote->difficulty_actual > client->difficulty_actual)
difficulty_remote = 0;
if(remote->nonce2size == 2)
{
RETURN_ON_CONDITION(job->count > 0, false);
strcpy(client->extranonce1, remote->nonce1);
client->extranonce2size = 2;
}
else if(job->id != client->jobid_sent)
{
if(!job->remote_subids[client->extranonce1_id])
job->remote_subids[client->extranonce1_id] = true;
else
{
int i=0;
for(; i<YAAMP_JOB_MAXSUBIDS; i++) if(!job->remote_subids[i])
{
job->remote_subids[i] = true;
client->extranonce1_id = i;
break;
}
RETURN_ON_CONDITION(i == YAAMP_JOB_MAXSUBIDS, false);
}
sprintf(client->extranonce1, "%s%02x", remote->nonce1, client->extranonce1_id);
client->extranonce2size = remote->nonce2size-1;
client->difficulty_remote = difficulty_remote;
}
client->jobid_locked = job->id;
}
else
{
strcpy(client->extranonce1, client->extranonce1_default);
client->extranonce2size = client->extranonce2size_default;
// decred uses an extradata field in block header, 2 first uint32 are set by the miner
if (g_current_algo->name && !strcmp(g_current_algo->name,"decred")) {
memset(client->extranonce1, '0', sizeof(client->extranonce1));
memcpy(&client->extranonce1[16], client->extranonce1_default, 8);
client->extranonce1[24] = '\0';
}
client->difficulty_remote = 0;
client->jobid_locked = 0;
}
client->jobid_next = job->id;
job->speed += client->speed;
job->count++;
// debuglog(" assign %x, %f, %d, %s\n", job->id, client->speed, client->reconnecting, client->sock->ip);
if(strcmp(client->extranonce1, client->extranonce1_last) || client->extranonce2size != client->extranonce2size_last)
{
// debuglog("new nonce %x %s %s\n", job->id, client->extranonce1_last, client->extranonce1);
if(!client->extranonce_subscribe)
{
strcpy(client->extranonce1_reconnect, client->extranonce1);
client->extranonce2size_reconnect = client->extranonce2size;
strcpy(client->extranonce1, client->extranonce1_default);
client->extranonce2size = client->extranonce2size_default;
client->reconnecting = true;
client->lock_count++;
client->unlock = true;
client->jobid_sent = client->jobid_next;
socket_send(client->sock, "{\"id\":null,\"method\":\"client.reconnect\",\"params\":[\"%s\",%d,0]}\n", g_tcp_server, g_tcp_port);
}
else
{
strcpy(client->extranonce1_last, client->extranonce1);
client->extranonce2size_last = client->extranonce2size;
socket_send(client->sock, "{\"id\":null,\"method\":\"mining.set_extranonce\",\"params\":[\"%s\",%d]}\n",
client->extranonce1, client->extranonce2size);
}
}
return true;
}
void job_assign_clients(YAAMP_JOB *job, double maxhash)
{
if (!job) return;
job->speed = 0;
job->count = 0;
g_list_client.Enter();
// pass0 locked
for(CLI li = g_list_client.first; li; li = li->next)
{
YAAMP_CLIENT *client = (YAAMP_CLIENT *)li->data;
if(client->jobid_locked && client->jobid_locked != job->id) continue;
bool b = job_assign_client(job, client, maxhash);
if(!b) break;
}
// pass1 sent
for(CLI li = g_list_client.first; li; li = li->next)
{
YAAMP_CLIENT *client = (YAAMP_CLIENT *)li->data;
if(client->jobid_sent != job->id) continue;
bool b = job_assign_client(job, client, maxhash);
if(!b) break;
}
// pass2 extranonce_subscribe
if(job->remote) for(CLI li = g_list_client.first; li; li = li->next)
{
YAAMP_CLIENT *client = (YAAMP_CLIENT *)li->data;
if(!client->extranonce_subscribe) continue;
bool b = job_assign_client(job, client, maxhash);
if(!b) break;
}
// pass3 the rest
for(CLI li = g_list_client.first; li; li = li->next)
{
YAAMP_CLIENT *client = (YAAMP_CLIENT *)li->data;
bool b = job_assign_client(job, client, maxhash);
if(!b) break;
}
g_list_client.Leave();
}
void job_assign_clients_left(double factor)
{
bool b;
for(CLI li = g_list_coind.first; li; li = li->next)
{
if(!job_has_free_client()) return;
YAAMP_COIND *coind = (YAAMP_COIND *)li->data;
if(!coind_can_mine(coind)) continue;
if(!coind->job) continue;
double nethash = coind_nethash(coind);
g_list_client.Enter();
for(CLI li = g_list_client.first; li; li = li->next)
{
YAAMP_CLIENT *client = (YAAMP_CLIENT *)li->data;
if (!g_autoexchange) {
if (client->coinid == coind->id)
factor = 100.;
else
factor = 0.;
}
//debuglog("%s %s factor %f nethash %.3f\n", coind->symbol, client->username, factor, nethash);
if (factor > 0.) {
b = job_assign_client(coind->job, client, nethash*factor);
if(!b) break;
}
}
g_list_client.Leave();
}
}
////////////////////////////////////////////////////////////////////////
pthread_mutex_t g_job_mutex;
pthread_cond_t g_job_cond;
void *job_thread(void *p)
{
CommonLock(&g_job_mutex);
while(!g_exiting)
{
job_update();
pthread_cond_wait(&g_job_cond, &g_job_mutex);
}
}
void job_init()
{
pthread_mutex_init(&g_job_mutex, 0);
pthread_cond_init(&g_job_cond, 0);
pthread_t thread3;
pthread_create(&thread3, NULL, job_thread, NULL);
}
void job_signal()
{
CommonLock(&g_job_mutex);
pthread_cond_signal(&g_job_cond);
CommonUnlock(&g_job_mutex);
}
void job_update()
{
// debuglog("job_update()\n");
job_reset_clients();
//////////////////////////////////////////////////////////////////////////////////////////////////////
g_list_job.Enter();
job_sort();
for(CLI li = g_list_job.first; li; li = li->next)
{
YAAMP_JOB *job = (YAAMP_JOB *)li->data;
if(!job_can_mine(job)) continue;
job_assign_clients(job, job->maxspeed);
job_unlock_clients(job);
if(!job_has_free_client()) break;
}
job_unlock_clients();
g_list_job.Leave();
////////////////////////////////////////////////////////////////////////////////////////////////
g_list_coind.Enter();
coind_sort();
job_assign_clients_left(1);
job_assign_clients_left(1);
job_assign_clients_left(-1);
g_list_coind.Leave();
////////////////////////////////////////////////////////////////////////////////////////////////
g_list_client.Enter();
for(CLI li = g_list_client.first; li; li = li->next)
{
YAAMP_CLIENT *client = (YAAMP_CLIENT *)li->data;
if(client->deleted) continue;
if(client->jobid_next) continue;
debuglog("clients with no job\n");
g_current_algo->overflow = true;
if(!g_list_coind.first) break;
// here: todo: choose first can mine
YAAMP_COIND *coind = (YAAMP_COIND *)g_list_coind.first->data;
if(!coind) break;
job_reset_clients(coind->job);
coind_create_job(coind, true);
job_assign_clients(coind->job, -1);
break;
}
g_list_client.Leave();
////////////////////////////////////////////////////////////////////////////////////////////////
// usleep(100*YAAMP_MS);
// int ready = 0;
// debuglog("job_update\n");
g_list_job.Enter();
for(CLI li = g_list_job.first; li; li = li->next)
{
YAAMP_JOB *job = (YAAMP_JOB *)li->data;
if(!job_can_mine(job)) continue;
job_broadcast(job);
// ready++;
}
// debuglog("job_update %d / %d jobs\n", ready, g_list_job.count);
g_list_job.Leave();
}
| 24.794872 | 131 | 0.652304 | now2more |
3653f7cf95aab81a640bd4b30645356edf8b8b74 | 1,270 | cpp | C++ | ForYou.CodingInterviews/CPlus/ReadBook/ForYou.CodingInterviews.CPlusPlus.PrimerPlus007/002.cpp | Gun-Killer/CodingInterviews | 0f06d9f7a79898fbce8a12726bd42077cf7ee071 | [
"MIT"
] | null | null | null | ForYou.CodingInterviews/CPlus/ReadBook/ForYou.CodingInterviews.CPlusPlus.PrimerPlus007/002.cpp | Gun-Killer/CodingInterviews | 0f06d9f7a79898fbce8a12726bd42077cf7ee071 | [
"MIT"
] | null | null | null | ForYou.CodingInterviews/CPlus/ReadBook/ForYou.CodingInterviews.CPlusPlus.PrimerPlus007/002.cpp | Gun-Killer/CodingInterviews | 0f06d9f7a79898fbce8a12726bd42077cf7ee071 | [
"MIT"
] | null | null | null | #include <iostream>
using namespace std;
void towDArray(int num[][4], int rows);
void towDArray2(int num[][4], int rows);
void towDArray3(int (*num)[4], int rows);
int main002()
{
int num = 10;
const int* num_p = #
//*num_p = 11; error
const int num2 = 20;
const int* num2_p = &num2;
const int num3 = 30;
//int* num3_p = &num3; error
int numArr[][4]
{
{1,2,3},
{4,5,6},
{9,8,9},
};
towDArray(numArr, 3);
towDArray2(numArr, 3);
towDArray3(numArr, 3);
return 0;
}
void towDArray(int num[][4], int rows)
{
int sum = 0;
for (int i = 0; i < rows; i++)
{
for (int k = 0; k < 4; k++)
{
sum += num[i][k];
}
}
cout << "sum is " << sum << endl;
}
void towDArray2(int num[][4], int rows)
{
int sum = 0;
for (int i = 0; i < rows; i++)
{
for (int k = 0; k < 4; k++)
{
sum += *(*(num + i) + k);
}
}
cout << "sum is " << sum << endl;
}
void towDArray3(int(*num)[4], int rows)
{
int sum = 0;
for (int i = 0; i < rows; i++)
{
for (int k = 0; k < 4; k++)
{
sum += *(*(num + i) + k);
}
}
cout << "sum is " << sum << endl;
}
| 17.162162 | 41 | 0.434646 | Gun-Killer |
3654c1245e4e8d8b4cc2ce6b2a2efe6cadf69f14 | 1,364 | hpp | C++ | shared/disparity_luts.hpp | ConnorChristie/depthai-api | cb09505f04b16734af99b58cbe763f7afcf86faf | [
"MIT"
] | null | null | null | shared/disparity_luts.hpp | ConnorChristie/depthai-api | cb09505f04b16734af99b58cbe763f7afcf86faf | [
"MIT"
] | null | null | null | shared/disparity_luts.hpp | ConnorChristie/depthai-api | cb09505f04b16734af99b58cbe763f7afcf86faf | [
"MIT"
] | null | null | null | #pragma once
static const int DISPARITY_SIZE = 96;
static unsigned char c_disp_to_color[DISPARITY_SIZE][3] =
{
{0, 0, 0},
{128, 0, 0},
{144, 0, 0},
{160, 0, 0},
{176, 0, 0},
{192, 0, 0},
{208, 0, 0},
{224, 0, 0},
{240, 0, 0},
{255, 0, 0},
{255, 16, 0},
{255, 32, 0},
{255, 48, 0},
{255, 64, 0},
{255, 80, 0},
{255, 96, 0},
{255, 112, 0},
{255, 128, 0},
{255, 144, 0},
{255, 160, 0},
{255, 176, 0},
{255, 192, 0},
{255, 212, 0},
{255, 228, 0},
{255, 244, 0},
{250, 255, 6},
{234, 255, 22},
{218, 255, 38},
{202, 255, 54},
{186, 255, 70},
{170, 255, 86},
{154, 255, 102},
{138, 255, 118},
{122, 255, 134},
{106, 255, 150},
{90, 255, 166},
{74, 255, 182},
{58, 255, 198},
{42, 255, 214},
{26, 255, 230},
{10, 255, 246},
{0, 248, 255},
{0, 232, 255},
{0, 212, 255},
{0, 196, 255},
{0, 180, 255},
{0, 164, 255},
{0, 148, 255},
{0, 132, 255},
{0, 116, 255},
{0, 100, 255},
{0, 84, 255},
{0, 68, 255},
{0, 52, 255},
{0, 36, 255},
{0, 20, 255},
{0, 4, 255},
{0, 0, 244},
{0, 0, 228},
{0, 0, 212},
{0, 0, 196},
{0, 0, 180},
{0, 0, 164},
{0, 0, 148}
};
| 18.684932 | 57 | 0.370968 | ConnorChristie |
365743d075eb2b09941ac7f90a18a62fece9c5bb | 2,301 | hpp | C++ | include/net/distribute/Connection.hpp | izenecloud/izenelib | 9d5958100e2ce763fc75f27217adf982d7c9d902 | [
"Apache-2.0"
] | 31 | 2015-03-03T19:13:42.000Z | 2020-09-03T08:11:56.000Z | include/net/distribute/Connection.hpp | izenecloud/izenelib | 9d5958100e2ce763fc75f27217adf982d7c9d902 | [
"Apache-2.0"
] | 1 | 2016-12-24T00:12:11.000Z | 2016-12-24T00:12:11.000Z | include/net/distribute/Connection.hpp | izenecloud/izenelib | 9d5958100e2ce763fc75f27217adf982d7c9d902 | [
"Apache-2.0"
] | 8 | 2015-09-06T01:55:21.000Z | 2021-12-20T02:16:13.000Z | /*
* File: Connection.hpp
* Author: Paolo D'Apice
*
* Created on May 24, 2012, 3:43 PM
*/
#ifndef IZENELIB_NET_DISTRIBUTE_CONNECTION_HPP
#define IZENELIB_NET_DISTRIBUTE_CONNECTION_HPP
#include "common.hpp"
#include "Message.hpp"
#include <boost/asio.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <boost/shared_ptr.hpp>
namespace ba = boost::asio;
namespace bfs = boost::filesystem;
namespace bs = boost::system;
NS_IZENELIB_DISTRIBUTE_BEGIN
/**
* @brief A file-transfer TCP connection.
*/
class Connection : public boost::enable_shared_from_this<Connection> {
public:
/// Simple alias for smart pointers to \c Connection objects.
typedef boost::shared_ptr<Connection> pointer;
/**
* Factory method for new \c connection objects.
* @param service A reference to the I/O service.
* @param bufferSize The buffer size.
* @param dir The directory for saved files.
* @return a \c pointer to a new \c Connection.
*/
static pointer create(ba::io_service& service, const size_t& bufferSize,
const std::string& dir) {
return pointer(new Connection(service, bufferSize, dir));
}
/// @return a reference to the socket.
ba::ip::tcp::socket& getSocket() {
return socket;
}
/// Start data transfer on this connection.
void start();
/// Destructor.
~Connection();
private:
/// Private constructor.
Connection(ba::io_service& service, const size_t& bufferSize,
const std::string& dir);
/// Callback for received header.
void handleReceivedHeader(const bs::error_code&, size_t);
/// Callback for sent header Ack.
void handleSentHeaderAck(const bs::error_code&, size_t);
/// Callback for sent file data Ack.
void handleSentFileDataAck(const bs::error_code&, size_t);
bool createFile();
size_t receiveFileData();
private:
const unsigned id;
ba::ip::tcp::socket socket;
const size_t bufferSize;
char* buffer;
bfs::ofstream output;
bfs::path basedir;
size_t fileSize;
Request request;
};
NS_IZENELIB_DISTRIBUTE_END
#endif /* CONNECTION_HPP */
| 24.221053 | 76 | 0.66319 | izenecloud |
365810dfca733750fe46365f9e2182539eaf17b2 | 4,183 | cpp | C++ | .src/type.cpp | robertu94/jluna | aa37f3d63126713afd92f83939ee2fc4f16039a9 | [
"MIT"
] | null | null | null | .src/type.cpp | robertu94/jluna | aa37f3d63126713afd92f83939ee2fc4f16039a9 | [
"MIT"
] | null | null | null | .src/type.cpp | robertu94/jluna | aa37f3d63126713afd92f83939ee2fc4f16039a9 | [
"MIT"
] | null | null | null | //
// Copyright 2022 Clemens Cords
// Created on 07.02.22 by clem (mail@clemens-cords.com)
//
#include "type.hpp"
#include "symbol.hpp"
namespace jluna
{
Type::Type() = default;
Type::Type(jl_datatype_t* value)
: Proxy((jl_value_t*) value, (value->name == NULL ? jl_symbol("Union{}") : value->name->name))
{}
Type::Type(Proxy* owner)
: Proxy(*owner)
{
static jl_datatype_t* type_t = (jl_datatype_t*) jl_eval_string("return Type");
jl_assert_type(owner->operator Any*(), type_t);
}
Type Type::unroll() const
{
static jl_function_t* unroll = jl_find_function("jluna", "unroll_type");
return Type((jl_datatype_t*) jluna::safe_call(unroll, get()));
}
Type::operator jl_datatype_t*()
{
return get();
}
jl_datatype_t* Type::get() const
{
return (jl_datatype_t*) Proxy::operator const jl_value_t*();
}
Type Type::get_super_type() const
{
return Type(get()->super);
}
Symbol Type::get_symbol() const
{
return get()->name->name;
}
size_t Type::get_n_fields() const
{
static jl_function_t* get_n_fields = jl_find_function("jluna", "get_n_fields");
return unbox<size_t>(jluna::safe_call(get_n_fields, get()));
}
std::vector<std::pair<Symbol, Type>> Type::get_fields() const
{
static jl_function_t* get_fields = jl_find_function("jluna", "get_fields");
return unbox<std::vector<std::pair<Symbol, Type>>>(jluna::safe_call(get_fields, get()));
}
std::vector<std::pair<Symbol, Type>> Type::get_parameters() const
{
static jl_function_t* get_parameters = jl_find_function("jluna", "get_parameters");
return unbox<std::vector<std::pair<Symbol, Type>>>(jluna::safe_call(get_parameters, get()));
}
size_t Type::get_n_parameters() const
{
static jl_function_t* get_n_fields = jl_find_function("jluna", "get_n_parameters");
return unbox<size_t>(jluna::safe_call(get_n_fields, get()));
}
Any* Type::get_singleton_instance() const
{
return get()->instance;
}
bool Type::is_subtype_of(const Type& other) const
{
return jl_subtype((jl_value_t*) get(), (jl_value_t*) other.get());
}
bool Type::operator<(const Type& other) const
{
return this->is_subtype_of(other);
}
bool Type::is_supertype_of(const Type& other) const
{
return other.is_subtype_of(*this);
}
bool Type::operator>(const Type& other) const
{
return this->is_supertype_of(other);
}
bool Type::is_same_as(const Type& other) const
{
return jl_is_identical((jl_value_t*) get(), (jl_value_t*) other.get());
}
bool Type::operator==(const Type& other) const
{
return this->is_same_as(other);
}
bool Type::operator!=(const Type& other) const
{
return not this->is_same_as(other);
}
bool Type::is_primitive() const
{
return jl_is_primitivetype(get());
}
bool Type::is_struct_type() const
{
return jl_is_structtype(get());
}
bool Type::is_isbits() const
{
return jl_isbits(get());
}
bool Type::is_singleton() const
{
return get()->instance != nullptr;
}
bool Type::is_abstract_type() const
{
return jl_is_abstracttype(get());
}
bool Type::is_abstract_ref_type() const
{
return jl_is_abstract_ref_type((jl_value_t*) get());
}
bool Type::is_declared_mutable() const
{
return jl_is_mutable_datatype(get());
}
bool Type::is_typename(const Type& other)
{
static jl_function_t* is_name_typename = jl_find_function("jluna", "is_name_typename");
return unbox<bool>(jluna::safe_call(is_name_typename, get(), other.get()));
}
bool Type::is_typename(const std::string& symbol)
{
static jl_function_t* is_name_typename = jl_find_function("jluna", "is_name_typename");
return unbox<bool>(jluna::safe_call(is_name_typename, get(), jl_eval_string(("Main.eval(Symbol(\"" + symbol + "\"))").c_str())));
}
}
| 25.820988 | 137 | 0.61726 | robertu94 |
365ee9a4ddfd2bda3664291ef34011aa024670cc | 4,155 | cpp | C++ | CardReaderLibrary/RectangleHelper.cpp | klanderfri/CardReaderLibrary | 71fc4b7fc6052a9ec3fb477fccd9b3fcfa0b9c60 | [
"MIT"
] | 4 | 2019-03-18T14:06:59.000Z | 2021-07-17T18:36:12.000Z | CardReaderLibrary/RectangleHelper.cpp | klanderfri/ReadMagicCard | 71fc4b7fc6052a9ec3fb477fccd9b3fcfa0b9c60 | [
"MIT"
] | 17 | 2018-04-12T18:03:16.000Z | 2018-05-09T18:33:07.000Z | CardReaderLibrary/RectangleHelper.cpp | klanderfri/ReadMagicCard | 71fc4b7fc6052a9ec3fb477fccd9b3fcfa0b9c60 | [
"MIT"
] | 1 | 2019-03-25T18:31:17.000Z | 2019-03-25T18:31:17.000Z | #include "stdafx.h"
#include "RectangleHelper.h"
#include <opencv2\imgproc.hpp>
using namespace cv;
using namespace std;
RectangleHelper::RectangleHelper()
{
}
RectangleHelper::~RectangleHelper()
{
}
RotatedRect RectangleHelper::GetRotatedRectangle(vector<TrendLine> verticalBorders, vector<TrendLine> horizontalBorders, double angleAdjustment) {
//Make sure the borders are correct.
bool isRightSize = verticalBorders.size() == 2 && horizontalBorders.size() == 2;
if (!isRightSize) {
throw ParameterException("Wrong number of borders! There should be exactly 2 vertical borders and 2 horizontal borders!");
}
bool isParallel = TrendLine::IsParallel(verticalBorders[0], verticalBorders[1]);
isParallel = TrendLine::IsParallel(horizontalBorders[0], horizontalBorders[1]) && isParallel;
if (!isParallel) {
throw ParameterException("The side borders are not paralell!");
}
long double angle1 = TrendLine::GetDegreesBetweenLines(verticalBorders[0], horizontalBorders[0]);
long double angle2 = TrendLine::GetDegreesBetweenLines(verticalBorders[1], horizontalBorders[1]);
bool isPerpendicular = abs(angle1) == 90.0 && abs(angle2) == 90;
if (!isPerpendicular) {
throw ParameterException("The horizontal and vertical borders are not perpendicular!");
}
//Get the corners.
Point2d corner = TrendLine::GetIntersectionPoint(horizontalBorders[0], verticalBorders[0]);
Point2d oppositeCorner = TrendLine::GetIntersectionPoint(horizontalBorders[1], verticalBorders[1]);
//Calculate center.
Point2d center = 0.5f * (corner + oppositeCorner);
//Calculate angle.
long double angle = (-1) * horizontalBorders[0].GetDegreesToAxisX();
angle += angleAdjustment;
//Calculate size.
long double height = TrendLine::GetPerpendicularDistance(horizontalBorders[0], horizontalBorders[1]);
long double width = TrendLine::GetPerpendicularDistance(verticalBorders[0], verticalBorders[1]);
Size2d size(width, height);
//Create rectangle.
RotatedRect rectangle(center, size, (float)angle);
return rectangle;
}
double RectangleHelper::GetAnglesToStrightenUp(const RotatedRect rotatedRectangle, bool enforcePortraitMode) {
if (enforcePortraitMode) {
return (rotatedRectangle.size.height < rotatedRectangle.size.width) ? rotatedRectangle.angle + 90 : rotatedRectangle.angle;
}
else {
double rotateAlternative1 = rotatedRectangle.angle; //Should always be negative.
double rotateAlternative2 = rotatedRectangle.angle + 90; //Should always be positive.
double smallestRotation = abs(rotateAlternative1) < rotateAlternative2 ? rotateAlternative1 : rotateAlternative2;
return smallestRotation;
}
}
float RectangleHelper::SmallestDistanceCenterToLimit(RotatedRect rectangle) {
return min(rectangle.size.height, rectangle.size.width) / 2;
}
bool RectangleHelper::IsInitialized(RotatedRect rectangleToCheck) {
float sum = abs(rectangleToCheck.angle)
+ abs(rectangleToCheck.center.x)
+ abs(rectangleToCheck.center.y)
+ abs(rectangleToCheck.size.area());
return sum != 0;
}
bool RectangleHelper::DoesRectangleContainPoint(RotatedRect rectangle, Point2f point) {
//Implemented as suggested at:
//http://answers.opencv.org/question/30330/check-if-a-point-is-inside-a-rotatedrect/?answer=190773#post-id-190773
//Get the corner points.
Point2f corners[4];
rectangle.points(corners);
//Convert the point array to a vector.
//https://stackoverflow.com/a/8777619/1997617
Point2f* lastItemPointer = (corners + sizeof corners / sizeof corners[0]);
vector<Point2f> contour(corners, lastItemPointer);
//Check if the point is within the rectangle.
double indicator = pointPolygonTest(contour, point, false);
bool rectangleContainsPoint = (indicator >= 0);
return rectangleContainsPoint;
}
void RectangleHelper::StretchRectangle(const RotatedRect rectangleToStretch, RotatedRect& outRectangle, float xFactor, float yFactor) {
Point2f center(rectangleToStretch.center.x * xFactor, rectangleToStretch.center.y * yFactor);
Size2f size(rectangleToStretch.size.width * xFactor, rectangleToStretch.size.height * yFactor);
float angle = rectangleToStretch.angle;
outRectangle = RotatedRect(center, size, angle);
}
| 34.915966 | 146 | 0.776895 | klanderfri |
365f3b95d8f835a411e48511222a3793c6fa1c13 | 384 | cpp | C++ | src/depricated_code/barcodecounter.cpp | LaoZZZZZ/bartender-1.1 | ddfb2e52bdf92258dd837ab8ee34306e9fb45b81 | [
"MIT"
] | 22 | 2016-08-11T06:16:25.000Z | 2022-02-22T00:06:59.000Z | src/depricated_code/barcodecounter.cpp | LaoZZZZZ/bartender-1.1 | ddfb2e52bdf92258dd837ab8ee34306e9fb45b81 | [
"MIT"
] | 9 | 2016-12-08T12:42:38.000Z | 2021-12-28T20:12:15.000Z | src/depricated_code/barcodecounter.cpp | LaoZZZZZ/bartender-1.1 | ddfb2e52bdf92258dd837ab8ee34306e9fb45b81 | [
"MIT"
] | 8 | 2017-06-26T13:15:06.000Z | 2021-11-12T18:39:54.000Z | //
// barcodecounter.cpp
// barcode_project
//
// Created by luzhao on 12/25/15.
// Copyright © 2015 luzhao. All rights reserved.
//
#include "barcodecounter.h"
#include <string>
#include "kmers_bitwisetransform.h"
using std::string;
namespace barcodeSpace{
BarcodeCounter::BarcodeCounter(size_t klen):_klen(klen)
{
this->_trans = kmersBitwiseTransform::getInstance();
}
}
| 18.285714 | 56 | 0.729167 | LaoZZZZZ |
3662f3f56c75335ef33ca1d2c06f8acf7dc8ec91 | 1,221 | cpp | C++ | leetcode-cpp/232_implementing_queue_using_stacks/main.cpp | clpsz/algorithms | c537c65eea5176f64cb37af674c3f07bc7d47821 | [
"Apache-2.0"
] | 2 | 2019-08-14T09:32:07.000Z | 2019-12-22T10:54:35.000Z | leetcode-cpp/232_implementing_queue_using_stacks/main.cpp | clpsz/algorithms | c537c65eea5176f64cb37af674c3f07bc7d47821 | [
"Apache-2.0"
] | null | null | null | leetcode-cpp/232_implementing_queue_using_stacks/main.cpp | clpsz/algorithms | c537c65eea5176f64cb37af674c3f07bc7d47821 | [
"Apache-2.0"
] | null | null | null | #include "../common.h"
#include <stack>
using std::stack;
// 0ms
class Queue {
public:
// Push element x to the back of queue.
void push(int x) {
s.push(x);
}
// Removes the element from in front of queue.
void pop(void) {
while (!s.empty())
{
int v = s.top();
s.pop();
aux.push(v);
}
aux.pop();
while (!aux.empty())
{
int v = aux.top();
aux.pop();
s.push(v);
}
}
// Get the front element.
int peek(void) {
while (!s.empty())
{
int v = s.top();
s.pop();
aux.push(v);
}
int v = aux.top();
while (!aux.empty())
{
int v = aux.top();
aux.pop();
s.push(v);
}
return v;
}
// Return whether the queue is empty.
bool empty(void) {
return s.empty();
}
private:
stack<int> s;
stack<int> aux;
};
int main()
{
Queue q;
q.push(1);
q.push(2);
q.push(3);
q.push(4);
while (!q.empty())
{
cout << q.peek() << endl;
q.pop();
}
return 0;
}
| 15.653846 | 50 | 0.398034 | clpsz |
3664d9e6927b068565836706f33999d41d13bb1b | 32,131 | cpp | C++ | multimedia/directx/dplay/dplay8/sp/serial/modemui.cpp | npocmaka/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 17 | 2020-11-13T13:42:52.000Z | 2021-09-16T09:13:13.000Z | multimedia/directx/dplay/dplay8/sp/serial/modemui.cpp | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 2 | 2020-10-19T08:02:06.000Z | 2020-10-19T08:23:18.000Z | multimedia/directx/dplay/dplay8/sp/serial/modemui.cpp | sancho1952007/Windows-Server-2003 | 5c6fe3db626b63a384230a1aa6b92ac416b0765f | [
"Unlicense"
] | 14 | 2020-11-14T09:43:20.000Z | 2021-08-28T08:59:57.000Z | /*==========================================================================
*
* Copyright (C) 1998-2000 Microsoft Corporation. All Rights Reserved.
*
* File: ModemUI.cpp
* Content: Modem service provider UI functions
*
*
* History:
* Date By Reason
* ==== == ======
* 03/24/99 jtk Created
***************************************************************************/
#include "dnmdmi.h"
//**********************************************************************
// Constant definitions
//**********************************************************************
// default size of temp strings used to add stuff to dialog
#define DEFAULT_DIALOG_STRING_SIZE 100
#define DEFAULT_DEVICE_SELECTION_INDEX 0
#define MAX_MODEM_NAME_LENGTH 255
//**********************************************************************
// Macro definitions
//**********************************************************************
//**********************************************************************
// Structure definitions
//**********************************************************************
//**********************************************************************
// Variable definitions
//**********************************************************************
static const INT_PTR g_iExpectedIncomingModemSettingsReturn = 0x23456789;
static const INT_PTR g_iExpectedOutgoingModemSettingsReturn = 0x3456789A;
//**********************************************************************
// Function prototypes
//**********************************************************************
static INT_PTR CALLBACK IncomingSettingsDialogProc( HWND hDialog, UINT uMsg, WPARAM wParam, LPARAM lParam );
static HRESULT SetAddressParametersFromIncomingDialogData( const HWND hDialog, CModemEndpoint *const pModemEndpoint );
static INT_PTR CALLBACK OutgoingSettingsDialogProc( HWND hDialog, UINT uMsg, WPARAM wParam, LPARAM lParam );
static HRESULT SetOutgoingPhoneNumber( const HWND hDialog, const CModemEndpoint *const pModemEndpoint );
static HRESULT SetAddressParametersFromOutgoingDialogData( const HWND hDialog, CModemEndpoint *const pModemEndpoint );
static HRESULT DisplayModemConfigDialog( const HWND hDialog, const HWND hDeviceComboBox, const CModemEndpoint *const pModemEndpoint );
static HRESULT SetModemDataInDialog( const HWND hComboBox, const CModemEndpoint *const pModemEndpoint );
static HRESULT GetModemSelectionFromDialog( const HWND hComboBox, CModemEndpoint *const pModemEndpoint );
static INT_PTR CALLBACK ModemStatusDialogProc( HWND hDialog, UINT uMsg, WPARAM wParam, LPARAM lParam );
//**********************************************************************
// Function definitions
//**********************************************************************
//**********************************************************************
// ------------------------------
// DisplayIncomingModemSettingsDialog - dialog for incoming modem connection
//
// Entry: Pointer to startup param
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "DisplayIncomingModemSettingsDialog"
void DisplayIncomingModemSettingsDialog( void *const pContext )
{
INT_PTR iDlgReturn;
CModemEndpoint *pModemEndpoint;
DNASSERT( pContext != NULL );
//
// intialize
//
pModemEndpoint = static_cast<CModemEndpoint*>( pContext );
DBG_CASSERT( sizeof( pModemEndpoint ) == sizeof( LPARAM ) );
SetLastError( ERROR_SUCCESS );
iDlgReturn = DialogBoxParam( g_hModemDLLInstance, // handle of module for resources
MAKEINTRESOURCE( IDD_INCOMING_MODEM_SETTINGS ), // resource for dialog
NULL, // no parent
IncomingSettingsDialogProc, // dialog message proc
reinterpret_cast<LPARAM>( pModemEndpoint ) // startup parameter
);
if ( iDlgReturn != g_iExpectedIncomingModemSettingsReturn )
{
DWORD dwError;
dwError = GetLastError();
DPFX(DPFPREP, 0, "Failed to start incoming modem settings dialog!" );
DisplayErrorCode( 0, dwError );
pModemEndpoint->SettingsDialogComplete( DPNERR_OUTOFMEMORY );
}
return;
}
//**********************************************************************
//**********************************************************************
// ------------------------------
// DisplayOutgoingModemSettingsDialog - dialog for Outgoing modem connection
//
// Entry: Pointer to startup param
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "DisplayOutgoingModemSettingsDialog"
void DisplayOutgoingModemSettingsDialog( void *const pContext )
{
INT_PTR iDlgReturn;
CModemEndpoint *pModemEndpoint;
DNASSERT( pContext != NULL );
//
// intialize
//
pModemEndpoint = static_cast<CModemEndpoint*>( pContext );
DBG_CASSERT( sizeof( pModemEndpoint ) == sizeof( LPARAM ) );
SetLastError( ERROR_SUCCESS );
iDlgReturn = DialogBoxParam( g_hModemDLLInstance, // handle of module for resources
MAKEINTRESOURCE( IDD_OUTGOING_MODEM_SETTINGS ), // resource for dialog
NULL, //
OutgoingSettingsDialogProc, // dialog message proc
reinterpret_cast<LPARAM>( pModemEndpoint ) // startup parameter
);
if ( iDlgReturn != g_iExpectedOutgoingModemSettingsReturn )
{
DWORD dwError;
dwError = GetLastError();
DPFX(DPFPREP, 0, "Failed to start outgoing modem settings dialog!" );
DisplayErrorCode( 0, dwError );
pModemEndpoint->SettingsDialogComplete( DPNERR_OUTOFMEMORY );
}
return;
}
//**********************************************************************
//**********************************************************************
// ------------------------------
// StopModemSettingsDialog - stop dialog dialog for modem settings
//
// Entry: Handle of dialog
//
// Exit: Nothing
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "StopModemSettingsDialog"
void StopModemSettingsDialog( const HWND hDlg )
{
DNASSERT( hDlg != NULL );
if ( PostMessage( hDlg, WM_COMMAND, MAKEWPARAM( IDCANCEL, NULL ), NULL ) == 0 )
{
DWORD dwError;
dwError = GetLastError();
DPFX(DPFPREP, 0, "Failed to stop dialog!" );
DisplayErrorCode( 0, dwError );
DNASSERT( FALSE );
}
}
//**********************************************************************
////**********************************************************************
//// ------------------------------
//// DisplayModemStatusDialog - dialog for modem status
////
//// Entry: Pointer to destination for dialog handle
//// Pointer to startup param
////
//// Exit: Error code
//// ------------------------------
//HRESULT DisplayModemStatusDialog( HWND *const phDialog, CModemEndpoint *const pEndpoint )
//{
// HRESULT hr;
// HWND hDialog;
//
//
// // intialize
// hr = DPN_OK;
//
// DBG_CASSERT( sizeof( pEndpoint ) == sizeof( LPARAM ) );
// hDialog = CreateDialogParam( g_hModemDLLInstance, // handle of module for resources
// MAKEINTRESOURCE( IDD_MODEM_STATUS ), // resource for dialog
// GetForegroundWindow(), // parent window (whatever is on top)
// ModemStatusDialogProc, // dialog message proc
// reinterpret_cast<LPARAM>( pEndpoint ) // startup parameter
// );
// if ( hDialog == NULL )
// {
// DPFX(DPFPREP, 0, "Could not create modem status dialog!" );
// DisplayErrorCode( 0, GetLastError() );
// goto Failure;
// }
//
// *phDialog = hDialog;
// ShowWindow( hDialog, SW_SHOW );
// UpdateWindow( hDialog );
//
//Exit:
// return hr;
//
//Failure:
// goto Exit;
//}
////**********************************************************************
//
//
////**********************************************************************
//// ------------------------------
//// StopModemStatusDialog - stop dialog for modem connection status
////
//// Entry: Handle of dialog
////
//// Exit: Nothing
//// ------------------------------
//void StopModemStatusDialog( const HWND hDialog )
//{
// DNASSERT( hDialog != NULL );
//
// if ( SendMessage( hDialog, WM_COMMAND, MAKEWPARAM( IDCANCEL, NULL ), NULL ) != 0 )
// {
// // we didn't handle the message
// DNASSERT( FALSE );
// }
//}
////**********************************************************************
//**********************************************************************
// ------------------------------
// OutgoingSettingsDialogProc - dialog proc for outgoing modem connection
//
// Entry: Window handle
// Message LPARAM
// Message WPARAM
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "OutgoingSettingsDialogProc"
static INT_PTR CALLBACK OutgoingSettingsDialogProc( HWND hDialog, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
CModemEndpoint *pModemEndpoint;
HRESULT hr;
//
// initialize
//
hr = DPN_OK;
// note the active endpoint pointer
DBG_CASSERT( sizeof( pModemEndpoint ) == sizeof( LONG_PTR ) );
pModemEndpoint = reinterpret_cast<CModemEndpoint*>( GetWindowLongPtr( hDialog, GWLP_USERDATA ) );
switch ( uMsg )
{
// initialize dialog
case WM_INITDIALOG:
{
// since this is the first dialog message, the default code to set
// pModemEndpoint isn't getting valid data
DBG_CASSERT( sizeof( pModemEndpoint ) == sizeof( lParam ) );
pModemEndpoint = reinterpret_cast<CModemEndpoint*>( lParam );
pModemEndpoint->SetActiveDialogHandle( hDialog );
//
// SetWindowLongPtr() returns NULL in case of error. It's possible
// that the old value from SetWindowLongPtr() was really NULL in
// which case it's not an error. To be safe, clear any residual
// error code before calling SetWindowLongPtr().
//
SetLastError( 0 );
if ( SetWindowLongPtr( hDialog, GWLP_USERDATA, lParam ) == NULL )
{
DWORD dwError;
dwError = GetLastError();
if ( dwError != ERROR_SUCCESS )
{
DPFX(DPFPREP, 0, "Problem setting user data for window!" );
DisplayErrorCode( 0, dwError );
goto Failure;
}
}
//
// set dialog information
//
hr = SetModemDataInDialog( GetDlgItem( hDialog, IDC_COMBO_OUTGOING_MODEM_DEVICE ), pModemEndpoint );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem setting modem device!" );
DisplayDNError( 0, hr );
goto Failure;
}
hr = SetOutgoingPhoneNumber( hDialog, pModemEndpoint );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem setting phone number!" );
DisplayDNError( 0, hr );
goto Failure;
}
return TRUE;
break;
}
// a control did something
case WM_COMMAND:
{
// what was the control?
switch ( LOWORD( wParam ) )
{
case IDOK:
{
hr = SetAddressParametersFromOutgoingDialogData( hDialog, pModemEndpoint );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem getting dialog data!" );
DisplayDNError( 0, hr );
goto Failure;
}
// pass any error code on to 'DialogComplete'
pModemEndpoint->SettingsDialogComplete( hr );
EndDialog( hDialog, g_iExpectedOutgoingModemSettingsReturn );
break;
}
case IDCANCEL:
{
pModemEndpoint->SettingsDialogComplete( DPNERR_USERCANCEL );
EndDialog( hDialog, g_iExpectedOutgoingModemSettingsReturn );
break;
}
case IDC_BUTTON_MODEM_CONFIGURE:
{
hr = DisplayModemConfigDialog( hDialog, GetDlgItem( hDialog, IDC_COMBO_OUTGOING_MODEM_DEVICE ), pModemEndpoint );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem with DisplayModemConfigDialog in outgoing dialog!" );
DisplayDNError( 0, hr );
}
break;
}
}
break;
}
// window is closing
case WM_CLOSE:
{
break;
}
}
Exit:
return FALSE;
Failure:
DNASSERT( pModemEndpoint != NULL );
DNASSERT( hr != DPN_OK );
pModemEndpoint->SettingsDialogComplete( hr );
EndDialog( hDialog, g_iExpectedOutgoingModemSettingsReturn );
goto Exit;
}
//**********************************************************************
//**********************************************************************
// ------------------------------
// IncomingSettingsDialogProc - dialog proc for incoming modem connection
//
// Entry: Window handle
// Message LPARAM
// Message WPARAM
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "IncomingSettingsDialogProc"
static INT_PTR CALLBACK IncomingSettingsDialogProc( HWND hDialog, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
CModemEndpoint *pModemEndpoint;
HRESULT hr;
//
// initialize
//
hr = DPN_OK;
//
// note the modem port pointer
//
DBG_CASSERT( sizeof( pModemEndpoint ) == sizeof( LONG_PTR ) );
pModemEndpoint = reinterpret_cast<CModemEndpoint*>( GetWindowLongPtr( hDialog, GWLP_USERDATA ) );
switch ( uMsg )
{
//
// initialize dialog
//
case WM_INITDIALOG:
{
//
// since this is the first dialog message, the default code to set
// pModemEndpoint isn't getting valid data
//
DBG_CASSERT( sizeof( pModemEndpoint) == sizeof( lParam ) );
pModemEndpoint = reinterpret_cast<CModemEndpoint*>( lParam );
pModemEndpoint->SetActiveDialogHandle( hDialog );
//
// SetWindowLongPtr() returns NULL in case of error. It's possible
// that the old value from SetWindowLongPtr() was really NULL in
// which case it's not an error. To be safe, clear any residual
// error code before calling SetWindowLongPtr().
//
SetLastError( 0 );
if ( SetWindowLongPtr( hDialog, GWLP_USERDATA, lParam ) == NULL )
{
DWORD dwError;
dwError = GetLastError();
if ( dwError != ERROR_SUCCESS )
{
DPFX(DPFPREP, 0, "Problem setting user data for window!" );
DisplayErrorCode( 0, dwError );
goto Failure;
}
}
//
// set dialog information
//
hr = SetModemDataInDialog( GetDlgItem( hDialog, IDC_COMBO_INCOMING_MODEM_DEVICE ), pModemEndpoint );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem setting modem device!" );
DisplayDNError( 0, hr );
goto Failure;
}
return TRUE;
break;
}
//
// a control did something
//
case WM_COMMAND:
{
// what was the control?
switch ( LOWORD( wParam ) )
{
case IDOK:
{
hr = SetAddressParametersFromIncomingDialogData( hDialog, pModemEndpoint );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem getting dialog data!" );
DisplayDNError( 0, hr );
goto Failure;
}
//
// pass any error code on to 'DialogComplete'
//
pModemEndpoint->SettingsDialogComplete( hr );
EndDialog( hDialog, g_iExpectedIncomingModemSettingsReturn );
break;
}
case IDCANCEL:
{
pModemEndpoint->SettingsDialogComplete( DPNERR_USERCANCEL );
EndDialog( hDialog, g_iExpectedIncomingModemSettingsReturn );
break;
}
case IDC_BUTTON_MODEM_CONFIGURE:
{
hr = DisplayModemConfigDialog( hDialog,
GetDlgItem( hDialog, IDC_COMBO_INCOMING_MODEM_DEVICE ),
pModemEndpoint );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem with DisplayModemConfigDialog in incoming dialog!" );
DisplayDNError( 0, hr );
}
break;
}
}
break;
}
//
// window is closing
//
case WM_CLOSE:
{
DNASSERT( FALSE );
break;
}
}
Exit:
return FALSE;
Failure:
DNASSERT( pModemEndpoint != NULL );
DNASSERT( hr != DPN_OK );
pModemEndpoint->SettingsDialogComplete( hr );
EndDialog( hDialog, g_iExpectedIncomingModemSettingsReturn );
goto Exit;
}
//**********************************************************************
////**********************************************************************
//// ------------------------------
//// ModemStatusDialogProc - dialog proc for modem status
////
//// Entry: Window handle
//// Message LPARAM
//// Message WPARAM
////
//// Exit: Error code
//// ------------------------------
//static INT_PTR CALLBACK ModemStatusDialogProc( HWND hDialog, UINT uMsg, WPARAM wParam, LPARAM lParam )
//{
// CModemEndpoint *pModemEndpoint;
// HRESULT hr;
//
// // initialize
// hr = DPN_OK;
//
// // note the active endpoint pointer
// DBG_CASSERT( sizeof( pModemEndpoint ) == sizeof( LONG_PTR ) );
// pModemEndpoint = reinterpret_cast<CModemEndpoint*>( GetWindowLongPtr( hDialog, GWLP_USERDATA ) );
//
// switch ( uMsg )
// {
// // initialize dialog
// case WM_INITDIALOG:
// {
// // since this is the first dialog message, the default code to set
// // pModemEndpoint isn't getting valid data
// DBG_CASSERT( sizeof( pModemEndpoint ) == sizeof( lParam ) );
// pModemEndpoint = reinterpret_cast<CModemEndpoint*>( lParam );
//
// //
// // SetWindowLongPtr() returns NULL in case of error. It's possible
// // that the old value from SetWindowLongPtr() was really NULL in
// // which case it's not an error. To be safe, clear any residual
// // error code before calling SetWindowLongPtr().
// //
// SetLastError( 0 );
// if ( SetWindowLongPtr( hDialog, GWLP_USERDATA, lParam ) == NULL )
// {
// DWORD dwError;
//
// dwError = GetLastError();
// if ( dwError != ERROR_SUCCESS )
// {
// DPFX(DPFPREP, 0, "Problem setting user data for window!" );
// DisplayErrorCode( 0, dwError );
// goto Failure;
// }
// }
//
// // set dialog information
//
// return TRUE;
//
// break;
// }
//
// // a control did something
// case WM_COMMAND:
// {
// // what was the control?
// switch ( LOWORD( wParam ) )
// {
// case IDOK:
// {
//// HRESULT hr;
//
//
//// if ( ( hr = GetDialogData( hDialog, pModemEndpoint ) ) != DPN_OK )
//// {
//// DPFX(DPFPREP, 0, "Problem getting dialog data!" );
//// DisplayDNError( 0, hr );
//// goto Failure;
//// }
//
//// // pass any error code on to 'DialogComplete'
//// pModemEndpoint->DialogComplete( hr );
// DestroyWindow( hDialog );
//
// break;
// }
//
//// case IDCANCEL:
//// {
//// pModemEndpoint->DialogComplete( DPNERR_USERCANCEL );
//// DestroyWindow( hDialog );
////
//// break;
//// }
// }
//
// break;
// }
//
// // window is closing
// case WM_CLOSE:
// {
// break;
// }
// }
//
//Exit:
// return FALSE;
//
//Failure:
// DNASSERT( pModemEndpoint != NULL );
// DNASSERT( hr != DPN_OK );
//// pModemEndpoint->StatusDialogComplete( hr );
// DestroyWindow( hDialog );
//
// goto Exit;
//}
////**********************************************************************
//**********************************************************************
// ------------------------------
// SetModemDataInDialog - set device for modem dialog
//
// Entry: Window handle of modem combo box
// Pointer to modem port
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "SetModemDataInDialog"
HRESULT SetModemDataInDialog( const HWND hComboBox, const CModemEndpoint *const pModemEndpoint )
{
HRESULT hr;
LRESULT lResult;
DWORD dwModemCount;
MODEM_NAME_DATA *pModemNameData;
DWORD dwModemNameDataSize;
BOOL fSelectionSet;
UINT_PTR uIndex;
DNASSERT( hComboBox != NULL );
DNASSERT( pModemEndpoint != NULL );
//
// initialize
//
hr = DPN_OK;
pModemNameData = NULL;
dwModemNameDataSize = 0;
fSelectionSet = FALSE;
lResult = SendMessage( hComboBox, CB_RESETCONTENT, 0, 0 );
// DNASSERT( lResult == CB_OKAY ); // <-- Win2K is busted!!!!
hr = GenerateAvailableModemList( pModemEndpoint->GetSPData()->GetThreadPool()->GetTAPIInfo(),
&dwModemCount,
pModemNameData,
&dwModemNameDataSize );
switch ( hr )
{
//
// no modems to list, no more processing to be done
//
case DPN_OK:
{
goto Exit;
}
//
// expected return
//
case DPNERR_BUFFERTOOSMALL:
{
break;
}
//
// error
//
default:
{
DPFX(DPFPREP, 0, "SetModemDataInDialog: Failed to get size of modem list!" );
DisplayDNError( 0, hr );
goto Failure;
break;
}
}
pModemNameData = static_cast<MODEM_NAME_DATA*>( DNMalloc( dwModemNameDataSize ) );
if ( pModemNameData == NULL )
{
hr = DPNERR_OUTOFMEMORY;
DPFX(DPFPREP, 0, "SetModemDataInDialog: Failed to allocate memory to fill modem dialog list!" );
goto Failure;
}
hr = GenerateAvailableModemList( pModemEndpoint->GetSPData()->GetThreadPool()->GetTAPIInfo(),
&dwModemCount,
pModemNameData,
&dwModemNameDataSize );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "SetModemDataInDialog: Failed to get size of modem list!" );
DisplayDNError( 0, hr );
goto Failure;
}
for ( uIndex = 0; uIndex < dwModemCount; uIndex++ )
{
LRESULT AddResult;
DBG_CASSERT( sizeof( pModemNameData[ uIndex ].pModemName ) == sizeof( LPARAM ) );
AddResult = SendMessage( hComboBox, CB_INSERTSTRING, 0, reinterpret_cast<const LPARAM>( pModemNameData[ uIndex ].pModemName ) );
switch ( AddResult )
{
case CB_ERR:
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Problem adding serial device to combo box!" );
goto Failure;
break;
}
case CB_ERRSPACE:
{
hr = DPNERR_OUTOFMEMORY;
DPFX(DPFPREP, 0, "Out of memory when ading serial device to combo box!" );
goto Failure;
break;
}
//
// we added the string OK, set the associated device id and check
// to see if this is the current value to set selection
//
default:
{
LRESULT SetResult;
SetResult = SendMessage ( hComboBox, CB_SETITEMDATA, AddResult, pModemNameData[ uIndex ].dwModemID );
if ( SetResult == CB_ERR )
{
DWORD dwError;
hr = DPNERR_OUTOFMEMORY;
dwError = GetLastError();
DPFX(DPFPREP, 0, "Problem setting modem device info!" );
DisplayErrorCode( 0, dwError );
goto Failure;
}
if ( pModemEndpoint->GetDeviceID() == uIndex )
{
LRESULT SetSelectionResult;
SetSelectionResult = SendMessage( hComboBox, CB_SETCURSEL, AddResult, 0 );
if ( SetSelectionResult == CB_ERR )
{
DWORD dwError;
hr = DPNERR_GENERIC;
dwError = GetLastError();
DPFX(DPFPREP, 0, "Problem setting default modem device selection!" );
DisplayErrorCode( 0, dwError );
DNASSERT( FALSE );
goto Failure;
}
fSelectionSet = TRUE;
}
break;
}
}
}
if ( fSelectionSet == FALSE )
{
LRESULT SetSelectionResult;
SetSelectionResult = SendMessage( hComboBox, CB_SETCURSEL, 0, 0 );
if ( SetSelectionResult == CB_ERR )
{
DWORD dwError;
dwError = GetLastError();
DPFX(DPFPREP, 0, "Problem setting default modem selection!" );
DisplayErrorCode( 0, dwError );
}
}
Exit:
if ( pModemNameData != NULL )
{
DNFree( pModemNameData );
pModemNameData = NULL;
}
return hr;
Failure:
goto Exit;
}
//**********************************************************************
//**********************************************************************
// ------------------------------
// GetModemSelectionFromDialog - get modem selection from dialog
//
// Entry: Window handle of modem combo box
// Pointer to modem port
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "GetModemSelectionFromDialog"
static HRESULT GetModemSelectionFromDialog( const HWND hComboBox, CModemEndpoint *const pModemEndpoint )
{
HRESULT hr;
LRESULT Selection;
LRESULT DeviceID;
//
// initialize
//
hr = DPN_OK;
if ( hComboBox == NULL )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Invalid control handle passed to GetModemSelectionFromDialog!" );
goto Failure;
}
//
// get modem selection
//
Selection = SendMessage( hComboBox, CB_GETCURSEL, 0, 0 );
if ( Selection == CB_ERR )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Could not get current modem selection!" );
DNASSERT( FALSE );
goto Failure;
}
//
// get device ID
//
DeviceID = SendMessage( hComboBox, CB_GETITEMDATA, Selection, 0 );
if ( DeviceID == CB_ERR )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Could not get selection item data!" );
DNASSERT( FALSE );
goto Failure;
}
//
// Now that we finally have the device ID, set it. Make sure
// we clear any existing ID first, or the ID setting code will
// complain. I like paranoid code, so work around the ASSERT.
//
DNASSERT( DeviceID <= UINT32_MAX );
hr = pModemEndpoint->SetDeviceID( INVALID_DEVICE_ID );
DNASSERT( hr == DPN_OK );
hr = pModemEndpoint->SetDeviceID( static_cast<DWORD>( DeviceID ) );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem setting modem device ID!" );
DisplayDNError( 0, hr );
goto Failure;
}
Exit:
return hr;
Failure:
goto Exit;
}
//**********************************************************************
//**********************************************************************
// ------------------------------
// SetOutgoingPhoneNumber - set phone number for modem dialog
//
// Entry: Window handle
// Pointer to modem port
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "SetOutgoingPhoneNumber"
HRESULT SetOutgoingPhoneNumber( const HWND hDialog, const CModemEndpoint *const pModemEndpoint )
{
HRESULT hr;
//
// initialize
//
hr = DPN_OK;
if ( SetWindowText( GetDlgItem( hDialog, IDC_EDIT_MODEM_PHONE_NUMBER ), pModemEndpoint->GetPhoneNumber() ) == FALSE )
{
DPFX(DPFPREP, 0, "Problem setting default phone number!" );
DisplayErrorCode( 0, GetLastError() );
goto Exit;
}
Exit:
return hr;
}
//**********************************************************************
//**********************************************************************
// ------------------------------
// SetAddressParamtersFromIncomingDialogData - set address data from incoming modem settings dialog
//
// Entry: Window handle
// Pointer to modem port
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "SetAddressParametersFromIncomingDialogData"
static HRESULT SetAddressParametersFromIncomingDialogData( const HWND hDialog, CModemEndpoint *const pModemEndpoint )
{
HRESULT hr;
HWND hControl;
//
// initialize
//
hr = DPN_OK;
hControl = GetDlgItem( hDialog, IDC_COMBO_INCOMING_MODEM_DEVICE );
if ( hControl == NULL )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Problem getting handle of combo box!" );
DisplayErrorCode( 0, GetLastError() );
goto Failure;
}
hr = GetModemSelectionFromDialog( hControl, pModemEndpoint );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem getting modem device!" );
DisplayDNError( 0, hr );
goto Failure;
}
Failure:
return hr;
}
//**********************************************************************
//**********************************************************************
// ------------------------------
// SetAddressParamtersFromOutgoingDialogData - set endpoint data from outgoing modem settings dialog
//
// Entry: Window handle
// Pointer to modem port
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "SetAddressParametersFromOutgoingDialogData"
static HRESULT SetAddressParametersFromOutgoingDialogData( const HWND hDialog, CModemEndpoint *const pModemEndpoint )
{
HRESULT hr;
HWND hControl;
DWORD dwPhoneNumberLength;
TCHAR TempBuffer[ MAX_PHONE_NUMBER_LENGTH + 1 ];
DNASSERT( hDialog != NULL );
DNASSERT( pModemEndpoint != NULL );
// initialize
hr = DPN_OK;
hControl = GetDlgItem( hDialog, IDC_COMBO_OUTGOING_MODEM_DEVICE );
if ( hControl == NULL )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Problem getting handle of combo box!" );
DisplayErrorCode( 0, GetLastError() );
goto Failure;
}
hr = GetModemSelectionFromDialog( hControl, pModemEndpoint );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem getting modem device!" );
DisplayDNError( 0, hr );
goto Failure;
}
// get phone number from dialog
hControl = GetDlgItem( hDialog, IDC_EDIT_MODEM_PHONE_NUMBER );
if ( hControl == NULL )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Problem getting handle of phone number edit field!" );
DisplayErrorCode( 0, GetLastError() );
goto Failure;
}
dwPhoneNumberLength = GetWindowText( hControl, TempBuffer, (sizeof(TempBuffer)/sizeof(TCHAR)) - 1 );
if ( dwPhoneNumberLength == 0 )
{
#ifdef DBG
DWORD dwErrorReturn;
dwErrorReturn = GetLastError();
DPFX(DPFPREP, 0, "User entered an invalid phone number in dialog (err = %u)!", dwErrorReturn );
#endif // DBG
hr = DPNERR_ADDRESSING;
goto Failure;
}
else
{
hr = pModemEndpoint->SetPhoneNumber( TempBuffer );
if ( hr != DPN_OK )
{
DPFX(DPFPREP, 0, "Problem setting new phone number!" );
DisplayDNError( 0, hr );
goto Failure;
}
}
Failure:
return hr;
}
//**********************************************************************
//**********************************************************************
// ------------------------------
// DisplayModemConfigDialog - display dialog to configure modem
//
// Entry: Window handle
// Pointer to modem port
//
// Exit: Error code
// ------------------------------
#undef DPF_MODNAME
#define DPF_MODNAME "DisplayModemConfigDialog"
static HRESULT DisplayModemConfigDialog( const HWND hDialog, const HWND hDeviceComboBox, const CModemEndpoint *const pModemEndpoint )
{
HRESULT hr;
LRESULT lSelection;
LRESULT lDeviceID;
LONG lTAPIReturn;
DNASSERT( hDialog != NULL );
DNASSERT( pModemEndpoint != NULL );
//
// initialize
//
hr = DPN_OK;
if ( hDeviceComboBox == NULL )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Invalid device combo box handle!" );
goto Exit;
}
//
// ask for current selection in combo box
//
lSelection = SendMessage( hDeviceComboBox, CB_GETCURSEL, 0, 0 );
if ( lSelection == CB_ERR )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Failed to get current modem selection when configuring modem!" );
DNASSERT( FALSE );
goto Exit;
}
//
// ask for the device ID for this selection, note that the device IDs are
//
lDeviceID = SendMessage( hDeviceComboBox, CB_GETITEMDATA, lSelection, 0 );
if ( lDeviceID == CB_ERR )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Problem getting device ID from selected modem when calling for config dialog!" );
goto Exit;
}
// display dialog
DNASSERT( lDeviceID <= UINT32_MAX );
lTAPIReturn = p_lineConfigDialog( TAPIIDFromModemID( static_cast<DWORD>( lDeviceID ) ),
hDialog,
TEXT("comm/datamodem") );
if ( lTAPIReturn != LINEERR_NONE )
{
hr = DPNERR_GENERIC;
DPFX(DPFPREP, 0, "Problem with modem config dialog!" );
DisplayTAPIError( 0, lTAPIReturn );
goto Exit;
}
Exit:
return hr;
}
//**********************************************************************
| 26.686877 | 135 | 0.558993 | npocmaka |
366648ed3fc20f187f8c57438ae9d1534a9cfe53 | 2,139 | cpp | C++ | OOP_Video_Games_Data_Structures/NIM/nim.cpp | estradjm/Class_Work | dc32f5d15ea53b3cace0a3bd873eab385bfb680d | [
"Apache-2.0"
] | 7 | 2018-10-31T08:22:17.000Z | 2021-11-19T00:41:35.000Z | OOP_Video_Games_Data_Structures/NIM/nim.cpp | estradjm/Class_Work | dc32f5d15ea53b3cace0a3bd873eab385bfb680d | [
"Apache-2.0"
] | null | null | null | OOP_Video_Games_Data_Structures/NIM/nim.cpp | estradjm/Class_Work | dc32f5d15ea53b3cace0a3bd873eab385bfb680d | [
"Apache-2.0"
] | 1 | 2020-03-23T01:19:59.000Z | 2020-03-23T01:19:59.000Z | #include "nim.h"
#include <iostream>
#include <cstdlib>
#include <time.h>
#include <assert.h> /* assert */
using namespace std;
nim::nim()
{
players_turn=1;
srand(time(NULL));
piles[0] = rand() % 6 + 5; // 5 - 11 stones in each pile
piles[1] = rand() % 6 + 5;
piles[2] = rand() % 6 + 5;
}
nim::nim(int pile1, int pile2, int pile3)
{
players_turn=1;
assert (pile1>=5); // Check arguements are valid
assert (pile2>=5);
assert (pile3>=5);
assert (pile1<=11);
assert (pile2<=11);
assert (pile3<=11);
piles[0]= pile1;
piles[1] = pile2;
piles[2] = pile3;
}
void nim::print(){
cout << "Player " << players_turn << ": " << piles[0] << " " << piles[1] << " " << piles[2]<< endl;
}
int nim::get_players_turn(){
return players_turn;
}
bool nim::take_turn(int pile, int stones_to_remove){
switch (pile){
case 1:
if ((piles[0] - stones_to_remove) >= 0 && ((piles[0]+piles[1]+piles[2]) > stones_to_remove)){
piles[0] -= stones_to_remove;
(players_turn==1)?(players_turn=2):(players_turn=1); // determine player turn using ternary operator
return true;
}
else return false;
break;
case 2:
if ((piles[1] - stones_to_remove) >= 0 && ((piles[0]+piles[1]+piles[2]) > stones_to_remove)){
piles[1] -= stones_to_remove;
(players_turn==1)?(players_turn=2):(players_turn=1); // determine player turn using ternary operator
return true;
}
else return false;
break;
case 3:
if ((piles[2] - stones_to_remove) >= 0 && ((piles[0]+piles[1]+piles[2]) > stones_to_remove)){
piles[2] -= stones_to_remove;
(players_turn==1)?(players_turn=2):(players_turn=1); // determine player turn using ternary operator
return true;
}
else return false;
break;
default:
return false;
}
}
bool nim::is_game_over(){
return ((piles[0]+piles[1]+piles[2])==1);
}
| 27.779221 | 116 | 0.533894 | estradjm |
36664c4fc4dc35784f2daa9f4f349b025cb89a1b | 837 | cc | C++ | peridot/bin/suggestion_engine/filters/ranked_passive_filter.cc | yanyushr/fuchsia | 98e70672a81a206d235503e398f37b7b65581f79 | [
"BSD-3-Clause"
] | 1 | 2019-10-09T10:50:57.000Z | 2019-10-09T10:50:57.000Z | peridot/bin/suggestion_engine/filters/ranked_passive_filter.cc | bootingman/fuchsia2 | 04012f0aa1edd1d4108a2ac647a65e59730fc4c2 | [
"BSD-3-Clause"
] | null | null | null | peridot/bin/suggestion_engine/filters/ranked_passive_filter.cc | bootingman/fuchsia2 | 04012f0aa1edd1d4108a2ac647a65e59730fc4c2 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "peridot/bin/suggestion_engine/filters/ranked_passive_filter.h"
#include <list>
namespace modular {
RankedPassiveFilter::RankedPassiveFilter(
std::shared_ptr<RankingFeature> ranking_feature)
: ranking_feature_(ranking_feature) {}
RankedPassiveFilter::~RankedPassiveFilter() = default;
// If the confidence of the ranking feature is 1.0 then this filter returns
// true.
bool RankedPassiveFilter::Filter(
const std::unique_ptr<RankedSuggestion>& ranked_suggestion) {
double confidence = ranking_feature_->ComputeFeature(
fuchsia::modular::UserInput(), *ranked_suggestion);
return confidence == kMaxConfidence;
}
} // namespace modular
| 31 | 75 | 0.770609 | yanyushr |
3666c7c081142a8678529552425d85854df760f2 | 9,331 | cpp | C++ | NOLF/ClientShellDLL/ParticleSystemFX.cpp | rastrup/no-one-lives-forever | dfbe22fb4cc01bf7e5f54a79174fa8f108dd2f54 | [
"Unlicense"
] | 65 | 2015-02-28T03:35:14.000Z | 2021-09-23T05:43:33.000Z | NOLF/ClientShellDLL/ParticleSystemFX.cpp | rastrup/no-one-lives-forever | dfbe22fb4cc01bf7e5f54a79174fa8f108dd2f54 | [
"Unlicense"
] | null | null | null | NOLF/ClientShellDLL/ParticleSystemFX.cpp | rastrup/no-one-lives-forever | dfbe22fb4cc01bf7e5f54a79174fa8f108dd2f54 | [
"Unlicense"
] | 27 | 2015-02-28T07:42:01.000Z | 2022-02-11T01:35:20.000Z | // ----------------------------------------------------------------------- //
//
// MODULE : ParticleSystemFX.cpp
//
// PURPOSE : ParticleSystem special FX - Implementation
//
// CREATED : 10/24/97
//
// ----------------------------------------------------------------------- //
#include "stdafx.h"
#include "ParticleSystemFX.h"
#include "iltclient.h"
#include "ClientUtilities.h"
#include "ClientServerShared.h"
#include "GameClientShell.h"
#include "VarTrack.h"
#define MAX_PARTICLES_PER_SECOND 5000
#define MAX_PS_VIEW_DIST_SQR (10000*10000) // Max global distance to add particles
extern CGameClientShell* g_pGameClientShell;
extern LTVector g_vWorldWindVel;
static VarTrack s_cvarTweak;
// ----------------------------------------------------------------------- //
//
// ROUTINE: CParticleSystemFX::CParticleSystemFX
//
// PURPOSE: Construct
//
// ----------------------------------------------------------------------- //
CParticleSystemFX::CParticleSystemFX() : CBaseParticleSystemFX()
{
m_bFirstUpdate = LTTRUE;
m_fLastTime = 0.0f;
m_fNextUpdate = 0.01f;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CParticleSystemFX::Init
//
// PURPOSE: Init the particle system fx
//
// ----------------------------------------------------------------------- //
LTBOOL CParticleSystemFX::Init(HLOCALOBJ hServObj, HMESSAGEREAD hMessage)
{
if (!CBaseParticleSystemFX::Init(hServObj, hMessage)) return LTFALSE;
if (!hMessage) return LTFALSE;
PSCREATESTRUCT ps;
ps.hServerObj = hServObj;
g_pLTClient->ReadFromMessageVector(hMessage, &(ps.vColor1));
g_pLTClient->ReadFromMessageVector(hMessage, &(ps.vColor2));
g_pLTClient->ReadFromMessageVector(hMessage, &(ps.vDims));
g_pLTClient->ReadFromMessageVector(hMessage, &(ps.vMinVel));
g_pLTClient->ReadFromMessageVector(hMessage, &(ps.vMaxVel));
ps.dwFlags = (uint32) g_pLTClient->ReadFromMessageFloat(hMessage);
ps.fBurstWait = g_pLTClient->ReadFromMessageFloat(hMessage);
ps.fBurstWaitMin = g_pLTClient->ReadFromMessageFloat(hMessage);
ps.fBurstWaitMax = g_pLTClient->ReadFromMessageFloat(hMessage);
ps.fParticlesPerSecond = g_pLTClient->ReadFromMessageFloat(hMessage);
ps.fParticleLifetime = g_pLTClient->ReadFromMessageFloat(hMessage);
ps.fParticleRadius = g_pLTClient->ReadFromMessageFloat(hMessage);
ps.fGravity = g_pLTClient->ReadFromMessageFloat(hMessage);
ps.fRotationVelocity = g_pLTClient->ReadFromMessageFloat(hMessage);
ps.fViewDist = g_pLTClient->ReadFromMessageFloat(hMessage);
ps.hstrTextureName = g_pLTClient->ReadFromMessageHString(hMessage);
return Init(&ps);
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CParticleSystemFX::Init
//
// PURPOSE: Init the particle system
//
// ----------------------------------------------------------------------- //
LTBOOL CParticleSystemFX::Init(SFXCREATESTRUCT* psfxCreateStruct)
{
if (!CBaseParticleSystemFX::Init(psfxCreateStruct)) return LTFALSE;
// Set up our creation struct...
PSCREATESTRUCT* pPS = (PSCREATESTRUCT*)psfxCreateStruct;
m_cs = *pPS;
// Set our (parent's) flags...
m_dwFlags = m_cs.dwFlags;
m_fRadius = m_cs.fParticleRadius;
m_fGravity = m_cs.fGravity;
m_vPos = m_cs.vPos;
// Set our max viewable distance...
m_fMaxViewDistSqr = m_cs.fViewDist*m_cs.fViewDist;
m_fMaxViewDistSqr = m_fMaxViewDistSqr > MAX_PS_VIEW_DIST_SQR ? MAX_PS_VIEW_DIST_SQR : m_fMaxViewDistSqr;
m_vMinOffset = -m_cs.vDims;
m_vMaxOffset = m_cs.vDims;
// Adjust velocities based on global wind values...
m_cs.vMinVel += g_vWorldWindVel;
m_cs.vMaxVel += g_vWorldWindVel;
return LTTRUE;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CParticleSystemFX::CreateObject
//
// PURPOSE: Create object associated the particle system.
//
// ----------------------------------------------------------------------- //
LTBOOL CParticleSystemFX::CreateObject(ILTClient *pClientDE)
{
if (!pClientDE ) return LTFALSE;
if (m_cs.hstrTextureName)
{
m_pTextureName = pClientDE->GetStringData(m_cs.hstrTextureName);
}
LTBOOL bRet = CBaseParticleSystemFX::CreateObject(pClientDE);
if (bRet && m_hObject && m_hServerObject)
{
LTRotation rRot;
pClientDE->GetObjectRotation(m_hServerObject, &rRot);
pClientDE->SetObjectRotation(m_hObject, &rRot);
uint32 dwUserFlags;
pClientDE->GetObjectUserFlags(m_hServerObject, &dwUserFlags);
if (!(dwUserFlags & USRFLG_VISIBLE))
{
uint32 dwFlags = pClientDE->GetObjectFlags(m_hObject);
pClientDE->SetObjectFlags(m_hObject, dwFlags & ~FLAG_VISIBLE);
}
}
s_cvarTweak.Init(g_pLTClient, "TweakParticles", NULL, 0.0f);
return bRet;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CParticleSystemFX::Update
//
// PURPOSE: Update the particle system
//
// ----------------------------------------------------------------------- //
LTBOOL CParticleSystemFX::Update()
{
if (!m_hObject || !m_pClientDE || m_bWantRemove) return LTFALSE;
LTFLOAT fTime = m_pClientDE->GetTime();
// Hide/show the particle system if necessary...
if (m_hServerObject)
{
uint32 dwUserFlags;
m_pClientDE->GetObjectUserFlags(m_hServerObject, &dwUserFlags);
uint32 dwFlags = m_pClientDE->GetObjectFlags(m_hObject);
if (!(dwUserFlags & USRFLG_VISIBLE))
{
// Once last puff as disappeared, hide the system (no new puffs
// will be added...)
if (dwFlags & FLAG_VISIBLE)
{
if (fTime > m_fLastTime + m_cs.fParticleLifetime)
{
m_pClientDE->SetObjectFlags(m_hObject, dwFlags & ~FLAG_VISIBLE);
}
}
else
{
m_fLastTime = fTime;
}
return LTTRUE;
}
else
{
m_pClientDE->SetObjectFlags(m_hObject, dwFlags | FLAG_VISIBLE);
}
}
// Debugging aid...
if (s_cvarTweak.GetFloat() > 0)
{
TweakSystem();
}
if (m_bFirstUpdate)
{
m_fLastTime = fTime;
m_bFirstUpdate = LTFALSE;
}
// Make sure it is time to update...
if (fTime < m_fLastTime + m_fNextUpdate)
{
return LTTRUE;
}
// Ok, how many to add this frame....(make sure time delta is no more than
// 15 frames/sec...
float fTimeDelta = fTime - m_fLastTime;
fTimeDelta = fTimeDelta > 0.0666f ? 0.0666f : fTimeDelta;
int nToAdd = (int) floor(m_cs.fParticlesPerSecond * fTimeDelta);
nToAdd = LTMIN(nToAdd, (int)(MAX_PARTICLES_PER_SECOND * fTimeDelta));
nToAdd = GetNumParticles(nToAdd);
m_pClientDE->AddParticles(m_hObject, nToAdd,
&m_vMinOffset, &m_vMaxOffset, // Position offset
&(m_cs.vMinVel), &(m_cs.vMaxVel), // Velocity
&(m_cs.vColor1), &(m_cs.vColor2), // Color
m_cs.fParticleLifetime, m_cs.fParticleLifetime);
// Determine when next update should occur...
if (m_cs.fBurstWait > 0.001f)
{
m_fNextUpdate = m_cs.fBurstWait * GetRandom(m_cs.fBurstWaitMin, m_cs.fBurstWaitMax);
}
else
{
m_fNextUpdate = 0.001f;
}
// Rotate the particle system...
if (m_cs.fRotationVelocity != 0.0f)
{
LTRotation rRot;
m_pClientDE->GetObjectRotation(m_hObject, &rRot);
m_pClientDE->EulerRotateY(&rRot, g_pGameClientShell->GetFrameTime() * m_cs.fRotationVelocity);
m_pClientDE->SetObjectRotation(m_hObject, &rRot);
}
m_fLastTime = fTime;
return LTTRUE;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CParticleSystemFX::TweakSystem
//
// PURPOSE: Tweak the particle system
//
// ----------------------------------------------------------------------- //
void CParticleSystemFX::TweakSystem()
{
LTFLOAT fIncValue = 0.01f;
LTBOOL bChanged = LTFALSE;
LTVector vScale;
vScale.Init();
uint32 dwPlayerFlags = g_pGameClientShell->GetPlayerFlags();
// Move faster if running...
if (dwPlayerFlags & BC_CFLG_RUN)
{
fIncValue = .5f;
}
// Move Red up/down...
if ((dwPlayerFlags & BC_CFLG_FORWARD) || (dwPlayerFlags & BC_CFLG_REVERSE))
{
//m_cs.vMinVel
//m_cs.vMaxVel
//m_cs.vColor1
//m_cs.vColor2
bChanged = LTTRUE;
}
// Add/Subtract number of particles per second
if ((dwPlayerFlags & BC_CFLG_STRAFE_RIGHT) || (dwPlayerFlags & BC_CFLG_STRAFE_LEFT))
{
fIncValue = dwPlayerFlags & BC_CFLG_STRAFE_RIGHT ? fIncValue : -fIncValue;
m_cs.fParticlesPerSecond += (LTFLOAT)(fIncValue * 101.0);
m_cs.fParticlesPerSecond = m_cs.fParticlesPerSecond < 0.0f ? 0.0f :
(m_cs.fParticlesPerSecond > MAX_PARTICLES_PER_SECOND ? MAX_PARTICLES_PER_SECOND : m_cs.fParticlesPerSecond);
bChanged = LTTRUE;
}
// Lower/Raise burst wait...
if ((dwPlayerFlags & BC_CFLG_JUMP) || (dwPlayerFlags & BC_CFLG_DUCK))
{
fIncValue = dwPlayerFlags & BC_CFLG_DUCK ? -fIncValue : fIncValue;
bChanged = LTTRUE;
}
if (bChanged)
{
g_pGameClientShell->CSPrint("Particles per second: %.2f", m_cs.fParticlesPerSecond);
}
} | 27.125 | 112 | 0.600686 | rastrup |
36678073975dc73c6804ed2c9a56ebf006b42802 | 840 | cpp | C++ | copyconst2.cpp | maansisrivastava/Practice-code-C- | 23f8c3798c15725bf14bb1215c01e7ad857a11b6 | [
"MIT"
] | null | null | null | copyconst2.cpp | maansisrivastava/Practice-code-C- | 23f8c3798c15725bf14bb1215c01e7ad857a11b6 | [
"MIT"
] | null | null | null | copyconst2.cpp | maansisrivastava/Practice-code-C- | 23f8c3798c15725bf14bb1215c01e7ad857a11b6 | [
"MIT"
] | null | null | null | #include<iostream>
#include<conio.h>
using namespace std;
class inte
{
public:
int m;
public:
inte(inte &i);
inte(int x)
{
m=x;
}
void show()
{
cout<<"\t m :"<<m;
}
};
inte::inte(inte &i)
{
m=i.m;
}
main()
{
inte i1(10);
inte i2(i1);
i2.show();
inte i3=i2;
i3.show();
getch();
return 0;
}
| 23.333333 | 36 | 0.204762 | maansisrivastava |
36678d7a333b83786aa4e73c4edf29f8f048cbf1 | 541 | cpp | C++ | C++/ascending array.cpp | mrjayantk237/Hacktober_Fest_2021 | 6dcd022a7116b81310534dcd0da8d66c185ac410 | [
"MIT"
] | 21 | 2021-10-02T14:14:33.000Z | 2022-01-12T16:27:49.000Z | C++/ascending array.cpp | mrjayantk237/Hacktober_Fest_2021 | 6dcd022a7116b81310534dcd0da8d66c185ac410 | [
"MIT"
] | 10 | 2021-10-02T15:52:56.000Z | 2021-10-31T14:13:23.000Z | C++/ascending array.cpp | mrjayantk237/Hacktober_Fest_2021 | 6dcd022a7116b81310534dcd0da8d66c185ac410 | [
"MIT"
] | 64 | 2021-10-02T09:20:19.000Z | 2021-10-31T20:21:01.000Z | #include<iostream>
using namespace std;
int main(){
int i, j, size, a[20],temp;
cout<<"enter the size of array: ";
cin>>size;
for(i=0;i<size;i++){
cout<<"\nenter the array elements: ";
cin>>a[i];
}
cout<<"the unsorted array is: ";
for(i=0;i<size;i++){
cout<<" "<<a[i]<<" ";
}
for(i=0;i<size;i++){
for(j=0;j<size-i-1;j++){
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
cout<<"\nthe sorted array is: ";
for(j=size-1;j>=0;j--){
cout<<" "<<a[j]<<" ";
}
cout<<"\n";
return 0;
}
| 16.393939 | 39 | 0.491682 | mrjayantk237 |
3667da790b0729903f6897de14053076ab5d0bb7 | 2,015 | cpp | C++ | arch/platform/platform-x86_64.cpp | IGR2014/kernale | a8b43cf7d89c3d92b14ffdb88683023048f4bf78 | [
"MIT"
] | 4 | 2019-08-09T09:20:40.000Z | 2021-09-10T00:59:30.000Z | arch/platform/platform-x86_64.cpp | IGR2014/kernale | a8b43cf7d89c3d92b14ffdb88683023048f4bf78 | [
"MIT"
] | 12 | 2017-10-24T14:22:46.000Z | 2020-07-17T16:20:39.000Z | arch/platform/platform-x86_64.cpp | IGR2014/kernale | a8b43cf7d89c3d92b14ffdb88683023048f4bf78 | [
"MIT"
] | 1 | 2019-08-01T07:49:36.000Z | 2019-08-01T07:49:36.000Z | ////////////////////////////////////////////////////////////////
//
// Platform description for x86_64
//
// File: platform-x86_64.cpp
// Date: 24 Sep 2021
//
// Copyright (c) 2017 - 2021, Igor Baklykov
// All rights reserved.
//
//
#include <platform.hpp>
#include <arch/x86_64/types.hpp>
#include <arch/x86_64/idt.hpp>
#include <arch/x86_64/exceptions.hpp>
#include <arch/x86_64/gdt.hpp>
#include <arch/x86_64/paging.hpp>
#include <arch/x86_64/irq.hpp>
#include <klib/kprint.hpp>
// x86_64 namespace
namespace igros::x86_64 {
// Initialize x86_64
void x86_64Init() noexcept {
klib::kprintf("Initializing x86_64 platform...", __func__);
// Setup Interrupts Descriptor Table
x86_64::idt::init();
// Init exceptions
x86_64::except::init();
// Setup Global Descriptors Table
x86_64::gdt::init();
// Setup paging (And identity map first 4MB where kernel physically is)
x86_64::paging::init();
// Init interrupts
x86_64::irq::init();
// Enable interrupts
x86_64::irq::enable();
}
// Finalize x86_64
void x86_64Finalize() noexcept {
klib::kprintf("%s:\tNot implemented yet!", __func__);
}
// Shutdown x86_64
void x86_64Shutdown() noexcept {
klib::kprintf("%s:\tNot implemented yet!", __func__);
}
// Reboot x86_64
void x86_64Reboot() noexcept {
klib::kprintf("%s:\tNot implemented yet!", __func__);
}
// Suspend x86_64
void x86_64Suspend() noexcept {
klib::kprintf("%s:\tNot implemented yet!", __func__);
}
// Wakeup x86_64
void x86_64Wakeup() noexcept {
klib::kprintf("%s:\tNot implemented yet!", __func__);
}
} // namespace igros::x86_64
// OS platform
namespace igros::platform {
// Platform description
const description_t CURRENT_PLATFORM {
"x86_64",
x86_64::x86_64Init,
x86_64::x86_64Finalize,
x86_64::x86_64Shutdown,
x86_64::x86_64Reboot,
x86_64::x86_64Suspend,
x86_64::x86_64Wakeup
};
} // namespace igros::platform
| 20.353535 | 74 | 0.636228 | IGR2014 |
3668ec1f0cb31671ceff2e5548469adb2d4c1dd6 | 1,612 | hh | C++ | src/motor/meta/api/motor/meta/engine/helper/staticarray.hh | motor-dev/Motor | 98cb099fe1c2d31e455ed868cc2a25eae51e79f0 | [
"BSD-3-Clause"
] | null | null | null | src/motor/meta/api/motor/meta/engine/helper/staticarray.hh | motor-dev/Motor | 98cb099fe1c2d31e455ed868cc2a25eae51e79f0 | [
"BSD-3-Clause"
] | null | null | null | src/motor/meta/api/motor/meta/engine/helper/staticarray.hh | motor-dev/Motor | 98cb099fe1c2d31e455ed868cc2a25eae51e79f0 | [
"BSD-3-Clause"
] | null | null | null | /* Motor <motor.devel@gmail.com>
see LICENSE for detail */
#ifndef MOTOR_META_ENGINE_HELPER_STATICARRAY_HH_
#define MOTOR_META_ENGINE_HELPER_STATICARRAY_HH_
/**************************************************************************************************/
#include <motor/meta/stdafx.h>
namespace Motor { namespace Meta {
template < typename T >
struct staticarray
{
u32 const count;
T* const elements;
inline T& operator[](const u32 index);
inline const T& operator[](const u32 index) const;
inline T* begin();
inline const T* begin() const;
inline T* end();
inline const T* end() const;
};
template < typename T >
T& staticarray< T >::operator[](const u32 index)
{
motor_assert(index < count, "index %d out of range (0, %d)" | index | (count - 1));
return *(begin() + index);
}
template < typename T >
const T& staticarray< T >::operator[](const u32 index) const
{
motor_assert(index < count, "index %d out of range (0, %d)" | index | (count - 1));
return *(begin() + index);
}
template < typename T >
T* staticarray< T >::begin()
{
return elements;
}
template < typename T >
const T* staticarray< T >::begin() const
{
return elements;
}
template < typename T >
T* staticarray< T >::end()
{
return begin() + count;
}
template < typename T >
const T* staticarray< T >::end() const
{
return begin() + count;
}
}} // namespace Motor::Meta
/**************************************************************************************************/
#endif
| 23.705882 | 101 | 0.533499 | motor-dev |
366a37348e1dbb58457f0de6f4f7720c83d6fb7a | 642 | hh | C++ | game/Registry.hh | trenete97/Joc-EDA-Dominator | 94d6036df52a524249fe7b1d4a3932b113c49425 | [
"Apache-2.0"
] | null | null | null | game/Registry.hh | trenete97/Joc-EDA-Dominator | 94d6036df52a524249fe7b1d4a3932b113c49425 | [
"Apache-2.0"
] | null | null | null | game/Registry.hh | trenete97/Joc-EDA-Dominator | 94d6036df52a524249fe7b1d4a3932b113c49425 | [
"Apache-2.0"
] | null | null | null | #ifndef Registry_hh
#define Registry_hh
#include "Utils.hh"
/** \file
* Magic to register players.
*/
class Player;
/**
* Since the main program does not know how many players will be inherited
* from the Player class, we use a registration and factory pattern.
*/
class Registry {
public:
typedef Player* (*Factory)();
static int Register (const char* name, Factory fact);
static Player* new_player (string name);
static void print_players (ostream& os);
};
#define _stringification(s) #s
#define RegisterPlayer(x) static int registration = \
Registry::Register(_stringification(x), x::factory)
#endif
| 15.658537 | 74 | 0.705607 | trenete97 |
366b7c8e205c89332ae99e76b0b21345896461b8 | 3,366 | cpp | C++ | src/kernel.cpp | Codesmith512/Apex | c230c53ab8f32a5371dcf7b40d25fa9fbb85ac6b | [
"MIT"
] | 1 | 2021-04-01T09:34:26.000Z | 2021-04-01T09:34:26.000Z | src/kernel.cpp | Codesmith512/Apex | c230c53ab8f32a5371dcf7b40d25fa9fbb85ac6b | [
"MIT"
] | null | null | null | src/kernel.cpp | Codesmith512/Apex | c230c53ab8f32a5371dcf7b40d25fa9fbb85ac6b | [
"MIT"
] | null | null | null | /* Kernel */
#include "mem_manager"
#include "multiboot2"
#include "page_manager"
#include "pic"
#include "ports"
#include "interrupts"
/* IO */
#include <keyboard>
#include <vga_screen>
/* STL */
#include <array>
#include <std_external>
#include <tuple>
#include <vector>
/* APEX */
#include <helpers>
#include <stack_string>
/* Get a static pager with static memory & no constructor call */
static char pager_memory[sizeof(page_manager)];
static page_manager& pager = *reinterpret_cast<page_manager*>(pager_memory);
/* Get a static memory manager with static memory & no constructor call */
static char m_manager_memory[sizeof(mem_manager)];
static mem_manager& m_manager = *reinterpret_cast<mem_manager*>(m_manager_memory);
/**
* The kernel initialization point
* Supported Features
* - Stack
* - GDT
*
* Initializes
* - Paging
* - Dynamic Memory/Heap
* - Global static variables (after this function returns)
*/
extern "C" void kernel_init(page_manager::page_directory* page_dir, const multiboot2::tag_entry* tags)
{
/* Initialize Paging */
pager.init(page_dir);
/* Parse Multiboot Tags */
for(const multiboot2::tag_generic* tag = tags->first();
tag->type != 0; tag = tag->next())
{
switch(tag->type)
{
case 6:
{
/* Read the memory map */
const multiboot2::tag_memory_map* mmap = reinterpret_cast<const multiboot2::tag_memory_map*>(tag);
const multiboot2::tag_memory_map::Entry* entry = mmap->first_entry();
for(unsigned int i = 0; i < mmap->entry_count(); ++i, entry = entry->next())
{
/* Send to the pager */
if(entry->get_length_32() >= 0x400000)
for(uintptr_t page = apex::ceil(entry->get_base_32(), static_cast<uint32_t>(0x400000));
page < entry->get_base_32() + entry->get_length_32();
page += 0x400000)
pager.free_phys_page(page);
}
}
break;
}
}
/* Enable paging */
void* kernel_addr = reinterpret_cast<void*>(&kernel_init);
pager.alloc_page(kernel_addr, kernel_addr);
pager.enable_paging();
/* Enable the memory manager */
m_manager.init(&pager);
}
/**
* Second-round init function, happens after _init
*
* Initializes
* - Interrupts/PIC
*/
extern "C" void kernel_init2()
{
/* Setup interrupts */
interrupts::setup();
interrupts::enable_hw_interrupts();
pic::initialize();
}
/**
* Kernel main function -- do whatever you want!
* C++ is already as setup as it's going to get
*
* @return 0 on success, other on error
*/
extern "C" int kernel_main()
{
/* Setup Screen */
io::screen::vga_manager manager({80,25});
io::screen::vga_screen& debug_screen = manager.create_screen({0,0}, {80,25}, "Debug");
manager.set_active(debug_screen);
/* Setup Keyboard */
io::keyboard::enable();
io::keyboard::register_callback(&io::screen::vga_manager::global_event);
/* Hang w/ interrupts */
for(;;);
/* Success! */
return 0;
}
/**
* Define classic C functions for STL
*/
STL_BEGIN
extern "C"
{
/* Malloc */
void* malloc(size_t size)
{ return m_manager.malloc(size); }
/* Aligned Malloc -- not sure why, but align comes first in std c */
void* aligned_alloc(size_t alloc, size_t size)
{ return m_manager.malloc(size, alloc); }
/* Free */
void free(void* ptr)
{ m_manager.free(ptr); }
}
STL_END
| 24.391304 | 106 | 0.656269 | Codesmith512 |
366d7b54d1a71360800f88cfa490efbe0562f66d | 976 | cpp | C++ | module-services/service-desktop/endpoints/developerMode/event/ATRequest.cpp | bitigchi/MuditaOS | 425d23e454e09fd6ae274b00f8d19c57a577aa94 | [
"BSL-1.0"
] | 369 | 2021-11-10T09:20:29.000Z | 2022-03-30T06:36:58.000Z | module-services/service-desktop/endpoints/developerMode/event/ATRequest.cpp | bitigchi/MuditaOS | 425d23e454e09fd6ae274b00f8d19c57a577aa94 | [
"BSL-1.0"
] | 149 | 2021-11-10T08:38:35.000Z | 2022-03-31T23:01:52.000Z | module-services/service-desktop/endpoints/developerMode/event/ATRequest.cpp | bitigchi/MuditaOS | 425d23e454e09fd6ae274b00f8d19c57a577aa94 | [
"BSL-1.0"
] | 41 | 2021-11-10T08:30:37.000Z | 2022-03-29T08:12:46.000Z | // Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
#include <endpoints/developerMode/event/ATRequest.hpp>
#include <endpoints/developerMode/DeveloperModeHelper.hpp>
#include <endpoints/JsonKeyNames.hpp>
namespace sdesktop::developerMode
{
ATResponseEvent::ATResponseEvent(std::string command, std::chrono::milliseconds timeout)
: command(std::move(command)), timeout(timeout)
{
context.setResponseStatus(endpoints::http::Code::InternalServerError);
context.setResponseBody(json11::Json::object{{endpoints::json::developerMode::ATResponse, ""}});
}
void ATResponseEvent::setResponse(const std::vector<std::string> &response)
{
context.setResponseBody(json11::Json::object{{endpoints::json::developerMode::ATResponse, response}});
context.setResponseStatus(endpoints::http::Code::OK);
}
} // namespace sdesktop::developerMode
| 40.666667 | 110 | 0.732582 | bitigchi |
367309c73333243729e5b1f56db2d79aef9d1e92 | 26,456 | cc | C++ | hookflash-core/webRTC/webRTC_ios/third_party/libyuv/source/planar_functions.cc | ilin-in/OP | bf3e87d90008e2a4106ee70360fbe15b0d694e77 | [
"Unlicense"
] | 1 | 2020-02-19T09:55:55.000Z | 2020-02-19T09:55:55.000Z | hookflash-core/webRTC/webRTC_ios/third_party/libyuv/source/planar_functions.cc | ilin-in/OP | bf3e87d90008e2a4106ee70360fbe15b0d694e77 | [
"Unlicense"
] | null | null | null | hookflash-core/webRTC/webRTC_ios/third_party/libyuv/source/planar_functions.cc | ilin-in/OP | bf3e87d90008e2a4106ee70360fbe15b0d694e77 | [
"Unlicense"
] | null | null | null | /*
* Copyright (c) 2011 The LibYuv project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "libyuv/planar_functions.h"
#include <string.h> // for memset()
#include "libyuv/cpu_id.h"
#include "row.h"
#ifdef __cplusplus
namespace libyuv {
extern "C" {
#endif
// Copy a plane of data
void CopyPlane(const uint8* src_y, int src_stride_y,
uint8* dst_y, int dst_stride_y,
int width, int height) {
void (*CopyRow)(const uint8* src, uint8* dst, int width) = CopyRow_C;
#if defined(HAS_COPYROW_NEON)
if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 64)) {
CopyRow = CopyRow_NEON;
}
#elif defined(HAS_COPYROW_X86)
if (IS_ALIGNED(width, 4)) {
CopyRow = CopyRow_X86;
#if defined(HAS_COPYROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2) &&
IS_ALIGNED(width, 32) &&
IS_ALIGNED(src_y, 16) && IS_ALIGNED(src_stride_y, 16) &&
IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) {
CopyRow = CopyRow_SSE2;
}
#endif
}
#endif
// Copy plane
for (int y = 0; y < height; ++y) {
CopyRow(src_y, dst_y, width);
src_y += src_stride_y;
dst_y += dst_stride_y;
}
}
// Mirror a plane of data
void MirrorPlane(const uint8* src_y, int src_stride_y,
uint8* dst_y, int dst_stride_y,
int width, int height) {
void (*MirrorRow)(const uint8* src, uint8* dst, int width);
#if defined(HAS_MIRRORROW_NEON)
if (TestCpuFlag(kCpuHasNEON) && IS_ALIGNED(width, 16)) {
MirrorRow = MirrorRow_NEON;
} else
#endif
#if defined(HAS_MIRRORROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) && IS_ALIGNED(width, 16) &&
IS_ALIGNED(src_y, 16) && IS_ALIGNED(src_stride_y, 16)) {
MirrorRow = MirrorRow_SSSE3;
} else
#endif
#if defined(HAS_MIRRORROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 16)) {
MirrorRow = MirrorRow_SSE2;
} else
#endif
{
MirrorRow = MirrorRow_C;
}
// Mirror plane
for (int y = 0; y < height; ++y) {
MirrorRow(src_y, dst_y, width);
src_y += src_stride_y;
dst_y += dst_stride_y;
}
}
// Mirror I420 with optional flipping
int I420Mirror(const uint8* src_y, int src_stride_y,
const uint8* src_u, int src_stride_u,
const uint8* src_v, int src_stride_v,
uint8* dst_y, int dst_stride_y,
uint8* dst_u, int dst_stride_u,
uint8* dst_v, int dst_stride_v,
int width, int height) {
if (!src_y || !src_u || !src_v ||
!dst_y || !dst_u || !dst_v ||
width <= 0 || height == 0) {
return -1;
}
// Negative height means invert the image.
if (height < 0) {
height = -height;
int halfheight = (height + 1) >> 1;
src_y = src_y + (height - 1) * src_stride_y;
src_u = src_u + (halfheight - 1) * src_stride_u;
src_v = src_v + (halfheight - 1) * src_stride_v;
src_stride_y = -src_stride_y;
src_stride_u = -src_stride_u;
src_stride_v = -src_stride_v;
}
int halfwidth = (width + 1) >> 1;
int halfheight = (height + 1) >> 1;
if (dst_y) {
MirrorPlane(src_y, src_stride_y, dst_y, dst_stride_y, width, height);
}
MirrorPlane(src_u, src_stride_u, dst_u, dst_stride_u, halfwidth, halfheight);
MirrorPlane(src_v, src_stride_v, dst_v, dst_stride_v, halfwidth, halfheight);
return 0;
}
// Copy ARGB with optional flipping
int ARGBCopy(const uint8* src_argb, int src_stride_argb,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
if (!src_argb ||
!dst_argb ||
width <= 0 || height == 0) {
return -1;
}
// Negative height means invert the image.
if (height < 0) {
height = -height;
src_argb = src_argb + (height - 1) * src_stride_argb;
src_stride_argb = -src_stride_argb;
}
CopyPlane(src_argb, src_stride_argb, dst_argb, dst_stride_argb,
width * 4, height);
return 0;
}
// Alpha Blend ARGB
void ARGBBlendRow(const uint8* src_argb, uint8* dst_argb, int width) {
#if defined(HAS_ARGBBLENDROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2)) {
ARGBBlendRow_SSE2(src_argb, dst_argb, width);
return;
}
#endif
ARGBBlendRow_C(src_argb, dst_argb, width);
}
// Alpha Blend ARGB
int ARGBBlend(const uint8* src_argb, int src_stride_argb,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
if (!src_argb || !dst_argb || width <= 0 || height == 0) {
return -1;
}
// Negative height means invert the image.
if (height < 0) {
height = -height;
src_argb = src_argb + (height - 1) * src_stride_argb;
src_stride_argb = -src_stride_argb;
}
void (*ARGBBlendRow)(const uint8* src_argb, uint8* dst_argb, int width) =
ARGBBlendRow_C;
#if defined(HAS_ARGBBLENDROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2)) {
ARGBBlendRow = ARGBBlendRow_SSE2;
if (IS_ALIGNED(width, 4) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
ARGBBlendRow = ARGBBlendRow_Aligned_SSE2;
}
}
#endif
for (int y = 0; y < height; ++y) {
ARGBBlendRow(src_argb, dst_argb, width);
src_argb += src_stride_argb;
dst_argb += dst_stride_argb;
}
return 0;
}
// Convert I422 to ARGB.
int I422ToARGB(const uint8* src_y, int src_stride_y,
const uint8* src_u, int src_stride_u,
const uint8* src_v, int src_stride_v,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
// Negative height means invert the image.
if (height < 0) {
height = -height;
dst_argb = dst_argb + (height - 1) * dst_stride_argb;
dst_stride_argb = -dst_stride_argb;
}
void (*I420ToARGBRow)(const uint8* y_buf,
const uint8* u_buf,
const uint8* v_buf,
uint8* rgb_buf,
int width);
#if defined(HAS_I420TOARGBROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
I420ToARGBRow = I420ToARGBRow_Any_NEON;
if (IS_ALIGNED(width, 16)) {
I420ToARGBRow = I420ToARGBRow_NEON;
}
} else
#elif defined(HAS_I420TOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
I420ToARGBRow = I420ToARGBRow_Any_SSSE3;
if (IS_ALIGNED(width, 8) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
I420ToARGBRow = I420ToARGBRow_SSSE3;
}
} else
#endif
{
I420ToARGBRow = I420ToARGBRow_C;
}
for (int y = 0; y < height; ++y) {
I420ToARGBRow(src_y, src_u, src_v, dst_argb, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
src_u += src_stride_u;
src_v += src_stride_v;
}
return 0;
}
// Convert I444 to ARGB.
int I444ToARGB(const uint8* src_y, int src_stride_y,
const uint8* src_u, int src_stride_u,
const uint8* src_v, int src_stride_v,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
// Negative height means invert the image.
if (height < 0) {
height = -height;
dst_argb = dst_argb + (height - 1) * dst_stride_argb;
dst_stride_argb = -dst_stride_argb;
}
void (*I444ToARGBRow)(const uint8* y_buf,
const uint8* u_buf,
const uint8* v_buf,
uint8* rgb_buf,
int width);
#if defined(HAS_I444TOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) &&
IS_ALIGNED(width, 8) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
I444ToARGBRow = I444ToARGBRow_SSSE3;
} else
#endif
{
I444ToARGBRow = I444ToARGBRow_C;
}
for (int y = 0; y < height; ++y) {
I444ToARGBRow(src_y, src_u, src_v, dst_argb, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
src_u += src_stride_u;
src_v += src_stride_v;
}
return 0;
}
// Convert I400 to ARGB.
int I400ToARGB_Reference(const uint8* src_y, int src_stride_y,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
// Negative height means invert the image.
if (height < 0) {
height = -height;
dst_argb = dst_argb + (height - 1) * dst_stride_argb;
dst_stride_argb = -dst_stride_argb;
}
void (*YToARGBRow)(const uint8* y_buf,
uint8* rgb_buf,
int width);
#if defined(HAS_YTOARGBROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2) &&
IS_ALIGNED(width, 8) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
YToARGBRow = YToARGBRow_SSE2;
} else
#endif
{
YToARGBRow = YToARGBRow_C;
}
for (int y = 0; y < height; ++y) {
YToARGBRow(src_y, dst_argb, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
}
return 0;
}
// Convert I400 to ARGB.
int I400ToARGB(const uint8* src_y, int src_stride_y,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
if (height < 0) {
height = -height;
src_y = src_y + (height - 1) * src_stride_y;
src_stride_y = -src_stride_y;
}
void (*I400ToARGBRow)(const uint8* src_y, uint8* dst_argb, int pix);
#if defined(HAS_I400TOARGBROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2) &&
IS_ALIGNED(width, 8) &&
IS_ALIGNED(src_y, 8) && IS_ALIGNED(src_stride_y, 8) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
I400ToARGBRow = I400ToARGBRow_SSE2;
} else
#endif
{
I400ToARGBRow = I400ToARGBRow_C;
}
for (int y = 0; y < height; ++y) {
I400ToARGBRow(src_y, dst_argb, width);
src_y += src_stride_y;
dst_argb += dst_stride_argb;
}
return 0;
}
int ABGRToARGB(const uint8* src_abgr, int src_stride_abgr,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
if (height < 0) {
height = -height;
src_abgr = src_abgr + (height - 1) * src_stride_abgr;
src_stride_abgr = -src_stride_abgr;
}
void (*ABGRToARGBRow)(const uint8* src_abgr, uint8* dst_argb, int pix);
#if defined(HAS_ABGRTOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) &&
IS_ALIGNED(width, 4) &&
IS_ALIGNED(src_abgr, 16) && IS_ALIGNED(src_stride_abgr, 16) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
ABGRToARGBRow = ABGRToARGBRow_SSSE3;
} else
#endif
{
ABGRToARGBRow = ABGRToARGBRow_C;
}
for (int y = 0; y < height; ++y) {
ABGRToARGBRow(src_abgr, dst_argb, width);
src_abgr += src_stride_abgr;
dst_argb += dst_stride_argb;
}
return 0;
}
// Convert BGRA to ARGB.
int BGRAToARGB(const uint8* src_bgra, int src_stride_bgra,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
if (height < 0) {
height = -height;
src_bgra = src_bgra + (height - 1) * src_stride_bgra;
src_stride_bgra = -src_stride_bgra;
}
void (*BGRAToARGBRow)(const uint8* src_bgra, uint8* dst_argb, int pix);
#if defined(HAS_BGRATOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) &&
IS_ALIGNED(width, 4) &&
IS_ALIGNED(src_bgra, 16) && IS_ALIGNED(src_stride_bgra, 16) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
BGRAToARGBRow = BGRAToARGBRow_SSSE3;
} else
#endif
{
BGRAToARGBRow = BGRAToARGBRow_C;
}
for (int y = 0; y < height; ++y) {
BGRAToARGBRow(src_bgra, dst_argb, width);
src_bgra += src_stride_bgra;
dst_argb += dst_stride_argb;
}
return 0;
}
// Convert ARGB to I400.
int ARGBToI400(const uint8* src_argb, int src_stride_argb,
uint8* dst_y, int dst_stride_y,
int width, int height) {
if (height < 0) {
height = -height;
src_argb = src_argb + (height - 1) * src_stride_argb;
src_stride_argb = -src_stride_argb;
}
void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int pix);
#if defined(HAS_ARGBTOYROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) &&
IS_ALIGNED(width, 4) &&
IS_ALIGNED(src_argb, 16) && IS_ALIGNED(src_stride_argb, 16) &&
IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) {
ARGBToYRow = ARGBToYRow_SSSE3;
} else
#endif
{
ARGBToYRow = ARGBToYRow_C;
}
for (int y = 0; y < height; ++y) {
ARGBToYRow(src_argb, dst_y, width);
src_argb += src_stride_argb;
dst_y += dst_stride_y;
}
return 0;
}
// Convert RAW to ARGB.
int RAWToARGB(const uint8* src_raw, int src_stride_raw,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
if (height < 0) {
height = -height;
src_raw = src_raw + (height - 1) * src_stride_raw;
src_stride_raw = -src_stride_raw;
}
void (*RAWToARGBRow)(const uint8* src_raw, uint8* dst_argb, int pix);
#if defined(HAS_RAWTOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) &&
IS_ALIGNED(width, 16) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
RAWToARGBRow = RAWToARGBRow_SSSE3;
} else
#endif
{
RAWToARGBRow = RAWToARGBRow_C;
}
for (int y = 0; y < height; ++y) {
RAWToARGBRow(src_raw, dst_argb, width);
src_raw += src_stride_raw;
dst_argb += dst_stride_argb;
}
return 0;
}
// Convert RGB24 to ARGB.
int RGB24ToARGB(const uint8* src_rgb24, int src_stride_rgb24,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
if (height < 0) {
height = -height;
src_rgb24 = src_rgb24 + (height - 1) * src_stride_rgb24;
src_stride_rgb24 = -src_stride_rgb24;
}
void (*RGB24ToARGBRow)(const uint8* src_rgb24, uint8* dst_argb, int pix);
#if defined(HAS_RGB24TOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) &&
IS_ALIGNED(width, 16) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
RGB24ToARGBRow = RGB24ToARGBRow_SSSE3;
} else
#endif
{
RGB24ToARGBRow = RGB24ToARGBRow_C;
}
for (int y = 0; y < height; ++y) {
RGB24ToARGBRow(src_rgb24, dst_argb, width);
src_rgb24 += src_stride_rgb24;
dst_argb += dst_stride_argb;
}
return 0;
}
// Convert ARGB To RGB24.
int ARGBToRGB24(const uint8* src_argb, int src_stride_argb,
uint8* dst_rgb24, int dst_stride_rgb24,
int width, int height) {
if (height < 0) {
height = -height;
src_argb = src_argb + (height - 1) * src_stride_argb;
src_stride_argb = -src_stride_argb;
}
void (*ARGBToRGB24Row)(const uint8* src_argb, uint8* dst_rgb, int pix);
#if defined(HAS_ARGBTORGB24ROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) &&
IS_ALIGNED(src_argb, 16) && IS_ALIGNED(src_stride_argb, 16)) {
ARGBToRGB24Row = ARGBToRGB24Row_Any_SSSE3;
if (IS_ALIGNED(width, 16) &&
IS_ALIGNED(dst_rgb24, 16) && IS_ALIGNED(dst_stride_rgb24, 16)) {
ARGBToRGB24Row = ARGBToRGB24Row_SSSE3;
}
} else
#endif
{
ARGBToRGB24Row = ARGBToRGB24Row_C;
}
for (int y = 0; y < height; ++y) {
ARGBToRGB24Row(src_argb, dst_rgb24, width);
src_argb += src_stride_argb;
dst_rgb24 += dst_stride_rgb24;
}
return 0;
}
// Convert ARGB To RAW.
int ARGBToRAW(const uint8* src_argb, int src_stride_argb,
uint8* dst_raw, int dst_stride_raw,
int width, int height) {
if (height < 0) {
height = -height;
src_argb = src_argb + (height - 1) * src_stride_argb;
src_stride_argb = -src_stride_argb;
}
void (*ARGBToRAWRow)(const uint8* src_argb, uint8* dst_rgb, int pix);
#if defined(HAS_ARGBTORAWROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3) &&
IS_ALIGNED(src_argb, 16) && IS_ALIGNED(src_stride_argb, 16)) {
ARGBToRAWRow = ARGBToRAWRow_Any_SSSE3;
if (IS_ALIGNED(width, 16) &&
IS_ALIGNED(dst_raw, 16) && IS_ALIGNED(dst_stride_raw, 16)) {
ARGBToRAWRow = ARGBToRAWRow_SSSE3;
}
} else
#endif
{
ARGBToRAWRow = ARGBToRAWRow_C;
}
for (int y = 0; y < height; ++y) {
ARGBToRAWRow(src_argb, dst_raw, width);
src_argb += src_stride_argb;
dst_raw += dst_stride_raw;
}
return 0;
}
// Convert NV12 to ARGB.
int NV12ToARGB(const uint8* src_y, int src_stride_y,
const uint8* src_uv, int src_stride_uv,
uint8* dst_argb, int dst_stride_argb,
int width, int height) {
// Negative height means invert the image.
if (height < 0) {
height = -height;
dst_argb = dst_argb + (height - 1) * dst_stride_argb;
dst_stride_argb = -dst_stride_argb;
}
void (*I420ToARGBRow)(const uint8* y_buf,
const uint8* u_buf,
const uint8* v_buf,
uint8* argb_buf,
int width);
#if defined(HAS_I420TOARGBROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
I420ToARGBRow = I420ToARGBRow_Any_NEON;
if (IS_ALIGNED(width, 16)) {
I420ToARGBRow = I420ToARGBRow_NEON;
}
} else
#elif defined(HAS_I420TOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
I420ToARGBRow = I420ToARGBRow_Any_SSSE3;
if (IS_ALIGNED(width, 8) &&
IS_ALIGNED(dst_argb, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
I420ToARGBRow = I420ToARGBRow_SSSE3;
}
} else
#endif
{
I420ToARGBRow = I420ToARGBRow_C;
}
int halfwidth = (width + 1) >> 1;
void (*SplitUV)(const uint8* src_uv, uint8* dst_u, uint8* dst_v, int pix);
#if defined(HAS_SPLITUV_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
SplitUV = SplitUV_NEON;
} else
#elif defined(HAS_SPLITUV_SSE2)
if (TestCpuFlag(kCpuHasSSE2) &&
IS_ALIGNED(src_uv, 16) && IS_ALIGNED(src_stride_uv, 16)) {
SplitUV = SplitUV_SSE2;
} else
#endif
{
SplitUV = SplitUV_C;
}
SIMD_ALIGNED(uint8 rowuv[kMaxStride * 2]);
for (int y = 0; y < height; ++y) {
if ((y & 1) == 0) {
// Copy a row of UV.
SplitUV(src_uv, rowuv, rowuv + kMaxStride, halfwidth);
src_uv += src_stride_uv;
}
I420ToARGBRow(src_y, rowuv, rowuv + kMaxStride, dst_argb, width);
dst_argb += dst_stride_argb;
src_y += src_stride_y;
}
return 0;
}
// Convert NV12 to RGB565.
int NV12ToRGB565(const uint8* src_y, int src_stride_y,
const uint8* src_uv, int src_stride_uv,
uint8* dst_rgb, int dst_stride_rgb,
int width, int height) {
// Negative height means invert the image.
if (height < 0) {
height = -height;
dst_rgb = dst_rgb + (height - 1) * dst_stride_rgb;
dst_stride_rgb = -dst_stride_rgb;
}
void (*I420ToARGBRow)(const uint8* y_buf,
const uint8* u_buf,
const uint8* v_buf,
uint8* rgb_buf,
int width);
#if defined(HAS_I420TOARGBROW_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
I420ToARGBRow = I420ToARGBRow_NEON;
} else
#elif defined(HAS_I420TOARGBROW_SSSE3)
if (TestCpuFlag(kCpuHasSSSE3)) {
I420ToARGBRow = I420ToARGBRow_SSSE3;
} else
#endif
{
I420ToARGBRow = I420ToARGBRow_C;
}
SIMD_ALIGNED(uint8 row[kMaxStride]);
void (*ARGBToRGB565Row)(const uint8* src_argb, uint8* dst_rgb, int pix);
#if defined(HAS_ARGBTORGB565ROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2) && IS_ALIGNED(width, 4)) {
ARGBToRGB565Row = ARGBToRGB565Row_SSE2;
} else
#endif
{
ARGBToRGB565Row = ARGBToRGB565Row_C;
}
int halfwidth = (width + 1) >> 1;
void (*SplitUV)(const uint8* src_uv, uint8* dst_u, uint8* dst_v, int pix);
#if defined(HAS_SPLITUV_NEON)
if (TestCpuFlag(kCpuHasNEON)) {
SplitUV = SplitUV_NEON;
} else
#elif defined(HAS_SPLITUV_SSE2)
if (TestCpuFlag(kCpuHasSSE2) &&
IS_ALIGNED(src_uv, 16) && IS_ALIGNED(src_stride_uv, 16)) {
SplitUV = SplitUV_SSE2;
} else
#endif
{
SplitUV = SplitUV_C;
}
SIMD_ALIGNED(uint8 rowuv[kMaxStride * 2]);
for (int y = 0; y < height; ++y) {
if ((y & 1) == 0) {
// Copy a row of UV.
SplitUV(src_uv, rowuv, rowuv + kMaxStride, halfwidth);
src_uv += src_stride_uv;
}
I420ToARGBRow(src_y, rowuv, rowuv + kMaxStride, row, width);
ARGBToRGB565Row(row, dst_rgb, width);
dst_rgb += dst_stride_rgb;
src_y += src_stride_y;
}
return 0;
}
// SetRow8 writes 'count' bytes using a 32 bit value repeated
// SetRow32 writes 'count' words using a 32 bit value repeated
#if defined(__ARM_NEON__) && !defined(YUV_DISABLE_ASM)
#define HAS_SETROW_NEON
static void SetRow8_NEON(uint8* dst, uint32 v32, int count) {
asm volatile (
"vdup.u32 q0, %2 \n" // duplicate 4 ints
"1: \n"
"subs %1, %1, #16 \n" // 16 bytes per loop
"vst1.u32 {q0}, [%0]! \n" // store
"bgt 1b \n"
: "+r"(dst), // %0
"+r"(count) // %1
: "r"(v32) // %2
: "q0", "memory", "cc"
);
}
// TODO(fbarchard): Make fully assembler
static void SetRows32_NEON(uint8* dst, uint32 v32, int width,
int dst_stride, int height) {
for (int y = 0; y < height; ++y) {
SetRow8_NEON(dst, v32, width << 2);
dst += dst_stride;
}
}
#elif defined(_M_IX86) && !defined(YUV_DISABLE_ASM)
#define HAS_SETROW_X86
__declspec(naked)
static void SetRow8_X86(uint8* dst, uint32 v32, int count) {
__asm {
mov edx, edi
mov edi, [esp + 4] // dst
mov eax, [esp + 8] // v32
mov ecx, [esp + 12] // count
shr ecx, 2
rep stosd
mov edi, edx
ret
}
}
__declspec(naked)
static void SetRows32_X86(uint8* dst, uint32 v32, int width,
int dst_stride, int height) {
__asm {
push edi
push ebp
mov edi, [esp + 8 + 4] // dst
mov eax, [esp + 8 + 8] // v32
mov ebp, [esp + 8 + 12] // width
mov edx, [esp + 8 + 16] // dst_stride
mov ebx, [esp + 8 + 20] // height
lea ecx, [ebp * 4]
sub edx, ecx // stride - width * 4
align 16
convertloop:
mov ecx, ebp
rep stosd
add edi, edx
sub ebx, 1
jg convertloop
pop ebp
pop edi
ret
}
}
#elif (defined(__x86_64__) || defined(__i386__)) && !defined(YUV_DISABLE_ASM)
#define HAS_SETROW_X86
static void SetRow8_X86(uint8* dst, uint32 v32, int width) {
size_t width_tmp = static_cast<size_t>(width);
asm volatile (
"shr $0x2,%1 \n"
"rep stosl \n"
: "+D"(dst), // %0
"+c"(width_tmp) // %1
: "a"(v32) // %2
: "memory", "cc"
);
}
static void SetRows32_X86(uint8* dst, uint32 v32, int width,
int dst_stride, int height) {
for (int y = 0; y < height; ++y) {
size_t width_tmp = static_cast<size_t>(width);
uint32* d = reinterpret_cast<uint32*>(dst);
asm volatile (
"rep stosl \n"
: "+D"(d), // %0
"+c"(width_tmp) // %1
: "a"(v32) // %2
: "memory", "cc"
);
dst += dst_stride;
}
}
#endif
#if !defined(HAS_SETROW_X86)
static void SetRow8_C(uint8* dst, uint32 v8, int count) {
#ifdef _MSC_VER
for (int x = 0; x < count; ++x) {
dst[x] = v8;
}
#else
memset(dst, v8, count);
#endif
}
static void SetRows32_C(uint8* dst, uint32 v32, int width,
int dst_stride, int height) {
for (int y = 0; y < height; ++y) {
uint32* d = reinterpret_cast<uint32*>(dst);
for (int x = 0; x < width; ++x) {
d[x] = v32;
}
dst += dst_stride;
}
}
#endif
void SetPlane(uint8* dst_y, int dst_stride_y,
int width, int height,
uint32 value) {
void (*SetRow)(uint8* dst, uint32 value, int pix);
#if defined(HAS_SETROW_NEON)
if (TestCpuFlag(kCpuHasNEON) &&
IS_ALIGNED(width, 16) &&
IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) {
SetRow = SetRow8_NEON;
} else
#elif defined(HAS_SETROW_SSE2)
if (TestCpuFlag(kCpuHasSSE2) &&
IS_ALIGNED(width, 16) &&
IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) {
SetRow = SetRow8_SSE2;
} else
#endif
{
#if defined(HAS_SETROW_X86)
SetRow = SetRow8_X86;
#else
SetRow = SetRow8_C;
#endif
}
uint32 v32 = value | (value << 8) | (value << 16) | (value << 24);
// Set plane
for (int y = 0; y < height; ++y) {
SetRow(dst_y, v32, width);
dst_y += dst_stride_y;
}
}
// Draw a rectangle into I420
int I420Rect(uint8* dst_y, int dst_stride_y,
uint8* dst_u, int dst_stride_u,
uint8* dst_v, int dst_stride_v,
int x, int y,
int width, int height,
int value_y, int value_u, int value_v) {
if (!dst_y || !dst_u || !dst_v ||
width <= 0 || height <= 0 ||
x < 0 || y < 0 ||
value_y < 0 || value_y > 255 ||
value_u < 0 || value_u > 255 ||
value_v < 0 || value_v > 255) {
return -1;
}
int halfwidth = (width + 1) >> 1;
int halfheight = (height + 1) >> 1;
uint8* start_y = dst_y + y * dst_stride_y + x;
uint8* start_u = dst_u + (y / 2) * dst_stride_u + (x / 2);
uint8* start_v = dst_v + (y / 2) * dst_stride_v + (x / 2);
SetPlane(start_y, dst_stride_y, width, height, value_y);
SetPlane(start_u, dst_stride_u, halfwidth, halfheight, value_u);
SetPlane(start_v, dst_stride_v, halfwidth, halfheight, value_v);
return 0;
}
// Draw a rectangle into ARGB
int ARGBRect(uint8* dst_argb, int dst_stride_argb,
int dst_x, int dst_y,
int width, int height,
uint32 value) {
if (!dst_argb ||
width <= 0 || height <= 0 ||
dst_x < 0 || dst_y < 0) {
return -1;
}
uint8* dst = dst_argb + dst_y * dst_stride_argb + dst_x * 4;
void (*SetRows)(uint8* dst, uint32 value, int width,
int dst_stride, int height);
#if defined(HAS_SETROW_NEON)
if (TestCpuFlag(kCpuHasNEON) &&
IS_ALIGNED(width, 16) &&
IS_ALIGNED(dst, 16) && IS_ALIGNED(dst_stride_argb, 16)) {
SetRows = SetRows32_NEON;
} else
#endif
{
#if defined(HAS_SETROW_X86)
SetRows = SetRows32_X86;
#else
SetRows = SetRows32_C;
#endif
}
SetRows(dst, value, width, dst_stride_argb, height);
return 0;
}
#ifdef __cplusplus
} // extern "C"
} // namespace libyuv
#endif
| 29.330377 | 79 | 0.611393 | ilin-in |
36752084da4967101bdfdc135f6aea986d786708 | 1,683 | cpp | C++ | email/src/gid.cpp | christophebedard/rmw_email | c0110b6fc6a61f389ec58f54496c39f6026a4a13 | [
"Apache-2.0"
] | 14 | 2021-09-19T02:04:37.000Z | 2022-02-24T08:15:50.000Z | email/src/gid.cpp | christophebedard/rmw_email | c0110b6fc6a61f389ec58f54496c39f6026a4a13 | [
"Apache-2.0"
] | 5 | 2021-09-18T23:50:02.000Z | 2022-02-21T14:44:49.000Z | email/src/gid.cpp | christophebedard/rmw_email | c0110b6fc6a61f389ec58f54496c39f6026a4a13 | [
"Apache-2.0"
] | 2 | 2021-09-20T13:56:38.000Z | 2021-12-10T09:00:24.000Z | // Copyright 2021 Christophe Bedard
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <atomic>
#include <optional> // NOLINT cpplint mistakes <optional> for a C system header
#include <random>
#include <string>
#include "email/gid.hpp"
#include "email/utils.hpp"
namespace email
{
Gid
Gid::new_gid()
{
return Gid(Gid::new_value());
}
Gid::Gid(const GidValue value)
: value_(value),
value_string_(Gid::to_string(value_))
{}
Gid::~Gid() {}
GidValue
Gid::value() const
{
return value_;
}
const std::string &
Gid::to_string() const
{
return value_string_;
}
std::optional<Gid>
Gid::from_string(const std::string & str)
{
auto value_opt = utils::optional_stoul(str);
if (!value_opt) {
return std::nullopt;
}
return Gid(value_opt.value());
}
GidValue
Gid::new_value()
{
// Generate random prefix
static std::random_device random_device;
static std::mt19937 gen(random_device());
static auto prefix = gen();
// Add sequence sequence number to prefix
static std::atomic<GidValue> sequence;
return prefix + sequence++;
}
std::string
Gid::to_string(const GidValue value)
{
return std::to_string(value);
}
} // namespace email
| 21.0375 | 80 | 0.714201 | christophebedard |
36798da0eed40dec3b67eeba5e362fc599252a49 | 4,105 | cpp | C++ | src/engine/render/Material.cpp | wsmind/leaf | 2a421515ef667a77c36fd852e59aedb677ab734c | [
"MIT"
] | 18 | 2017-01-11T22:09:07.000Z | 2022-02-02T03:20:23.000Z | src/engine/render/Material.cpp | wsmind/leaf | 2a421515ef667a77c36fd852e59aedb677ab734c | [
"MIT"
] | 13 | 2016-08-04T18:29:14.000Z | 2018-11-21T19:08:11.000Z | src/engine/render/Material.cpp | wsmind/leaf | 2a421515ef667a77c36fd852e59aedb677ab734c | [
"MIT"
] | 1 | 2018-11-20T15:24:53.000Z | 2018-11-20T15:24:53.000Z | #include <engine/render/Material.h>
#include <algorithm>
#include <iterator>
#include <engine/animation/AnimationData.h>
#include <engine/animation/AnimationPlayer.h>
#include <engine/animation/PropertyMapping.h>
#include <engine/render/Image.h>
#include <engine/render/RenderSettings.h>
#include <engine/render/Texture.h>
#include <engine/render/graph/Batch.h>
#include <engine/resource/ResourceManager.h>
#include <cJSON/cJSON.h>
const std::string Material::resourceClassName = "Material";
const std::string Material::defaultResourceData = "{"
"\"shaderPrefix\": {"
"\"code\": \""
"import bsdf;\n"
"import geometry;\n"
"import nodes;\n"
"struct Material\n"
"{\n"
" BSDF_DIFFUSE_OUTPUT_TYPE Surface;\n"
" BSDF_DEFAULT_OUTPUT_TYPE Volume;\n"
" float Displacement;\n"
"};\n"
"void evaluateMaterial(out Material output, Intersection intersection)\n"
"{\n"
" BSDF_DIFFUSE_input diffuseInput;\n"
" BSDF_DIFFUSE_output diffuseOutput;\n"
" diffuseInput.Color = float4(0.8, 0.8, 0.8, 1.0);\n"
" diffuseInput.Roughness = 0.5;\n"
" diffuseInput.Normal = intersection.normal;\n"
" BSDF_DIFFUSE(diffuseInput, diffuseOutput, intersection);\n"
" \n"
" output.Surface = diffuseOutput.BSDF;\n"
" output.Volume = makeNullBsdf();\n"
" output.Displacement = 0.0;\n"
"}\n"
"\","
"\"textures\": []"
"}"
"}";
void Material::load(const unsigned char *buffer, size_t size)
{
cJSON *json = cJSON_Parse((const char *)buffer);
cJSON *animation = cJSON_GetObjectItem(json, "animation");
if (animation)
{
PropertyMapping properties;
this->animation = new AnimationData(animation, properties);
AnimationPlayer::globalPlayer.registerAnimation(this->animation);
}
cJSON *prefix = cJSON_GetObjectItem(json, "shaderPrefix");
if (prefix != nullptr)
{
const char *prefixCode = cJSON_GetObjectItem(prefix, "code")->valuestring;
this->prefixHash = ShaderCache::getInstance()->registerPrefix(prefixCode);
cJSON *textureList = cJSON_GetObjectItem(prefix, "textures");
cJSON *textureJson = textureList->child;
while (textureJson)
{
Image *texture = ResourceManager::getInstance()->requestResource<Image>(textureJson->valuestring);
this->textures.push_back(texture);
textureJson = textureJson->next;
}
}
cJSON_Delete(json);
D3D11_SAMPLER_DESC samplerDesc;
ZeroMemory(&samplerDesc, sizeof(samplerDesc));
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR; // trilinear
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
Device::device->CreateSamplerState(&samplerDesc, &this->samplerState);
}
void Material::unload()
{
this->samplerState->Release();
this->samplerState = nullptr;
ShaderCache::getInstance()->unregisterPrefix(this->prefixHash);
this->prefixHash = { 0, 0 };
for (auto texture: this->textures)
ResourceManager::getInstance()->releaseResource(texture);
this->textures.clear();
if (this->animation)
{
AnimationPlayer::globalPlayer.unregisterAnimation(this->animation);
delete this->animation;
this->animation = nullptr;
}
}
DescriptorSet Material::getParameterBlock() const
{
DescriptorSet set;
std::transform(this->textures.begin(), this->textures.end(), std::back_inserter(set.resources), [](Image *texture) { return texture->getSRV(); });
std::transform(this->textures.begin(), this->textures.end(), std::back_inserter(set.samplers), [&](Image *texture) { return this->samplerState; });
return set;
}
| 33.647541 | 151 | 0.642875 | wsmind |
3679b029f1751825abfbe164b306c33b1f00a4be | 11,895 | hpp | C++ | private/inc/rtprocessingfwx/IasAudioChannelBundle.hpp | juimonen/SmartXbar | 033f521a5dba5bce5e097df9c98af5b2cc2636dd | [
"BSD-3-Clause"
] | 5 | 2018-11-05T07:37:58.000Z | 2022-03-04T06:40:09.000Z | private/inc/rtprocessingfwx/IasAudioChannelBundle.hpp | juimonen/SmartXbar | 033f521a5dba5bce5e097df9c98af5b2cc2636dd | [
"BSD-3-Clause"
] | null | null | null | private/inc/rtprocessingfwx/IasAudioChannelBundle.hpp | juimonen/SmartXbar | 033f521a5dba5bce5e097df9c98af5b2cc2636dd | [
"BSD-3-Clause"
] | 7 | 2018-12-04T07:32:19.000Z | 2021-02-17T11:28:28.000Z | /*
* Copyright (C) 2018 Intel Corporation.All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
/**
* @file IasAudioChannelBundle.hpp
* @date 2012
* @brief The definition of the IasAudioChannelBundle class.
*/
#ifndef IASAUDIOCHANNELBUNDLE_HPP_
#define IASAUDIOCHANNELBUNDLE_HPP_
#include "audio/smartx/rtprocessingfwx/IasProcessingTypes.hpp"
#include "avbaudiomodules/internal/audio/common/IasAudioLogging.hpp"
namespace IasAudio {
static const uint32_t cIasNumChannelsPerBundle = 4; //!< The maximum number of channels in one bundle.
/**
* @class IasAudioChannelBundle
*
* An audio channel bundle provides the data buffer for four interleaved audio data channels
* with 32-bit floating point format. This data layout provides the best optimization possibilities for SIMD
* operations. The class provides mechanisms to reserve channels, interleave data into the bundle, deinterleave
* data out of the bundle and get a pointer to directly access the audio data.
*/
class IAS_AUDIO_PUBLIC IasAudioChannelBundle
{
public:
/**
* @brief Constructor.
*/
IasAudioChannelBundle(uint32_t FrameLength);
/**
* @brief Destructor, virtual by default.
*/
virtual ~IasAudioChannelBundle();
/**
* @brief Initializes an audio bundle.
*
* This method is used to allocate memory for the audio data
* carried by the bundle. This function must be called before a bundle
* is used.
*
* @returns The result indicating success (eIasAudioCompOK) or failure (eIasAudioCompInitializationFailed)
*/
IasAudioProcessingResult init();
/**
* @brief Resets an audio bundle.
*
* This method is used to reset the internal states of an audio bundle.
*/
void reset();
/**
* @brief Clear the complete audio buffer of this bundle.
*
* This method clears ALL samples of all four channels inside the bundle to zero.
*/
void clear();
/**
* @brief Return a pointer to the audio data memory.
*
* @returns Returns the pointer to mAudioData if the audio channel bundle is initialized or NULL if audio channel bundle is not initialized.
*/
inline float* getAudioDataPointer() const { return mAudioData; }
/**
* @brief Gets the number of free audio within the bundle.
*
* @returns Returns the free audio channels within the bundle.
*/
inline uint32_t getNumFreeChannels() const { return mNumFreeChannels; }
/**
* @brief Gets the number of used audio within the bundle.
*
* @returns Returns the used audio channels within the bundle.
*/
inline uint32_t getNumUsedChannels() const { return cIasNumChannelsPerBundle-mNumFreeChannels; }
/**
* @brief Reserves a number of channels in this bundle.
*
* The number of channels that will be reserved are all sequentially ordered
*
* @param[in] numberChannels The number of channels to reserve.
* @param[out] startIndex The index of the first reserved channel inside the bundle.
*
* @returns The result indication success (eIasAudioProcOK) or an error when no space is left (eIasAudioProcNoSpaceLeft).
*/
IasAudioProcessingResult reserveChannels(uint32_t numberChannels, uint32_t* startIndex);
/**
* @brief Interleaves one channel into the bundle ('Bundling').
*
* The originating data is in non-interleaved order and will be interleaved into the bundle.
*
* @param[in] offset The offset in the bundle were the channel shall be placed.
* @param[in] channel A pointer to the samples in non-interleaved order to be copied into the bundle.
*/
void writeOneChannelFromNonInterleaved(uint32_t offset, const float *channel);
/**
* @brief Interleaves two channels into the bundle ('Bundling').
*
* The originating data is in non-interleaved order and will be interleaved into the bundle.
* The offset defines the location of the first channel and all other channels will be added adjacent to the first.
*
* @param[in] offset The offset in the bundle were the first channel shall be placed.
* @param[in] channel0 A pointer to the samples of the first channel in non-interleaved order to be copied into the bundle.
* @param[in] channel1 A pointer to the samples of the second channel in non-interleaved order to be copied into the bundle.
*/
void writeTwoChannelsFromNonInterleaved(uint32_t offset, const float *channel0, const float *channel1);
/**
* @brief Interleaves three channels into the bundle ('Bundling').
*
* The originating data is in non-interleaved order and will be interleaved into the bundle.
* The offset defines the location of the first channel and all other channels will be added adjacent to the first.
*
* @param[in] offset The offset in the bundle were the first channel shall be placed.
* @param[in] channel0 A pointer to the samples of the first channel in non-interleaved order to be copied into the bundle.
* @param[in] channel1 A pointer to the samples of the second channel in non-interleaved order to be copied into the bundle.
* @param[in] channel2 A pointer to the samples of the third channel in non-interleaved order to be copied into the bundle.
*/
void writeThreeChannelsFromNonInterleaved(uint32_t offset, const float *channel0, const float *channel1, const float *channel2);
/**
* @brief Interleaves four channels into the bundle ('Bundling').
*
* The originating data is in non-interleaved order and will be interleaved into the bundle.
*
* @param[in] channel0 A pointer to the samples of the first channel in non-interleaved order to be copied into the bundle.
* @param[in] channel1 A pointer to the samples of the second channel in non-interleaved order to be copied into the bundle.
* @param[in] channel2 A pointer to the samples of the third channel in non-interleaved order to be copied into the bundle.
* @param[in] channel3 A pointer to the samples of the fourth channel in non-interleaved order to be copied into the bundle.
*/
void writeFourChannelsFromNonInterleaved(const float *channel0, const float *channel1, const float *channel2, const float *channel3);
/**
* @brief Interleaves two channels into the bundle ('Bundling').
*
* The originating data is in interleaved order and will be interleaved into the bundle.
* The offset defines the location of the first channel and all other channels will be added adjacent to the first.
*
* @param[in] offset The offset in the bundle were the first channel shall be placed.
* @param[in] srcStride The stride of the source channels
* @param[in] channel A pointer to the samples of the first channel in interleaved order to be copied into the bundle.
*/
void writeTwoChannelsFromInterleaved(uint32_t offset, uint32_t srcStride, const float *channel);
/**
* @brief Interleaves three channels into the bundle ('Bundling').
*
* The originating data is in interleaved order and will be interleaved into the bundle.
* The offset defines the location of the first channel and all other channels will be added adjacent to the first.
*
* @param[in] offset The offset in the bundle were the first channel shall be placed.
* @param[in] srcStride The stride of the source channels
* @param[in] channel A pointer to the samples of the first channel in interleaved order to be copied into the bundle.
*/
void writeThreeChannelsFromInterleaved(uint32_t offset, uint32_t srcStride, const float *channel);
/**
* @brief Interleaves four channels into the bundle ('Bundling').
*
* The originating data is in interleaved order and will be interleaved into the bundle.
*
* @param[in] srcStride The stride of the source channels
* @param[in] channel A pointer to the samples of the first channel in interleaved order to be copied into the bundle.
*/
void writeFourChannelsFromInterleaved(uint32_t srcStride, const float *channel);
/**
* @brief Deinterleaves one channel out of the bundle ('Unbundling').
*
* The data in the bundle is in interleaved order and will be deinterleaved into the pointer given as parameter.
*
* @param[in] offset The offset in the bundle were the channel shall be read from.
* @param[in] channel A pointer where the samples shall be deinterleaved to.
*/
void readOneChannel(uint32_t offset, float *channel) const;
/**
* @brief Deinterleaves two channels out of the bundle ('Unbundling').
*
* The data in the bundle is in interleaved order and will be deinterleaved into the pointers given as parameters.
* The offset defines the location of the first channel and all other channels will be read adjacent from the first.
*
* @param[in] offset The offset in the bundle were the first channel shall be read from.
* @param[in] channel0 A pointer where the samples of the first channel shall be deinterleaved to.
* @param[in] channel1 A pointer where the samples of the second channel shall be deinterleaved to.
*/
void readTwoChannels(uint32_t offset, float *channel0, float *channel1) const;
/**
* @brief Deinterleaves three channels out of the bundle ('Unbundling').
*
* The data in the bundle is in interleaved order and will be deinterleaved into the pointers given as parameters.
* The offset defines the location of the first channel and all other channels will be read adjacent from the first.
*
* @param[in] offset The offset in the bundle were the first channel shall be read from.
* @param[in] channel0 A pointer where the samples of the first channel shall be deinterleaved to.
* @param[in] channel1 A pointer where the samples of the second channel shall be deinterleaved to.
* @param[in] channel2 A pointer where the samples of the third channel shall be deinterleaved to.
*/
void readThreeChannels(uint32_t offset, float *channel0, float *channel1, float *channel2) const;
/**
* @brief Deinterleaves four channels out of the bundle ('Unbundling').
*
* The data in the bundle is in interleaved order and will be deinterleaved into the pointers given as parameters.
*
* @param[in] channel0 A pointer where the samples of the first channel shall be deinterleaved to.
* @param[in] channel1 A pointer where the samples of the second channel shall be deinterleaved to.
* @param[in] channel2 A pointer where the samples of the third channel shall be deinterleaved to.
* @param[in] channel3 A pointer where the samples of the fourth channel shall be deinterleaved to.
*/
void readFourChannels(float *channel0, float *channel1, float *channel2, float *channel3) const;
private:
/**
* @brief Copy constructor, private unimplemented to prevent misuse.
*/
IasAudioChannelBundle(IasAudioChannelBundle const &other); //lint !e1704
/**
* @brief Assignment operator, private unimplemented to prevent misuse.
*/
IasAudioChannelBundle& operator=(IasAudioChannelBundle const &other); //lint !e1704
// Member variables
uint32_t mNumFreeChannels; //!< Number of free audio channels within a bundle. Must be updated by the audio component.
uint32_t mFrameLength; //!< frame length of one audio frame.
float *mAudioData; //!< Pointer to the begin of the audio data memory
float *mAudioDataEnd; //!< Pointer to the end of the audio data memory
DltContext *mLogContext; //!< The log context
};
} //namespace IasAudio
#endif /* IASAUDIOCHANNELBUNDLE_HPP_ */
| 47.390438 | 144 | 0.707524 | juimonen |
3679f439012e51728095825be0d272517e71bc36 | 2,896 | cpp | C++ | Chapter06-game-object/player_ship.cpp | focusright/Hands-On-Game-Development-with-WebAssembly | 8b5d5f58e91b3477109caf8dd923ab9f1c8bac4a | [
"MIT"
] | 71 | 2019-05-13T23:30:39.000Z | 2022-03-08T15:28:20.000Z | Chapter06-game-object/player_ship.cpp | focusright/Hands-On-Game-Development-with-WebAssembly | 8b5d5f58e91b3477109caf8dd923ab9f1c8bac4a | [
"MIT"
] | 4 | 2019-10-20T19:18:04.000Z | 2021-01-15T15:41:53.000Z | Chapter06-game-object/player_ship.cpp | focusright/Hands-On-Game-Development-with-WebAssembly | 8b5d5f58e91b3477109caf8dd923ab9f1c8bac4a | [
"MIT"
] | 23 | 2019-05-10T14:25:59.000Z | 2021-10-03T07:19:28.000Z | #include "game.hpp"
PlayerShip::PlayerShip() {
m_X = 160.0;
m_Y = 100.0;
m_Rotation = PI;
m_DX = 0.0;
m_DY = 1.0;
m_VX = 0.0;
m_VY = 0.0;
m_LastLaunchTime = current_time;
SDL_Surface *temp_surface = IMG_Load( c_SpriteFile );
if( !temp_surface ) {
printf("failed to load image: %s\n", IMG_GetError() );
return;
}
m_SpriteTexture = SDL_CreateTextureFromSurface( renderer, temp_surface );
if( !m_SpriteTexture ) {
printf("failed to create texture: %s\n", IMG_GetError() );
return;
}
SDL_FreeSurface( temp_surface );
}
void PlayerShip::RotateLeft() {
m_Rotation -= delta_time;
if( m_Rotation < 0.0 ) {
m_Rotation += TWO_PI;
}
m_DX = sin(m_Rotation);
m_DY = -cos(m_Rotation);
}
void PlayerShip::RotateRight() {
m_Rotation += delta_time;
if( m_Rotation >= TWO_PI ) {
m_Rotation -= TWO_PI;
}
m_DX = sin(m_Rotation);
m_DY = -cos(m_Rotation);
}
void PlayerShip::Accelerate() {
m_VX += m_DX * delta_time;
m_VY += m_DY * delta_time;
}
void PlayerShip::Decelerate() {
m_VX -= (m_DX * delta_time) / 2.0;
m_VY -= (m_DY * delta_time) / 2.0;
}
void PlayerShip::CapVelocity() {
double vel = sqrt( m_VX * m_VX + m_VY * m_VY );
if( vel > MAX_VELOCITY ) {
m_VX /= vel;
m_VY /= vel;
m_VX *= MAX_VELOCITY;
m_VY *= MAX_VELOCITY;
}
}
void PlayerShip::Move() {
current_time = SDL_GetTicks();
diff_time = current_time - last_time;
delta_time = (double)diff_time / 1000.0;
last_time = current_time;
if( left_key_down ) {
RotateLeft();
}
if( right_key_down ) {
RotateRight();
}
if( up_key_down ) {
Accelerate();
}
if( down_key_down ) {
Decelerate();
}
CapVelocity();
m_X += m_VX;
if( m_X > 320 ) {
m_X = -16;
}
else if( m_X < -16 ) {
m_X = 320;
}
m_Y += m_VY;
if( m_Y > 200 ) {
m_Y = -16;
}
else if( m_Y < -16 ) {
m_Y = 200;
}
if( space_key_down ) {
Projectile* projectile;
if( current_time - m_LastLaunchTime >= c_MinLaunchTime ) {
m_LastLaunchTime = current_time;
projectile = projectile_pool->GetFreeProjectile();
if( projectile != NULL ) {
projectile->Launch( m_X, m_Y, m_DX, m_DY );
}
}
}
}
void PlayerShip::Render() {
dest.x = (int)m_X;
dest.y = (int)m_Y;
dest.w = c_Width;
dest.h = c_Height;
double degrees = (m_Rotation / PI) * 180.0;
int return_code = SDL_RenderCopyEx( renderer, m_SpriteTexture,
NULL, &dest,
degrees, NULL, SDL_FLIP_NONE );
if( return_code != 0 ) {
printf("failed to render image: %s\n", IMG_GetError() );
}
} | 20.539007 | 77 | 0.541091 | focusright |
367c5ff01773ddd2658478b32871cdb49b71c119 | 651 | cpp | C++ | oop_ex33.cpp | 85105/HW | 2161a1a7ac1082a85454672d359c00f2d42ef21f | [
"MIT"
] | null | null | null | oop_ex33.cpp | 85105/HW | 2161a1a7ac1082a85454672d359c00f2d42ef21f | [
"MIT"
] | null | null | null | oop_ex33.cpp | 85105/HW | 2161a1a7ac1082a85454672d359c00f2d42ef21f | [
"MIT"
] | null | null | null | /*
cpp_ex33.cpp
Using call by reference to return multiple values
*/
#include <iostream>
using namespace std;
void fourop(const double& x, const double& y, double& a, double& s, double& m, double& d)
{
a = x + y;
s = x - y;
m = x * y;
d = x / y;
//x = y;
}
void main()
{
cout << "Please enter two numbers:" << endl;
double x, y;
double add, min, mult, div;
cin >> x >> y;
fourop(x, y, add, min, mult, div);
cout << x << " + " << y << " = " << add << endl;
cout << x << " - " << y << " = " << min << endl;
cout << x << " * " << y << " = " << mult << endl;
cout << x << " / " << y << " = " << div << endl;
system("pause");
}
| 15.878049 | 89 | 0.483871 | 85105 |
367cded62f280bb284ced6066b4da0056f2f9e67 | 25,321 | cpp | C++ | inc/control.cpp | HiSER/LCD-SSD1963-TOUCH | a2e4f51789710f5dbed00495b7306de376e0b5dc | [
"MIT"
] | null | null | null | inc/control.cpp | HiSER/LCD-SSD1963-TOUCH | a2e4f51789710f5dbed00495b7306de376e0b5dc | [
"MIT"
] | null | null | null | inc/control.cpp | HiSER/LCD-SSD1963-TOUCH | a2e4f51789710f5dbed00495b7306de376e0b5dc | [
"MIT"
] | null | null | null | /**
* HiSER (c)2018 Litvin Artem Vasilyevich
* Date 31.08.2019
* hiser@mail.ru, +79130258565
* License MIT
*/
#include <control.hpp>
#include <lcd.hpp>
CONTROL::CONTROL(tArea* area, bool visible, bool group, bool background, bool events)
{
child = NULL;
childCount = 0;
me.x = 0;
me.y = 0;
me.width = 100;
me.height = 100;
me.target = etLeftTop;
if (area != NULL) memcpy(&this->me, area, sizeof(tArea));
this->visible = visible;
this->events = events;
this->background = background;
bgnormal = ecGray;
bgactive = ecGray;
bgdisable = ecDarkGray;
frnormal = ecBlack;
fractive = ecBlack;
frdisable = ecWhite;
enable = true;
active = false;
redraw = false;
_isChange = false;
this->group = group;
owner = NULL;
tag = NULL;
text = NULL;
value = 0;
valueD = 0;
font = NULL;
onClick = onNull;
onPressed = onNull;
onPress = onNull;
state = esPaint;
//DBGF("CONTROL %ix%i, %ix%i", x, y, width, height);
}
CONTROL::~CONTROL(void)
{
removeAll();
}
bool CONTROL::testChild(tEvent* event)
{
bool flag = true;
if (child != NULL)
{
uint16 i;
for (i = 0; i < childCount; i++)
{
flag = child[i]->test(event);
if (!flag) break;
}
}
return flag;
}
void CONTROL::threadChild(void)
{
uint16 i;
if (child != NULL)
{
for (i = 0; i < childCount; i++)
{
child[i]->thread();
}
}
}
bool CONTROL::test(tEvent* event)
{
if (visible && enable)
{
bool flag = testChild(event);
if (events && flag)
{
sint16 xS = me.x;
sint16 yS = me.y;
switch (me.target)
{
case etLeftTop:
case etDefault:
break;
case etLeftBottom:
yS -= me.height;
break;
case etCenter:
xS -= me.width / 2;
yS -= me.height / 2;
break;
case etRightTop:
xS -= me.width;
break;
case etRightBottom:
xS -= me.width;
yS -= me.height;
break;
}
sint16 xE = xS + me.width;
sint16 yE = yS + me.height;
if (event->x >= xS && event->x <= xE && event->y >= yS && event->y <= yE)
{
switch (event->type)
{
case eetStart:
active = true;
state = esPaint;
break;
case eetEnd:
active = false;
state = esPaint;
break;
default:
break;
}
flag = onTouch(event->type);
}
}
return flag;
}
return true;
}
void CONTROL::thread(void)
{
bool flag = true;
if (state != esIdle)
{
uint16 i;
switch (state)
{
case esPaint:
paint();
if (group && child != NULL)
{
for (i = 0; i < childCount; i++)
{
child[i]->state = esPaint;
}
}
threadChild();
break;
case esUpdate:
update();
break;
case esHidden:
flag = false;
threadChild();
if (owner != NULL)
{
owner->paint(&me);
}
break;
default:
DBGP_WARNING("CONTROL::Thread error eState");
break;
}
/*if (child != NULL)
{
for (i = 0; i < childCount; i++)
{
child[i]->thread();
}
}*/
state = esIdle;
}
if (flag) threadChild();
}
void CONTROL::append(CONTROL* control)
{
if (control == NULL) return;
control->owner = this;
if (child == NULL)
{
child = (CONTROL**)malloc(sizeof(CONTROL*));
child[0] = control;
childCount = 1;
}
else
{
CONTROL** tmp = (CONTROL**)malloc(sizeof(CONTROL*) * (childCount + 1));
memcpy(tmp, child, sizeof(CONTROL*) * childCount);
tmp[childCount] = control;
childCount++;
free(child);
child = tmp;
}
}
void CONTROL::remove(CONTROL* control)
{
if (child == NULL || control == NULL) return;
uint16 i;
for (i = 0; i < childCount; i++)
{
if (control == child[i])
{
control->Visible(false);
control->thread();
control->owner = NULL;
childCount--;
if (childCount == 0)
{
free(child);
child = NULL;
}
else
{
CONTROL** tmp = (CONTROL**)malloc(sizeof(CONTROL*) * childCount);
memcpy(tmp, child, sizeof(CONTROL*) * i);
memcpy(&tmp[i], &child[i + 1], sizeof(CONTROL*) * (childCount - i));
free(child);
child = tmp;
}
delete(control);
break;
}
}
}
void CONTROL::removeAll(void)
{
if (child != NULL)
{
uint16 i;
for (i = 0; i < childCount; i++)
{
child[i]->Visible(false);
child[i]->thread();
child[i]->owner = NULL;
delete(child[i]);
}
free(child);
child = NULL;
}
}
void CONTROL::update()
{
if (visible) onUpdate();
threadChild();
state = esIdle;
}
void CONTROL::paint(tArea* area)
{
if (visible) onPaint(area);
state = esIdle;
}
void CONTROL::Visible(bool visible)
{
if (this->visible == visible) return;
this->visible = visible;
if (!visible) active = false;
if (child != NULL)
{
uint16 i;
for (i = 0; i < childCount; i++)
{
child[i]->Visible(visible);
}
}
state = ((visible) ? esPaint : esHidden);
}
bool CONTROL::Visible(void)
{
return visible;
}
void CONTROL::Enable(bool enable)
{
if (this->enable == enable) return;
this->enable = enable;
if (!enable) active = false;
if (child != NULL)
{
uint16 i;
for (i = 0; i < childCount; i++)
{
child[i]->Enable(enable);
}
}
state = esPaint;
}
bool CONTROL::Enable(void)
{
return enable;
}
void CONTROL::Text(const char* text)
{
if (this->text == text) return;
if (this->text != NULL && isAddressOfHeap(this->text))
{
free((char*)this->text);
}
this->text = text;
/*if (child != NULL)
{
uint16 i;
for (i = 0; i < childCount; i++)
{
child[i]->state = esUpdate;
}
}*/
_isChange = true;
state = esUpdate;
}
const char* CONTROL::getText(bool changeReset)
{
if (changeReset) _isChange = false;
return text;
}
void CONTROL::Tag(void* tag)
{
this->tag = tag;
}
void* CONTROL::Tag(void)
{
return tag;
}
void CONTROL::Value(int value)
{
if (this->value == value) return;
this->value = value;
_isChange = true;
state = esUpdate;
}
int CONTROL::Value(bool changeReset)
{
if (changeReset) _isChange = false;
return value;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
void CONTROL::Value(double value)
{
if (valueD == value) return;
valueD = value;
_isChange = true;
state = esUpdate;
}
#pragma GCC diagnostic pop
double CONTROL::ValueD(bool changeReset)
{
if (changeReset) _isChange = false;
return valueD;
}
bool CONTROL::isChange(void)
{
return _isChange;
}
void CONTROL::Area(tArea* area)
{
if (area != NULL)
{
if (visible && owner != NULL && !owner->group)
{
owner->paint(&me);
}
memcpy(&me, area, sizeof(tArea));
onArea();
state = esPaint;
}
}
CONTROL::tArea* CONTROL::Area(void)
{
tArea* area = (tArea*)malloc(sizeof(tArea));
memcpy(area, &me, sizeof(tArea));
return area;
}
void CONTROL::BackGround(eColor all)
{
BackGround(all, all, all);
}
void CONTROL::BackGround(eColor normal, eColor active)
{
BackGround(normal, active, active);
}
void CONTROL::BackGround(eColor normal, eColor disable, eColor active)
{
bgnormal = normal;
bgactive = active;
bgdisable = disable;
state = esPaint;
}
void CONTROL::ForeGround(eColor all)
{
ForeGround(all, all, all);
}
void CONTROL::ForeGround(eColor normal, eColor active)
{
ForeGround(normal, active, active);
}
void CONTROL::ForeGround(eColor normal, eColor disable, eColor active)
{
frnormal = normal;
fractive = active;
frdisable = disable;
state = esPaint;
}
void CONTROL::onPaint(tArea* area)
{
if (background)
{
eColor color = ((enable) ? ((active) ? bgactive : bgnormal) : bgdisable);
if (area == NULL)
{
LCD::fill(me.x, me.y, me.width, me.height, me.target, color);
}
else
{
LCD::fill(area->x, area->y, area->width, area->height, area->target, color);
}
}
}
bool CONTROL::onTouch(eEventType event)
{
switch (event)
{
case eetEnd:
onClick(tag);
break;
case eetPressed:
onPressed(tag);
break;
case eetPress:
onPress(tag);
break;
default:
break;
}
return false;
}
void CONTROL::onUpdate(void)
{
if (redraw && owner != NULL)
{
owner->paint(&me);
}
paint();
}
BACKGROUND::BACKGROUND(sint16 width, sint16 height) : CONTROL(NULL, true)
{
background = true;
bgnormal = bgactive = ecWhite;
bgdisable = ecBlack;
me.x = me.y = 0;
me.width = width;
me.height = height;
me.target = etLeftTop;
};
/*void BACKGROUND::onPaint(tArea* area)
{
CONTROL::onPaint(area);
}*/
BUTTON::BUTTON(const char* text, tArea* area, const tFontHeader* font, bool visible, uint8 lines)
: CONTROL(area, visible)
{
events = true;
background = true;
bgnormal = ecBlue;
bgactive = ecLightBlue;
bgdisable = ecGray;
frnormal = ecWhite;
this->text = text;
this->tag = tag;
this->font = font;
this->lines = lines;
}
void BUTTON::onPaint(tArea* area)
{
CONTROL::onPaint(area);
switch (me.target)
{
case etLeftTop:
case etRightTop:
default:
LCD::text(text, me.x, me.y + (me.height - font->height * lines) / 2, me.target, font, frnormal, etaCenter, me.width, lines);
break;
case etCenter:
LCD::text(text, me.x, me.y, me.target, font, frnormal, etaCenter, me.width, lines);
break;
case etLeftBottom:
case etRightBottom:
LCD::text(text, me.x, me.y - (me.height - font->height * lines) / 2, me.target, font, frnormal, etaCenter, me.width, lines);
break;
}
}
TEXT::TEXT(const char* text, tArea* area, const tFontHeader* font, eTextAlign align, bool border, bool visible, bool background, bool events)
: CONTROL(area, visible), border(border), align(align)
{
group = true;
this->events = events;
this->background = background;
bgnormal = ecWhite;
bgdisable = ecGray;
frnormal = ecBlack;
frdisable = ecWhite;
this->text = text;
this->font = font;
isFloat = false;
setUnit(NULL);
if (me.height <= 20)
{
if (me.height == 0) me.height = 1;
me.height *= font->height;
}
};
void TEXT::setUnit(const char* unit)
{
if (unit == NULL)
{
this->unit = "";
}
else
{
this->unit = unit;
}
}
void TEXT::setValue(int value)
{
if (!isFloat && text != NULL && this->value == value) return;
isFloat = false;
this->value = value;
char* tmp;
tmp = (char*)malloc(32);
sprintf(tmp, "%i%s", value, unit);
Text(tmp);
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
void TEXT::setValue(double value, int digit)
{
if (isFloat && text != NULL && this->valueD == value) return;
isFloat = true;
this->valueD = value;
char* tmp;
tmp = (char*)malloc(32);
dtoa(tmp, value, digit);
strcat(tmp, unit);
Text(tmp);
}
#pragma GCC diagnostic pop
void TEXT::onPaint(tArea* area)
{
CONTROL::onPaint(area);
int margin = ((border) ? marginBorder : marginNoBorder);
int margin2 = margin * 2;
if (border) LCD::rect(me.x, me.y, me.width, me.height, me.target, 1, ((enable) ? ecBlack : ecGray));
uint16 right = LCD::text(text, me.x + margin, me.y, me.target, font, ((enable) ? frnormal : frdisable), align, me.width - margin2, me.height / font->height);
if (child != NULL)
{
uint8 i;
tArea* a;
right += me.x + margin + font->space;
for (i = 0; i < childCount; i++)
{
a = child[i]->Area();
a->x = right;
right += a->width + font->space;
child[i]->Area(a);
free(a);
}
}
}
IMAGE::IMAGE(const tImgHeader* image, tArea* area, float scale, bool visible, bool events, bool redraw)
: CONTROL(area, visible)
{
group = true;
this->image = image;
this->imageDisable = NULL;
this->scale = scale;
this->events = events;
this->redraw = redraw;
me.width = image->width * scale;
me.height = image->height * scale;
}
void IMAGE::setImage(const tImgHeader* image)
{
if (this->image == image) return;
this->image = image;
state = esPaint;
}
void IMAGE::setImageDisable(const tImgHeader* image)
{
this->imageDisable = ((image == NULL) ? this->image : image);
}
void IMAGE::onPaint(tArea* area __UNUSED)
{
LCD::image(((enable) ? image : imageDisable), me.x, me.y, me.target, scale);
}
BUTTONIMG::BUTTONIMG(const tImgHeader* image, tArea* area, bool visible)
: CONTROL(area, visible)
{
events = true;
group = true;
background = true;
bgnormal = ecBlue;
bgactive = ecLightBlue;
bgdisable = ecGray;
frnormal = ecWhite;
this->tag = tag;
tArea a;
a.target = etCenter;
a.x = me.x + me.width / 2;
a.y = me.y + me.height / 2;
IMAGE* img = new IMAGE(image, &a);
img->setImageDisable();
append(img);
}
NUMBER::NUMBER(int value, int min, int max, tArea* area, const tFontHeader* font, const char** list, bool visible, bool cyclic, bool buttons)
: CONTROL(area, visible), onChange(onNull), min(min), max(max)
{
tArea a;
group = true;
background = true;
bgnormal = ecWhite;
bgactive = ecBlue;
bgdisable = ecLightBlue;
frnormal = ecBlack;
fractive = ecWhite;
frdisable = ecGray;
this->value = value;
this->list = list;
this->tag = tag;
this->font = font;
this->cyclic = cyclic;
_isFloat = false;
onKeyboard = CONTROL::onNull;
a.target = etLeftTop;
a.x = me.x;
a.y = me.y;
a.width = me.width;
if (buttons)
{
a.height = (me.height - font->height - margin * 2) / 2;
up = new BUTTONIMG(&lcdArrowUp2, &a, visible);
up->Tag(this);
up->ForeGround(fractive, frdisable, fractive);
up->BackGround(bgactive, bgdisable, bgdisable);
up->onClick = onClickUp;
up->onPress = onPressUp;
append(up);
a.y += a.height + margin;
}
a.height = 0;
textValue = new TEXT(NULL, &a, font, etaCenter, false, visible, true, true);
textValue->Tag(this);
textValue->ForeGround(frnormal, frdisable, frnormal);
textValue->BackGround(bgnormal, bgnormal, bgnormal);
textValue->onClick = onClickText;
append(textValue);
if (buttons)
{
a.y += font->height + margin;
a.height = (me.height - font->height - margin * 2) / 2;
down = new BUTTONIMG(&lcdArrowDown2, &a, visible);
down->Tag(this);
down->ForeGround(fractive, frdisable, fractive);
down->BackGround(bgactive, bgdisable, bgdisable);
down->onClick = onClickDown;
down->onPress = onPressDown;
append(down);
}
else
{
up = NULL;
down = NULL;
}
resetInterval();
}
void NUMBER::BackGround(eColor normal, eColor disable, eColor active)
{
CONTROL::BackGround(normal, disable, active);
if (up != NULL) up->BackGround(bgactive, bgdisable, bgdisable);
if (down != NULL) down->BackGround(bgactive, bgdisable, bgdisable);
textValue->BackGround(bgnormal, bgnormal, bgnormal);
}
void NUMBER::ForeGround(eColor normal, eColor disable, eColor active)
{
CONTROL::ForeGround(normal, disable, active);
if (up != NULL) up->ForeGround(fractive, frdisable, fractive);
if (down != NULL) down->ForeGround(fractive, frdisable, fractive);
textValue->ForeGround(frnormal, frdisable, frnormal);
}
void NUMBER::onArea(void)
{
tArea a;
a.target = etLeftTop;
a.x = me.x;
a.y = me.y;
a.width = me.width;
a.height = (me.height - font->height - margin * 2) / 2;
up->Area(&a);
a.y += a.height + margin;
a.height = 0;
textValue->Area(&a);
a.y += font->height + margin;
a.height = (me.height - font->height - margin * 2) / 2;
down->Area(&a);
}
void NUMBER::onPaint(tArea* area)
{
CONTROL::onPaint(area);
onUpdate();
}
void NUMBER::onUpdate(void)
{
if (list == NULL)
{
if (_isFloat)
{
textValue->setValue(valueD);
}
else
{
textValue->setValue(value);
}
}
else
{
textValue->Text(list[value]);
}
}
void NUMBER::onClickText(void* tag)
{
((NUMBER*)tag)->onKeyboard(((NUMBER*)tag)->Tag());
}
int NUMBER::Min(void)
{
return min;
}
int NUMBER::Max(void)
{
return max;
}
void NUMBER::setFloat(double value, double min, double max)
{
_isFloat = true;
valueD = value;
minD = min;
maxD = max;
if (state != esPaint) state = esUpdate;
}
bool NUMBER::isFloat(void)
{
return _isFloat;
}
double NUMBER::MinD(void)
{
return minD;
}
double NUMBER::MaxD(void)
{
return maxD;
}
void NUMBER::doMath(int interval)
{
if (_isFloat)
{
double tmp = valueD + interval;
if (tmp > maxD) tmp = ((cyclic) ? minD : maxD);
if (tmp < minD) tmp = ((cyclic) ? maxD : minD);
Value(tmp);
}
else
{
int tmp = value + interval;
if (tmp > max) tmp = ((cyclic) ? min : max);
if (tmp < min) tmp = ((cyclic) ? max : min);
Value(tmp);
}
}
int NUMBER::interval;
int NUMBER::tick;
void NUMBER::resetInterval(void)
{
interval = 1;
tick = 0;
}
void NUMBER::incInterval(void)
{
tick++;
if (interval == 1 && tick >= 70)
{
tick = 0;
interval = 5;
}
else if (interval == 5 && tick >= 100)
{
tick = 0;
interval = 50;
}
else if (interval == 50 && tick >= 150)
{
tick = 0;
interval = 5000;
}
}
void NUMBER::onClickUp(void* tag)
{
resetInterval();
((NUMBER*)tag)->doMath(interval);
}
void NUMBER::onClickDown(void* tag)
{
resetInterval();
((NUMBER*)tag)->doMath(-interval);
}
void NUMBER::onPressUp(void* tag)
{
incInterval();
((NUMBER*)tag)->doMath(interval);
}
void NUMBER::onPressDown(void* tag)
{
incInterval();
((NUMBER*)tag)->doMath(-interval);
}
LIST::LIST(tArea* area, const tFontHeader* font, const tFontHeader* fontHeader, bool visible)
: CONTROL(area, visible)
{
background = true;
group = true;
number = NULL;
header = NULL;
list = NULL;
this->font = font;
this->fontHeader = fontHeader;
heightCount = (me.height - fontHeader->height - padding * 3 + margin) / (font->height + margin);
position = 0;
onKeyboard = CONTROL::onNull;
onItemChange = onItemChangeNull;
}
LIST::~LIST()
{
reset();
}
LIST::tHeader* LIST::createHeader(int count)
{
tHeader* h = NULL;
if (count > 0)
{
int w = (me.width - padding * 2) / count;
h = (tHeader*)malloc(sizeof(tHeader));
h->column = (tCol*)calloc(sizeof(tCol), count);
h->count = count;
for (int i = 0; i < count; i++)
{
h->column[i].text = NULL;
h->column[i].width = w;
h->column[i].type = etcText;
h->column[i].min = -1000000;
h->column[i].max = 1000000;
h->column[i].minD = -1000000;
h->column[i].maxD = 1000000;
h->column[i].isEdit = false;
}
}
return h;
}
LIST::tList* LIST::createList(int count)
{
tList* l = NULL;
if (count > 0 && header != NULL)
{
l = (tList*)malloc(sizeof(tList));
l->row = (tRow*)calloc(sizeof(tRow), count);
l->count = count;
for (int i = 0; i < count; i++)
{
l->row[i].item = (tItem*)calloc(sizeof(tItem), header->count);
for (int n = 0; n < header->count; n++)
{
l->row[i].item[n].flag = eifNull;
}
}
}
return l;
}
void LIST::setHeader(tHeader* header)
{
if (this->header != NULL || list != NULL)
{
reset();
}
this->header = header;
position = 0;
number = (NUMBER***)calloc(sizeof(NUMBER**), header->count);
int i, n;
tArea a;
a.target = etLeftTop;
a.x = me.x + padding;
a.height = font->height;
for (i = 0; i < header->count; i++)
{
a.x += ((i == 0) ? 0 : header->column[i - 1].width);
if (header->column[i].isEdit && header->column[i].type != etcFloat && header->column[i].type != etcInt)
{
header->column[i].isEdit = false;
}
if (header->column[i].isEdit)
{
number[i] = (NUMBER**)calloc(sizeof(NUMBER*), heightCount);
a.y = me.y + padding * 2 + fontHeader->height + margin / 2;
a.width = header->column[i].width;
for (n = 0; n < heightCount; n++)
{
number[i][n] = new NUMBER(0, header->column[i].min, header->column[i].max, &a, font, NULL, visible, false, false);
number[i][n]->BackGround(bgnormal, bgnormal, bgnormal);
number[i][n]->ForeGround(frnormal, frnormal, frnormal);
if (header->column[i].type == etcFloat) number[i][n]->setFloat(0, header->column[i].minD, header->column[i].maxD);
number[i][n]->onKeyboard = onKeyboard;
tTagNumber* tag = (tTagNumber*)malloc(sizeof(tTagNumber));
tag->control = number[i][n];
number[i][n]->Tag(tag);
append(number[i][n]);
a.y += font->height + margin;
}
}
else
{
number[i] = NULL;
}
}
if (state != esPaint) state = esUpdate;
}
void LIST::setList(tList* list)
{
if (header != NULL)
{
resetList();
this->list = list;
position = 0;
if (state != esPaint) state = esUpdate;
}
}
void LIST::cutList(int count)
{
if (list != NULL && count < list->count)
{
if (count < 0) count = 0;
for (int i = count; i < list->count; i++)
{
for (int n = 0; n < header->count; n++)
{
if (header->column[n].type == etcText && list->row[i].item[n].text != NULL && isAddressOfHeap(list->row[i].item[n].text))
{
free((char*)list->row[i].item[n].text);
}
}
free(list->row[i].item);
}
list->count = count;
if (count <= heightCount)
{
position = 0;
}
else if (count <= position)
{
position = count - 1;
}
if (state != esPaint) state = esUpdate;
}
}
void LIST::reverseList(void)
{
if (list != NULL && list->count > 1)
{
int count2 = list->count / 2;
int i, n;
tItem* item;
for (i = 0, n = list->count - 1; i < count2; i++, n--)
{
item = list->row[i].item;
list->row[i].item = list->row[n].item;
list->row[n].item = item;
}
if (state != esPaint) state = esUpdate;
}
}
void LIST::resetList(void)
{
if (list != NULL)
{
cutList(0);
free(list->row);
free(list);
list = NULL;
if (state != esPaint) state = esUpdate;
}
}
bool LIST::isList(void)
{
return (list != NULL);
}
LIST::tList* LIST::getList(void)
{
return list;
}
void LIST::reset(void)
{
resetList();
if (header != NULL)
{
for (int i = 0; i < header->count; i++)
{
if (number[i] != NULL)
{
for (int n = 0; n < heightCount; n++)
{
free(number[i][n]->Tag());
remove(number[i][n]);
delete(number[i][n]);
}
free(number[i]);
}
}
free(number);
number = NULL;
for (int i = 0; i < header->count; i++)
{
if (header->column[i].text != NULL && isAddressOfHeap(header->column[i].text))
{
free((char*)header->column[i].text);
}
}
free(header->column);
free(header);
header = NULL;
}
}
bool LIST::scrollUp(void)
{
if (list != NULL)
{
position--;
if (position < 0) position = 0;
state = esUpdate;
return (position != 0);
}
else
{
return false;
}
}
bool LIST::scrollDown(void)
{
if (list != NULL)
{
int max = list->count - heightCount;
if (max < 0) max = 0;
position++;
if (position > max) position = max;
state = esUpdate;
return (position != max);
}
else
{
return false;
}
}
void LIST::onPaint(tArea* area)
{
CONTROL::onPaint(area);
if (header == NULL) return;
int x, y, i, n;
x = me.x + padding;
y = me.y + padding;
for (i = 0; i < header->count; i++)
{
x += ((i == 0) ? 0 : header->column[i - 1].width);
LCD::text(header->column[i].text, x, y, etLeftTop, fontHeader, fractive, etaLeft, header->column[i].width, 1);
}
x = me.x + padding;
y = me.y + padding * 2 + fontHeader->height + margin / 2 - 1;
for (n = 0; n < heightCount; n++)
{
if (n != (heightCount - 1)) LCD::fill(x, y + font->height + margin / 2, me.width - padding * 2, 1, etLeftTop, bgactive);
y += font->height + margin;
}
onUpdate();
}
void LIST::onUpdate(void)
{
if (list == NULL || !enable) return;
int x, y, i, n, p;
tRow* row;
bool reupdate;
char* tmp = (char*)malloc(32);
const char* tmp2;
RRTC::tDateTime* datetime;
y = me.y + padding * 2 + fontHeader->height + margin / 2;
for (p = 0, n = position; p < heightCount && n < list->count; p++, n++)
{
reupdate = false;
row = &list->row[n];
x = me.x + padding;
for (i = 0; i < header->count; i++)
{
x += ((i == 0) ? 0 : header->column[i - 1].width);
if (header->column[i].isEdit)
{
tTagNumber* tag = (tTagNumber*)number[i][p]->Tag();
tag->index = n;
if (number[i][p]->isChange())
{
if (header->column[i].type == etcFloat)
{
row->item[i].valueD = number[i][p]->ValueD();
}
else
{
row->item[i].valueD = number[i][p]->Value();
}
reupdate = onItemChange(n);
if (reupdate) break;
}
else
{
if (header->column[i].type == etcFloat)
{
number[i][p]->Value(row->item[i].valueD);
}
else
{
number[i][p]->Value(row->item[i].value);
}
number[i][p]->Value();
}
}
else
{
LCD::fill(x, y, header->column[i].width, font->height, etLeftTop, ((enable) ? bgnormal : bgdisable));
tmp2 = tmp;
switch (header->column[i].type)
{
case etcText:
tmp2 = row->item[i].text;
break;
case etcFloat:
dtoa(tmp, row->item[i].valueD, 3);
break;
case etcInt:
sprintf(tmp, "%i", row->item[i].value);
break;
case etcDate:
datetime = RRTC::mkDateTime(row->item[i].datetime);
sprintf(tmp, "%02u.%02u.%04u", datetime->date, datetime->month, 2000 + datetime->year);
free(datetime);
break;
case etcTime:
datetime = RRTC::mkDateTime(row->item[i].datetime);
sprintf(tmp, "%02u:%02u", datetime->hour, datetime->minute);
free(datetime);
break;
case etcTimeWithSecond:
datetime = RRTC::mkDateTime(row->item[i].datetime);
sprintf(tmp, "%02u:%02u:%02u", datetime->hour, datetime->minute, datetime->second);
free(datetime);
break;
case etcTimeWeekHour:
datetime = RRTC::mkDateTime(row->item[i].datetime, true);
sprintf(tmp, "%02u:%02u", datetime->hour, datetime->minute);
free(datetime);
break;
}
switch (row->item[i].flag)
{
case eifNull:
break;
case eifHyphen:
LCD::text("-", x, y, etLeftTop, font, ((enable) ? frnormal : frdisable), etaLeft, header->column[i].width, 1);
break;
default:
LCD::text(tmp2, x, y, etLeftTop, font, ((enable) ? frnormal : frdisable), etaLeft, header->column[i].width, 1);
break;
}
}
}
if (reupdate)
{
p--;
n--;
}
else
{
y += font->height + margin;
}
}
free(tmp);
}
| 19.552896 | 158 | 0.606888 | HiSER |
367d0c71430acdcf2a9f99dead7c1d56b3622f31 | 1,062 | hpp | C++ | include/natalie/managed_vector.hpp | philberty/natalie | 8c10132a07fa2cdd23dc718dbc8020079a8df130 | [
"MIT"
] | null | null | null | include/natalie/managed_vector.hpp | philberty/natalie | 8c10132a07fa2cdd23dc718dbc8020079a8df130 | [
"MIT"
] | null | null | null | include/natalie/managed_vector.hpp | philberty/natalie | 8c10132a07fa2cdd23dc718dbc8020079a8df130 | [
"MIT"
] | null | null | null | #pragma once
#include "natalie/gc.hpp"
#include "tm/vector.hpp"
namespace Natalie {
template <typename T>
class ManagedVector : public Cell, public TM::Vector<T> {
public:
using TM::Vector<T>::Vector;
ManagedVector(const Vector<T> &other)
: ManagedVector {} {
for (auto item : other)
this->push(item);
}
virtual ~ManagedVector() { }
virtual void visit_children(Visitor &visitor) override final {
for (auto it = TM::Vector<T>::begin(); it != TM::Vector<T>::end(); ++it) {
visitor.visit(*it);
}
}
virtual void gc_print() override {
size_t the_size = TM::Vector<T>::size();
fprintf(stderr, "<ManagedVector %p size=%zu [", this, the_size);
size_t index = 0;
for (auto it = TM::Vector<T>::begin(); it != TM::Vector<T>::end(); ++it) {
auto item = *it;
item->gc_print();
if (index + 1 < the_size)
fprintf(stderr, ", ");
++index;
}
fprintf(stderr, "]>");
}
};
}
| 24.697674 | 82 | 0.531073 | philberty |
367e44585a3669facc0846fa77da60b0a651ea88 | 5,687 | cpp | C++ | cap05/cap05-03-01-class_students.cpp | ggaaaff/think_like_a_programmer--test_code | fb081d24d70db6dd503608562625b84607c7a3ab | [
"MIT"
] | 1 | 2020-12-08T10:54:39.000Z | 2020-12-08T10:54:39.000Z | cap05/cap05-03-01-class_students.cpp | ggaaaff/think_like_a_programmer--test_code | fb081d24d70db6dd503608562625b84607c7a3ab | [
"MIT"
] | null | null | null | cap05/cap05-03-01-class_students.cpp | ggaaaff/think_like_a_programmer--test_code | fb081d24d70db6dd503608562625b84607c7a3ab | [
"MIT"
] | null | null | null | //2014.07.20 - 2014.07.21 - 2014.07.22 Gustaf-37 - CTG.
/* PROBLEM :
T R A C K I N G A N U N K N O W N Q U A N T I T Y O F S TU D E N T R E C O R D S
In this problem, you will write a class with methods to store and manipulate a collection
of student records. A student record contains a student number and a grade,
both integers, and a string for the student name.
The following functions are to be implemented:
addRecord This method takes a student number, name, and grade and adds a
new record with this data to the collection.
recordWithNumber This function takes a student number and retrieves the record
with that student number from the collection.
removeRecord This function takes a student number and removes the record with
that student number from the collection.
The collection can be of any size.
The addRecord operation is expected to be called frequently,
so it must be implemented efficiently.
=== PLAN ===
OK - Reuse class studentRecord from code:
/cap05-02-02-class_roster-support_methods.cpp
-
*/
#include <iostream>
#include <string>
using namespace std;
// -----------------------------------------------------------------------------
class studentRecord
{
public:
studentRecord();
studentRecord(int newGrade, int newID, string newName);
int grade();
void setGrade(int newGrade);
int studentID();
void setStudentID(int newID);
string name();
void setName(string newName);
// Support Methods
string letterGrade();
protected:
bool isValidGrade(int grade);
private:
int _grade;
int _studentID;
string _name;
};
// -- Public Methods --
studentRecord::studentRecord()
{
// Values that indicate the object is not properly initialized.
setGrade(0);
setStudentID(-1); //Notice: invalid ID.
setName("");
}
studentRecord::studentRecord(int newGrade, int newID, string newName)
{
setGrade(newGrade);
setStudentID(newID);
setName(newName);
}
int studentRecord::grade()
{
return _grade;
}
void studentRecord::setGrade(int newGrade)
{
if (isValidGrade(newGrade))
{
_grade = newGrade;
}
}
int studentRecord::studentID()
{
return _studentID;
}
void studentRecord::setStudentID(int newID)
{
_studentID = newID;
}
string studentRecord::name()
{
return _name;
}
void studentRecord::setName(string newName)
{
_name = newName;
}
string studentRecord::letterGrade()
{
if (!isValidGrade(_grade))
return "ERROR";
const int NUMBER_CATEGORIES = 11;
const string GRADE_LETTER[] = {"F", "D", "D+", "C-", "C", "C+", "B-", "B", "B+", "A-", "A"};
const int LOWEST_GRADE_SCORE[] = {0, 60, 67, 70, 73, 77, 80, 83, 87, 90, 93};
int category = 0;
while (category < NUMBER_CATEGORIES && LOWEST_GRADE_SCORE[category] <= _grade)
category++;
return GRADE_LETTER[category - 1];
}
// -- Protected Methods --
bool studentRecord::isValidGrade(int grade)
{
if ((grade >= 0) && (grade <= 100))
return true;
else
return false;
}
// -----------------------------------------------------------------------------
class studentCollection
{
private:
struct studentNode
{
studentRecord studentData;
studentNode *next;
};
public:
studentCollection(); // constructor
~studentCollection(); // destructor
void addRecord(studentRecord newStudent);
void removeRecord(int idNum);
studentRecord recordWithNumber(int idNum);
private:
typedef studentNode *studentList;
studentList _listHead;
void deleteList(studentList &listPtr);
};
studentCollection::studentCollection()
{
_listHead = NULL; // initialization.
}
studentCollection::~studentCollection()
{
deleteList(_listHead); // cleans memory.
}
void studentCollection::addRecord(studentRecord newStudent)
{
studentNode *newNode = new studentNode;
newNode -> studentData = newStudent;
// Link at the beginning
newNode -> next = _listHead;
_listHead = newNode;
}
studentRecord studentCollection::recordWithNumber(int idNum)
{
/*
WARNING: The function that calls this method is responsible for checking the
studentRecord that comes back and making sure it’s not the dummy record
before further processing.
*/
studentNode *loopPtr = _listHead;
while ( (loopPtr != NULL) && (loopPtr -> studentData.studentID() != idNum) )
{
loopPtr = loopPtr -> next;
}
if (loopPtr == NULL)
{
// If the list is empty or couldn't find the ID, then creates a fake record.
studentRecord dummyRecord(-1, -1, "");
return dummyRecord;
}
else
{
return loopPtr -> studentData;
}
}
void studentCollection::removeRecord(int idNum)
{
studentNode *trailing = NULL;
// Finding the ID
studentNode *loopPtr = _listHead;
while (loopPtr != NULL && loopPtr -> studentData.studentID() != idNum)
{
trailing = loopPtr;
loopPtr = loopPtr -> next;
}
// list is empty or couldn't find the ID.
if (loopPtr == NULL)
return;
// New link that "removes" the node.
if (trailing == NULL)
{
_listHead = _listHead -> next;
}
else
{
trailing -> next = loopPtr -> next;
}
delete loopPtr; // Clean memory.
}
void studentCollection::deleteList(studentList &listPtr)
{
while (listPtr != NULL)
{
studentNode *temp = listPtr;
listPtr = listPtr -> next;
delete temp;
}
}
int main()
{
cout << "Tracking students records (with a linked list wrapped out by a class)." << endl;
// Test I
studentCollection s;
studentRecord stu3(84, 1152, "Sue");
studentRecord stu2(75, 4875, "Ed");
studentRecord stu1(98, 2938, "Todd");
s.addRecord(stu3);
s.addRecord(stu2);
s.addRecord(stu1);
s.removeRecord(4875);
cout << endl;
return 0;
}
| 18.227564 | 94 | 0.662388 | ggaaaff |
368876e5c495ecb67be9e4a6d6d80a7d2bb17f00 | 12,250 | cpp | C++ | deep500/frameworks/reference/custom_operators/cpp/operators/batchnormalization_op_training.cpp | khoaideptrai/deep500 | 0953038f64bc73c8d41d01796e07d3a23ca97822 | [
"BSD-3-Clause"
] | 90 | 2019-01-02T22:49:08.000Z | 2022-02-17T21:11:38.000Z | deep500/frameworks/reference/custom_operators/cpp/operators/batchnormalization_op_training.cpp | khoaideptrai/deep500 | 0953038f64bc73c8d41d01796e07d3a23ca97822 | [
"BSD-3-Clause"
] | 4 | 2019-02-14T16:19:06.000Z | 2022-01-11T17:54:42.000Z | deep500/frameworks/reference/custom_operators/cpp/operators/batchnormalization_op_training.cpp | khoaideptrai/deep500 | 0953038f64bc73c8d41d01796e07d3a23ca97822 | [
"BSD-3-Clause"
] | 24 | 2019-01-09T18:09:44.000Z | 2022-01-10T13:04:42.000Z | #include <deque>
#include "deep500/deep500.h"
#include "../utility/tensor/copy_data.hpp"
#include "../utility/tensor/set_all.hpp"
#include "../utility/math/mean.hpp"
#include "../utility/math/variance.hpp"
#include <iostream>
//batchnormalization - training mode
template<typename T>
class BatchNormalizationLayerTraining : public deep500::CustomOperator{
protected:
const float m_epsilon;
const float m_momentum;
const int m_spatial;
int m_initalized; //running mean and running var are init. in first call of forward
const std::deque<uint32_t> m_input_shape;
uint32_t m_input_size;
public:
//constructor
BatchNormalizationLayerTraining(
const std::deque<uint32_t> input_shape,
const float epsilon,
const float momentum,
const int spatial) :
m_epsilon(epsilon),
m_momentum(momentum),
m_spatial(spatial),
m_input_shape(input_shape) {
//compute numpber of elements in input
m_input_size = 1;
for(const auto& elem: input_shape)
m_input_size *= elem;
}
//copy constructor
//destructor
virtual ~BatchNormalizationLayerTraining() {}
//member functions
virtual bool supports_cuda() { return false; }
void forward(
const T *input_tensor,
const T *input_tensor2,
const T *input_tensor3,
const T *input_tensor4,
const T *input_tensor5,
T *output_tensor,
T *output_tensor2,
T *output_tensor3,
T *output_tensor4,
T *output_tensor5) {
/*
ONNX notation:
X = input1
scale = input2
B = input3
mean = input4
var = input5
Y = output
*/
//compute mean of minibatch
utilityMath::compute_mean(m_input_shape, input_tensor, output_tensor4);
//compute variance of minibatch
utilityMath::compute_variance(m_input_shape, input_tensor, output_tensor4, output_tensor5);
for(size_t i = 0; i < m_input_shape[1]; i++) {
//compute running mean
output_tensor2[i] = input_tensor2[i] * m_momentum + input_tensor4[i] * (1 - m_momentum);
//compute running var
output_tensor3[i] = input_tensor3[i] * m_momentum + input_tensor5[i] * (1 - m_momentum);
}
size_t num_blocks;
size_t length_block;
size_t num_elements;
size_t spacing;
size_t initial_offset;
size_t temp;
num_blocks = m_input_shape[0];
temp = 1;
for(size_t j = 2; j < m_input_shape.size(); j++) {
temp *= m_input_shape[j];
}
length_block = temp;
num_elements = num_blocks * length_block;
spacing = m_input_shape[1] * length_block;
//compute standard deviation of minibatch
//m_input_shape[1] = size of saved_mean
T sqrtvar[m_input_shape[1]];
for(size_t i = 0; i < m_input_shape[1]; i++) {
sqrtvar[i] = std::sqrt(output_tensor5[i] + m_epsilon);
}
//compute output
//assume: T output_tensor[m_input_size];
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
output_tensor[initial_offset + k * spacing + l] =
input_tensor2[i] * (input_tensor[initial_offset + k * spacing + l] -
output_tensor4[i]) / sqrtvar[i] + input_tensor3[i];
}
}
}
return;
}
void backward(
const T *nextop_grad,
const T *nextop_grad2,
const T *nextop_grad3,
const T *nextop_grad4,
const T *nextop_grad5,
const T *fwd_input_tensor,
const T *fwd_input_tensor2,
const T *fwd_input_tensor3,
const T *fwd_input_tensor4,
const T *fwd_input_tensor5,
const T *fwd_output_tensor,
const T *fwd_output_tensor2,
const T *fwd_output_tensor3,
const T *fwd_output_tensor4,
const T *fwd_output_tensor5,
T *input_tensor_grad,
T *input_tensor2_grad,
T *input_tensor3_grad,
T *input_tensor4_grad,
T *input_tensor5_grad) {
utilityTensor::set_all_zero(m_input_size, input_tensor_grad);
utilityTensor::set_all_zero(m_input_shape[1], input_tensor2_grad);
utilityTensor::set_all_zero(m_input_shape[1], input_tensor3_grad);
utilityTensor::set_all_zero(m_input_shape[1], input_tensor4_grad);
utilityTensor::set_all_zero(m_input_shape[1], input_tensor5_grad);
size_t num_blocks;
size_t length_block;
size_t num_elements;
size_t spacing;
size_t initial_offset;
size_t temp;
num_blocks = m_input_shape[0];
temp = 1;
for(size_t j = 2; j < m_input_shape.size(); j++) {
temp *= m_input_shape[j];
}
length_block = temp;
//number of elements in minibatch per channel
num_elements = num_blocks * length_block;
spacing = m_input_shape[1] * length_block;
T x_min_mu[m_input_size];
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
x_min_mu[initial_offset + k * spacing + l] =
fwd_input_tensor[initial_offset + k * spacing + l] - fwd_output_tensor4[i];
}
}
}
T sqrtvar[m_input_shape[1]];
for(size_t i = 0; i < m_input_shape[1]; i++) {
sqrtvar[i] = std::sqrt(fwd_output_tensor5[i] + m_epsilon);
}
T ivar[m_input_shape[1]];
for(size_t i = 0; i < m_input_shape[1]; i++) {
ivar[i] = 1. / sqrtvar[i];
}
T x_hat[m_input_size];
T d_x_hat[m_input_size];
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
x_hat[initial_offset + k * spacing + l] = x_min_mu[initial_offset + k * spacing + l] * ivar[i];
d_x_hat[initial_offset + k * spacing + l] = fwd_input_tensor2[i] * nextop_grad[initial_offset + k * spacing + l];
}
}
}
T d_w[m_input_shape[1]];
T d_b[m_input_shape[1]];
utilityTensor::set_all_zero(m_input_shape[1], d_w);
utilityTensor::set_all_zero(m_input_shape[1], d_b);
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
d_w[i] += nextop_grad[initial_offset + k * spacing + l] * x_hat[initial_offset + k * spacing + l];
d_b[i] += nextop_grad[initial_offset + k * spacing + l];
}
}
}
T d_ivar[m_input_shape[1]];
utilityTensor::set_all_zero(m_input_shape[1], d_ivar);
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
d_ivar[i] += d_x_hat[initial_offset + k * spacing + l] * x_min_mu[initial_offset + k * spacing + l];
}
}
}
T d_xmu1[m_input_size];
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
d_xmu1[initial_offset + k * spacing + l] = d_x_hat[initial_offset + k * spacing + l] * ivar[i];
}
}
}
T d_sqrtvar[m_input_shape[1]];
for(size_t i = 0; i < m_input_shape[1]; i++) {
d_sqrtvar[i] = -1. / std::pow(sqrtvar[i], 2) * d_ivar[i];
}
T d_var[m_input_shape[1]];
for(size_t i = 0; i < m_input_shape[1]; i++) {
d_var[i] = 0.5 * 1. / sqrtvar[i] * d_sqrtvar[i];
}
T d_sq[m_input_size];
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
d_sq[initial_offset + k * spacing + l] = 1. / (T) num_elements * d_var[i];
}
}
}
T d_xmu2[m_input_size];
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
d_xmu2[initial_offset + k * spacing + l] = 2 * x_min_mu[initial_offset + k * spacing + l] * d_sq[initial_offset + k * spacing + l];
}
}
}
T d_x1[m_input_size];
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
d_x1[initial_offset + k * spacing + l] = d_xmu1[initial_offset + k * spacing + l] + d_xmu2[initial_offset + k * spacing + l];
}
}
}
T d_mu[m_input_shape[1]];
utilityTensor::set_all_zero(m_input_shape[1], d_mu);
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
d_mu[i] += (-1.) * (d_xmu1[initial_offset + k * spacing + l] + d_xmu2[initial_offset + k * spacing + l]);
}
}
}
T d_x2[m_input_size];
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
d_x2[initial_offset + k * spacing + l] = 1. / (T) num_elements * d_mu[i];
}
}
}
//bwd_params
for(size_t i = 0; i < m_input_shape[1]; i++) {
initial_offset = i * length_block;
for(size_t k = 0; k < num_blocks; k++) {
for(size_t l = 0; l < length_block; l++) {
input_tensor2_grad[i] += nextop_grad[initial_offset + k * spacing + l] * (fwd_input_tensor[
initial_offset + k * spacing + l] - fwd_output_tensor4[i]) / sqrtvar[i];
input_tensor3_grad[i] += nextop_grad[initial_offset + k * spacing + l];
}
}
}
for(size_t i = 0; i < m_input_size; i++) {
input_tensor_grad[i] = d_x1[i] + d_x2[i];
}
utilityTensor::set_all_zero(m_input_shape[1], input_tensor4_grad);
utilityTensor::set_all_zero(m_input_shape[1], input_tensor5_grad);
return;
}
};
D500_EXPORTED void *create_new_op(deep500::tensor_t *input_descriptors,
int num_inputs,
deep500::tensor_t *param_descriptors,
int num_params,
deep500::tensor_t *output_descriptors,
int num_outputs) {
std::deque<uint32_t> input_tensor_shape(
input_descriptors[0].sizes,
input_descriptors[0].sizes + input_descriptors[0].dims
);
return new BatchNormalizationLayerTraining<DTYPE>(input_tensor_shape, EPSILON, MOMENTUM, SPATIAL);
}
D500_REGISTER_OP(BatchNormalizationLayerTraining<DTYPE>); | 35.100287 | 151 | 0.535592 | khoaideptrai |
368a9c681bb6654cad78e79a3a798703c643e134 | 4,598 | cpp | C++ | jlp_wxplot/jlp_wxplot_plot/jlp_wxlogbook.cpp | jlprieur/jlplib | 6073d7a7eb76d916662b1f8a4eb54f345cf7c772 | [
"MIT"
] | null | null | null | jlp_wxplot/jlp_wxplot_plot/jlp_wxlogbook.cpp | jlprieur/jlplib | 6073d7a7eb76d916662b1f8a4eb54f345cf7c772 | [
"MIT"
] | null | null | null | jlp_wxplot/jlp_wxplot_plot/jlp_wxlogbook.cpp | jlprieur/jlplib | 6073d7a7eb76d916662b1f8a4eb54f345cf7c772 | [
"MIT"
] | 1 | 2020-07-09T00:20:49.000Z | 2020-07-09T00:20:49.000Z | /******************************************************************************
* Name: jlp_wxlogbook.cpp (GpdLogbook class)
* Purpose: Logbook utilities
* Author: JLP
* Version: 03/01/2015
******************************************************************************/
#include "jlp_wxlogbook.h"
#include "jlp_wxspeckle1_dlg.h" // JLP_wxSpeckle1_Dlg
/*
JLP_wxLogbook(wxWindow *window, const wxString title, const int iwidth,
const int iheight);
~JLP_wxLogbook();
int SaveLogbook(wxString save_filename)
void Clear()
void Clean()
int WriteToLogbook(wxString str1, bool SaveToFile);
int BinariesSaveMeasurements(wxString m_full_filename1);
*/
BEGIN_EVENT_TABLE(JLP_wxLogbook, wxTextCtrl)
END_EVENT_TABLE()
/**********************************************************************
* JLP_wxLogbook constructor
*
* INPUT:
* xx,yy : size of created window
*
***********************************************************************/
JLP_wxLogbook::JLP_wxLogbook(wxWindow *window, const wxString title, const int xx, const int yy)
: wxTextCtrl(window, wxID_ANY, title, wxPoint(-1, -1), wxSize(xx, yy),
wxTE_MULTILINE | wxTE_READONLY /* | wxTE_RICH */)
{
return;
}
/**********************************************************************
* JLP_wxLogbook destructor
*
* INPUT:
* xx,yy : size of created window
*
***********************************************************************/
JLP_wxLogbook::~JLP_wxLogbook()
{
return;
}
/************************************************************************
* Save useful content of logbook to file
* Input:
* save_filename: wxString whose value is set in gdp_frame_menu.cpp
************************************************************************/
int JLP_wxLogbook::SaveLogbook(wxString save_filename)
{
int status = 0;
wxFile *m_log_file;
m_log_file = new wxFile();
// Overwrite = true:
m_log_file->Create(save_filename, true);
if(!m_log_file->IsOpened()) {
wxLogError(_T("Error opening log file!\n"));
status = -1;
} else {
m_log_file->Write(m_LogString);
m_log_file->Close();
delete m_log_file;
}
return(status);
}
/*******************************************************************
* Clear the logbook: erase all its content
********************************************************************/
void JLP_wxLogbook::Clear()
{
m_LogString.Clear();
SetValue(m_LogString);
return;
}
/*******************************************************************
* Clean the logbook: only keep its useful content
********************************************************************/
void JLP_wxLogbook::Clean()
{
wxString str1;
// First erase screen:
str1 = wxString("");
SetValue(str1);
// Then display usefull content:
SetValue(m_LogString);
}
/*******************************************************************
* Write a string to the logbook
********************************************************************/
int JLP_wxLogbook::WriteToLogbook(wxString str1, bool SaveToFile)
{
int status = 0;
if(SaveToFile) m_LogString.Append(str1);
*this << str1;
return(status);
}
/**************************************************************************
* Binaries: process and saving measurements to Latex file
*
* INPUT:
* original_fits_fname: FITS file obtained from the observations
* (full name with directory and extension)
* processed_fits_fname: processed FITS file used for the measurements
* (name without directory and extension)
*
**************************************************************************/
int JLP_wxLogbook::BinariesSaveMeasurements(wxString original_fits_fname,
wxString processed_fits_fname)
{
double font_width;
int status = -1;
// One possibility is:
// iwFont = wxNORMAL_FONT->GetPointSize();
//
wxFont m_Font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
font_width = m_Font.GetPointSize();
// Smaller width if font width is not a fixed:
if(!m_Font.IsFixedWidth()) font_width *= 0.8;
wxSize size1 = wxSize((int)(80. * font_width), (int)(32. * font_width));
// Speckle, DVA mode or Lucky imaging:
// process and save measurements to Latex file
// Read the header of the FITS file to fill the result latex line
if( (new JLP_wxSpeckle1_Dlg((wxFrame *)this, m_LogString, original_fits_fname,
processed_fits_fname,
_T("Processing and saving measurements"),
size1))->ShowModal() == wxID_OK) status = 0;
return(status);
}
| 32.380282 | 96 | 0.514572 | jlprieur |
368f49394200baccc9da366ae59691bd796f553c | 72 | hpp | C++ | Addons/e12_tools/script_component.hpp | Echo12/e12_tools_ace3 | 41ae1e76a6c0177b73f9f0eef65f19a911f09099 | [
"MIT"
] | 1 | 2015-06-04T17:53:30.000Z | 2015-06-04T17:53:30.000Z | Addons/e12_tools/script_component.hpp | Echo12/e12_tools_ace3 | 41ae1e76a6c0177b73f9f0eef65f19a911f09099 | [
"MIT"
] | 17 | 2015-06-04T19:27:03.000Z | 2020-04-17T19:47:35.000Z | Addons/e12_tools/script_component.hpp | Echo12/e12_tools_ace3 | 41ae1e76a6c0177b73f9f0eef65f19a911f09099 | [
"MIT"
] | 2 | 2015-06-08T14:18:36.000Z | 2016-07-12T18:14:54.000Z | #define COMPONENT tools
#define PREFIX e12
#include "script_macros.hpp" | 18 | 28 | 0.805556 | Echo12 |
369160dcf51f1fa8ba74af241f4a355c3b15a8f2 | 2,362 | cpp | C++ | mozilla/gfx/thebes/gfxQuartzNativeDrawing.cpp | naver/webgraphics | 4f9b9aa6a13428b5872dd020eaf34ec77b33f240 | [
"MS-PL"
] | 5 | 2016-12-20T15:48:05.000Z | 2020-05-01T20:12:09.000Z | mozilla/gfx/thebes/gfxQuartzNativeDrawing.cpp | naver/webgraphics | 4f9b9aa6a13428b5872dd020eaf34ec77b33f240 | [
"MS-PL"
] | null | null | null | mozilla/gfx/thebes/gfxQuartzNativeDrawing.cpp | naver/webgraphics | 4f9b9aa6a13428b5872dd020eaf34ec77b33f240 | [
"MS-PL"
] | 2 | 2016-12-20T15:48:13.000Z | 2019-12-10T15:15:05.000Z | /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "gfxQuartzNativeDrawing.h"
#include "gfxPlatform.h"
#include "mozilla/gfx/Helpers.h"
using namespace mozilla::gfx;
using namespace mozilla;
gfxQuartzNativeDrawing::gfxQuartzNativeDrawing(DrawTarget& aDrawTarget,
const Rect& nativeRect)
: mDrawTarget(&aDrawTarget)
, mNativeRect(nativeRect)
, mCGContext(nullptr)
{
}
CGContextRef
gfxQuartzNativeDrawing::BeginNativeDrawing()
{
NS_ASSERTION(!mCGContext, "BeginNativeDrawing called when drawing already in progress");
DrawTarget *dt = mDrawTarget;
if (dt->GetBackendType() != BackendType::COREGRAPHICS ||
dt->IsDualDrawTarget() ||
dt->IsTiledDrawTarget()) {
// We need a DrawTarget that we can get a CGContextRef from:
Matrix transform = dt->GetTransform();
mNativeRect = transform.TransformBounds(mNativeRect);
mNativeRect.RoundOut();
// Quartz theme drawing often adjusts drawing rects, so make
// sure our surface is big enough for that.
mNativeRect.Inflate(5);
if (mNativeRect.IsEmpty()) {
return nullptr;
}
mTempDrawTarget =
Factory::CreateDrawTarget(BackendType::COREGRAPHICS,
IntSize(mNativeRect.width, mNativeRect.height),
SurfaceFormat::B8G8R8A8);
if (mTempDrawTarget) {
transform.PostTranslate(-mNativeRect.x, -mNativeRect.y);
mTempDrawTarget->SetTransform(transform);
}
dt = mTempDrawTarget;
}
if (dt) {
mCGContext = mBorrowedContext.Init(dt);
MOZ_ASSERT(mCGContext);
}
return mCGContext;
}
void
gfxQuartzNativeDrawing::EndNativeDrawing()
{
NS_ASSERTION(mCGContext, "EndNativeDrawing called without BeginNativeDrawing");
mBorrowedContext.Finish();
if (mTempDrawTarget) {
RefPtr<SourceSurface> source = mTempDrawTarget->Snapshot();
AutoRestoreTransform autoRestore(mDrawTarget);
mDrawTarget->SetTransform(Matrix());
mDrawTarget->DrawSurface(source, mNativeRect,
Rect(0, 0, mNativeRect.width, mNativeRect.height));
}
}
| 31.493333 | 90 | 0.681202 | naver |
3691f3e0762f55a980cef62b2af0d06ad85933cb | 5,474 | cpp | C++ | rocAL/rocAL/source/meta_node_rotate.cpp | Indumathi31/MIVisionX | e58c8b63d51e3f857d5f1c8750433d1ec887d7f0 | [
"MIT"
] | null | null | null | rocAL/rocAL/source/meta_node_rotate.cpp | Indumathi31/MIVisionX | e58c8b63d51e3f857d5f1c8750433d1ec887d7f0 | [
"MIT"
] | 8 | 2021-12-10T14:07:28.000Z | 2022-03-04T02:53:11.000Z | rocAL/rocAL/source/meta_node_rotate.cpp | Indumathi31/MIVisionX | e58c8b63d51e3f857d5f1c8750433d1ec887d7f0 | [
"MIT"
] | 2 | 2021-06-01T09:42:51.000Z | 2021-11-09T14:35:36.000Z | /*
Copyright (c) 2019 - 2022 Advanced Micro Devices, Inc. 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 "meta_node_rotate.h"
void RotateMetaNode::initialize()
{
_src_height_val.resize(_batch_size);
_src_width_val.resize(_batch_size);
_angle_val.resize(_batch_size);
}
void RotateMetaNode::update_parameters(MetaDataBatch* input_meta_data)
{
initialize();
if(_batch_size != input_meta_data->size())
{
_batch_size = input_meta_data->size();
}
_src_width = _node->get_src_width();
_src_height = _node->get_src_height();
_dst_width = _node->get_dst_width();
_dst_height = _node->get_dst_height();
_angle = _node->get_angle();
vxCopyArrayRange((vx_array)_src_width, 0, _batch_size, sizeof(uint),_src_width_val.data(), VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
vxCopyArrayRange((vx_array)_src_height, 0, _batch_size, sizeof(uint),_src_height_val.data(), VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
vxCopyArrayRange((vx_array)_angle, 0, _batch_size, sizeof(float),_angle_val.data(), VX_READ_ONLY, VX_MEMORY_TYPE_HOST);
BoundingBoxCord temp_box = {0, 0, 1, 1};
for(int i = 0; i < _batch_size; i++)
{
auto bb_count = input_meta_data->get_bb_labels_batch()[i].size();
int labels_buf[bb_count];
float coords_buf[bb_count*4];
memcpy(labels_buf, input_meta_data->get_bb_labels_batch()[i].data(), sizeof(int)*bb_count);
memcpy(coords_buf, input_meta_data->get_bb_cords_batch()[i].data(), input_meta_data->get_bb_cords_batch()[i].size() * sizeof(BoundingBoxCord));
BoundingBoxCords bb_coords;
BoundingBoxLabels bb_labels;
BoundingBoxCord dest_image;
dest_image.l = dest_image.t = 0;
dest_image.r = _dst_width;
dest_image.b = _dst_height;
for(uint j = 0, m = 0; j < bb_count; j++)
{
BoundingBoxCord box;
float src_bb_x, src_bb_y, bb_w, bb_h;
float dest_cx, dest_cy, src_cx, src_cy;
float x1, y1, x2, y2, x3, y3, x4, y4, min_x, min_y;
float rotate[4];
float radian = RAD(_angle_val[i]);
rotate[0] = rotate[3] = cos(radian);
rotate[1] = sin(radian);
rotate[2] = -1 * rotate[1];
dest_cx = _dst_width / 2;
dest_cy = _dst_height / 2;
src_cx = _src_width_val[i]/2;
src_cy = _src_height_val[i]/2;
src_bb_x = (coords_buf[m++]);
src_bb_y = (coords_buf[m++]);
bb_w = (coords_buf[m++]);
bb_h = (coords_buf[m++]);
x1 = (rotate[0] * (src_bb_x - src_cx)) + (rotate[1] * (src_bb_y - src_cy)) + dest_cx;
y1 = (rotate[2] * (src_bb_x - src_cx)) + (rotate[3] * (src_bb_y - src_cy)) + dest_cy;
x2 = (rotate[0] * ((src_bb_x + bb_w) - src_cx))+( rotate[1] * (src_bb_y - src_cy)) + dest_cx;
y2 = (rotate[2] * ((src_bb_x + bb_w) - src_cx))+( rotate[3] * (src_bb_y - src_cy)) + dest_cy;
x3 = (rotate[0] * (src_bb_x - src_cx)) + (rotate[1] * ((src_bb_y + bb_h) - src_cy)) + dest_cx;
y3 = (rotate[2] * (src_bb_x - src_cx)) + (rotate[3] * ((src_bb_y + bb_h) - src_cy)) + dest_cy;
x4 = (rotate[0] * ((src_bb_x + bb_w) - src_cx))+( rotate[1] * ((src_bb_y + bb_h) - src_cy)) + dest_cx;
y4 = (rotate[2] * ((src_bb_x + bb_w) - src_cx))+( rotate[3] * ((src_bb_y + bb_h) - src_cy)) + dest_cy;
min_x = std::min(x1, std::min(x2, std::min(x3, x4)));
min_y = std::min(y1, std::min(y2, std::min(y3, y4)));
box.l = std::max(min_x, 0.0f);
box.t = std::max(min_y, 0.0f);
box.r = std::max(x1, std::max(x2, std::max(x3, x4))); ;
box.b = std::max(y1, std::max(y2, std::max(y3, y4)));
if (BBoxIntersectionOverUnion(box, dest_image) >= _iou_threshold)
{
box.l = std::max(dest_image.l, box.l);
box.t = std::max(dest_image.t, box.t);
box.r = std::min(dest_image.r, box.r);
box.b = std::min(dest_image.b, box.b);
bb_coords.push_back(box);
bb_labels.push_back(labels_buf[j]);
}
}
if(bb_coords.size() == 0)
{
bb_coords.push_back(temp_box);
bb_labels.push_back(0);
}
input_meta_data->get_bb_cords_batch()[i] = bb_coords;
input_meta_data->get_bb_labels_batch()[i] = bb_labels;
}
}
| 49.315315 | 151 | 0.620935 | Indumathi31 |
369947a42f5980121c03baf7cb2e4bab1ecad920 | 2,918 | hpp | C++ | plugin/com.blackberry.push/src/blackberry10/native/push_ndk.hpp | timwindsor/cordova-blackberry-plugins | a3e9e7d22f54d464647e60ef3ec574b324a5972e | [
"Apache-2.0"
] | 5 | 2015-03-04T00:17:54.000Z | 2019-06-27T13:36:05.000Z | plugin/com.blackberry.push/src/blackberry10/native/push_ndk.hpp | timwindsor/cordova-blackberry-plugins | a3e9e7d22f54d464647e60ef3ec574b324a5972e | [
"Apache-2.0"
] | 6 | 2015-02-09T21:33:52.000Z | 2017-06-02T16:19:26.000Z | plugin/com.blackberry.push/src/blackberry10/native/push_ndk.hpp | timwindsor/cordova-blackberry-plugins | a3e9e7d22f54d464647e60ef3ec574b324a5972e | [
"Apache-2.0"
] | 10 | 2015-01-27T22:58:19.000Z | 2019-02-15T19:07:01.000Z | /*
* Copyright 2012 Research In Motion Limited.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef PUSH_NDK_H_
#define PUSH_NDK_H_
#include <bb/communications/push/PushErrno.hpp>
#include <bb/communications/push/PushService.hpp>
#include <pthread.h>
#include <string>
#include "../common/plugin.h"
#define INVALID_PPS_FILE_DESCRIPTOR -1
class Push;
namespace webworks {
enum PipeFileDescriptor {
PIPE_READ_FD = 0,
PIPE_WRITE_FD,
PIPE_FD_SIZE
};
typedef bb::communications::push::PushListener PushListener;
typedef bb::communications::push::PushService PushService;
typedef bb::communications::push::PushStatus PushStatus;
typedef bb::communications::push::PushPayload PushPayload;
typedef bb::communications::push::PushCommand PushCommand;
class PushNDK: public PushListener {
public:
explicit PushNDK(Push *parent);
virtual ~PushNDK();
void StartService(const std::string& invokeTargetId, const std::string& appId, const std::string& ppgUrl);
void CreateChannel();
void DestroyChannel();
std::string ExtractPushPayload(const std::string& invokeData);
void RegisterToLaunch();
void UnregisterFromLaunch();
void Acknowledge(const std::string& payloadId, bool shouldAccept);
static void* MonitorMessagesStartThread(void* parent);
void MonitorMessages();
// Interfaces defined in PushListener
virtual void onCreateSessionComplete(const PushStatus& status);
virtual void onCreateChannelComplete(const PushStatus& status, const std::string& token);
virtual void onDestroyChannelComplete(const PushStatus& status);
virtual void onRegisterToLaunchComplete(const PushStatus& status);
virtual void onUnregisterFromLaunchComplete(const PushStatus& status);
virtual void onSimChange();
virtual void onPushTransportReady(PushCommand command);
private:
void stopService();
int startMonitorThread();
std::string decodeBase64(const std::string& encodedString);
private:
Push *m_parent;
std::string m_invokeTargetId;
std::string m_appId;
std::string m_ppgUrl;
PushService* m_pPushService;
int m_fileDescriptor; // Push service file descriptor
pthread_t m_monitorThread;
int m_pipeFileDescriptors[PIPE_FD_SIZE]; // pipe to write dummy data to wake up select
bool m_shutdownThread;
};
} // namespace webworks
#endif /* PUSH_NDK_H_ */
| 32.422222 | 110 | 0.746059 | timwindsor |
369b399ba774a134189ef45d65f93dcdc50cd32f | 468 | cpp | C++ | simulation_code/src/matplotlib-cpp/examples/scatter.cpp | lottegr/project_simulation | b95d88114a3d2611073d1977393884062f63bdab | [
"Apache-2.0"
] | 58 | 2019-12-30T19:39:52.000Z | 2022-03-27T15:55:10.000Z | simulation_code/src/matplotlib-cpp/examples/scatter.cpp | lottegr/project_simulation | b95d88114a3d2611073d1977393884062f63bdab | [
"Apache-2.0"
] | 3 | 2021-08-25T13:22:52.000Z | 2022-03-20T18:26:01.000Z | simulation_code/src/matplotlib-cpp/examples/scatter.cpp | lottegr/project_simulation | b95d88114a3d2611073d1977393884062f63bdab | [
"Apache-2.0"
] | 39 | 2020-02-26T11:37:14.000Z | 2022-03-22T09:50:24.000Z | #define _USE_MATH_DEFINES
#include <cmath>
#include <vector>
#include "../matplotlibcpp.h"
namespace plt = matplotlibcpp;
void plot() {
const unsigned n = 100;
std::vector<double> x(n), y(n);
#include <iostream>
for (unsigned i = 0; i < n; ++i) {
x[i] = sin(2 * M_PI * i / n);
y[i] = cos(2 * M_PI * i / n);
}
plt::scatter(x, y, {{"color", "red"}, {"label", "a circle!"}});
plt::legend();
plt::show();
}
int main() {
plot();
return 0;
}
| 18 | 65 | 0.553419 | lottegr |
36a094dbc76b7b0a88755d149665033df62acfd8 | 1,465 | cpp | C++ | lib/Target/Sophon/BM188x/Compute/AveragePool.cpp | LiuLeif/onnc | 3f69e46172a9c33cc04541ff7fd78d5d7b6bdbba | [
"BSD-3-Clause"
] | 450 | 2018-08-03T08:17:03.000Z | 2022-03-17T17:21:06.000Z | lib/Target/Sophon/BM188x/Compute/AveragePool.cpp | ffk0716/onnc | 91e4955ade64b479db17aaeccacf4b7339fe44d2 | [
"BSD-3-Clause"
] | 104 | 2018-08-13T07:31:50.000Z | 2021-08-24T11:24:40.000Z | lib/Target/Sophon/BM188x/Compute/AveragePool.cpp | ffk0716/onnc | 91e4955ade64b479db17aaeccacf4b7339fe44d2 | [
"BSD-3-Clause"
] | 100 | 2018-08-12T04:27:39.000Z | 2022-03-11T04:17:42.000Z | //===- AveragePool.cpp ----------------------------------------------------===//
//
// The ONNC Project
//
// See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define DEBUG_TYPE "tg_averagepool"
#include "AveragePool.h"
#include "../BM188xVisitor.h"
using namespace onnc;
using namespace onnc::BM188X;
char BM188X::AveragePool::ID = 0;
//===----------------------------------------------------------------------===//
// AveragePool
//===----------------------------------------------------------------------===//
BM188X::AveragePool::AveragePool(const IntsAttr& pKernelShape)
: onnc::AveragePool(pKernelShape), m_EnableRelu(0), m_RShiftWidth(0),
m_ThresholdXQuantized(0)
{
setID(ID);
setPads(IntsAttr(4, 0)); //< fill constructor {0, 0, 0, 0}
setStrides(IntsAttr(2, 1)); //< fill constructor {1, 1}
}
void BM188X::AveragePool::print(std::ostream& pOS) const
{
// TODO
}
void BM188X::AveragePool::accept(ComputeVisitor& pV)
{
BM188xVisitor* visitor = dyn_cast<BM188xVisitor>(&pV);
if (nullptr != visitor)
visitor->visit(*this);
}
void BM188X::AveragePool::accept(ComputeVisitor& pV) const
{
BM188xVisitor* visitor = dyn_cast<BM188xVisitor>(&pV);
if (nullptr != visitor)
visitor->visit(*this);
}
bool BM188X::AveragePool::classof(const ComputeOperator* pOp)
{
if (nullptr == pOp)
return false;
return (pOp->getID() == &ID);
}
| 27.12963 | 80 | 0.536519 | LiuLeif |
36a18d97f6a25b52bd2e3685ba32a5e61a821e22 | 750 | cpp | C++ | some homeworks/hunterhw10/main.cpp | jamalakhaligova/ELTE-OOP- | 65a549801f74ad04c813f58bcc7cad3affe0e135 | [
"Apache-2.0"
] | null | null | null | some homeworks/hunterhw10/main.cpp | jamalakhaligova/ELTE-OOP- | 65a549801f74ad04c813f58bcc7cad3affe0e135 | [
"Apache-2.0"
] | null | null | null | some homeworks/hunterhw10/main.cpp | jamalakhaligova/ELTE-OOP- | 65a549801f74ad04c813f58bcc7cad3affe0e135 | [
"Apache-2.0"
] | null | null | null | #include <iostream>
#include "hunter.h"
#include "Trophy.h"
using namespace std;
int countOfLions(vector <Trophy> &trophies);
int main()
{
Hunter Person("Jack",32);
Lion first("lion","forest","2007.08.18",54,"male");
Elephant second("elephant","forest","2014.06.20",108,27);
Lion third("lion","forest","2009.04.12",38,"female");
Person.trophies = {first,second,third};
int lions=countOfLions(Person.trophies);
cout<<"Count of lions that hunter killed " << lions <<endl;
return 0;
}
int countOfLions(vector <Trophy> &trophies)
{
int c_lions=0;
for(int i=0;i<trophies.size();i++)
{
if(trophies[i].getSpecies() == "lion")
{
++c_lions;
}
}
return c_lions;
}
| 20.27027 | 63 | 0.605333 | jamalakhaligova |
36a2f395a7966b144f786d9d006fbdbf6938b656 | 693,984 | cpp | C++ | unity/builds/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs74.cpp | leeenglestone/mrtk | e9c81815e5cdfba3315bb72f16400a80383a3b63 | [
"MIT"
] | null | null | null | unity/builds/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs74.cpp | leeenglestone/mrtk | e9c81815e5cdfba3315bb72f16400a80383a3b63 | [
"MIT"
] | null | null | null | unity/builds/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs74.cpp | leeenglestone/mrtk | e9c81815e5cdfba3315bb72f16400a80383a3b63 | [
"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"
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);
}
};
// System.Action`1<System.Collections.Generic.IEnumerable`1<System.String>>
struct Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439;
// System.Action`1<System.Object>
struct Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC;
// System.Action`1<System.String>
struct Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,System.UInt32>
struct Dictionary_2_tB877F46A6C20A56DEA8ED6DC3E004A3171647E3B;
// System.Collections.Generic.Dictionary`2<UnityEngine.XR.InputDevice,Microsoft.MixedReality.Toolkit.XRSDK.Input.GenericXRSDKController>
struct Dictionary_2_t2FB6B87AE845471F5ACC7900099F9B8BFE071E0E;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Threading.Tasks.Task>
struct Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8;
// System.Collections.Generic.Dictionary`2<System.String,System.Resources.ResourceLocator>
struct Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA;
// System.Collections.Generic.Dictionary`2<System.Type,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry>>
struct Dictionary_2_t9C346C961DA726D2E935BCA9F27BF39FE4EB463B;
// UnityEngine.EventSystems.ExecuteEvents/EventFunction`1<Microsoft.MixedReality.Toolkit.Teleport.IMixedRealityTeleportHandler>
struct EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246;
// System.Func`1<System.Threading.Tasks.Task/ContingentProperties>
struct Func_1_tBCF42601FA307876E83080BE4204110820F8BF3B;
// System.Func`2<System.Object,System.Int32>
struct Func_2_t0CEE9D1C856153BA9C23BB9D7E929D577AF37A2C;
// System.Func`2<System.Object,System.String>
struct Func_2_t060A650AB95DEF14D4F579FA5999ACEFEEE0FD82;
// System.Collections.Generic.List`1<System.Tuple`2<Microsoft.MixedReality.Toolkit.BaseEventSystem/Action,UnityEngine.GameObject>>
struct List_1_tFBD74CBAB85AF6A2E49F61373B8A7503C022E2CD;
// System.Collections.Generic.List`1<System.Tuple`3<Microsoft.MixedReality.Toolkit.BaseEventSystem/Action,System.Type,UnityEngine.EventSystems.IEventSystemHandler>>
struct List_1_tB2338FC47817B39A67EDF98A81C666A585CBB1B0;
// System.Collections.Generic.List`1<UnityEngine.GameObject>
struct List_1_t6D0A10F47F3440798295D2FFFC6D016477AF38E5;
// System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.IMixedRealityDataProvider>
struct List_1_t94FC783F2185B5CB832CD245C5E89430CC6533D4;
// System.Collections.Generic.List`1<UnityEngine.XR.InputDevice>
struct List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F;
// System.Collections.Generic.List`1<UnityEngine.XR.InputDeviceCharacteristics>
struct List_1_tD812850D83CCFFD34E9A310E2AE62B198E513F2C;
// System.Collections.Generic.List`1<UnityEngine.Ray>
struct List_1_tDBBF8003D7BAC756EE5262C1DF03096EB730DF2B;
// Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessEventData`1<Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject>
struct MixedRealitySpatialAwarenessEventData_1_t7ED8A8C4F13DE7DA0CDB49A53184152431B8337F;
// System.Predicate`1<System.Object>
struct Predicate_1_t5C96B81B31A697B11C4C3767E3298773AF25DFEB;
// System.Predicate`1<System.Threading.Tasks.Task>
struct Predicate_1_tC0DBBC8498BD1EE6ABFFAA5628024105FA7D11BD;
// System.Threading.Tasks.Task`1<System.Boolean>
struct Task_1_t9C1FE9F18F52F3409B9E970FA38801A443AE7849;
// System.Byte[]
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726;
// System.Char[]
struct CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34;
// System.Int32[]
struct Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32;
// System.Object[]
struct ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE;
// System.RuntimeType[]
struct RuntimeTypeU5BU5D_t826186B59A32B687978751BFE46041623BCF4BA4;
// Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager/PointerConfig[]
struct PointerConfigU5BU5D_t17182F245D18BDE8E16CCF14BC0FF2793EF9B08E;
// System.Action
struct Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6;
// System.Collections.ArrayList
struct ArrayList_t6C1A49839DC1F0D568E8E11FA1626FCF0EC06575;
// Microsoft.MixedReality.Toolkit.BaseMixedRealityProfile
struct BaseMixedRealityProfile_tC5DBD7146B1E1D467DE81BA1EAB45133408A59E1;
// System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
struct BinaryFormatter_tAA0465FE94B272FAC7C99F6AD38120E9319C5F55;
// System.IO.BinaryReader
struct BinaryReader_t4F45C15FF44F8E1C105704A21FFBE58D60015128;
// System.Byte
struct Byte_t0111FAB8B8685667EDDAF77683F0D8F86B659056;
// System.Threading.ContextCallback
struct ContextCallback_t93707E0430F4FF3E15E1FB5A4844BE89C657AE8B;
// System.Globalization.CultureInfo
struct CultureInfo_t1B787142231DB79ABDCE0659823F908A040E9A98;
// System.Text.Decoder
struct Decoder_t91B2ED8AEC25AA24D23A00265203BE992B12C370;
// System.Text.Encoding
struct Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827;
// UnityEngine.GameObject
struct GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319;
// System.Collections.Hashtable
struct Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC;
// System.Collections.IComparer
struct IComparer_t624EE667DCB0D3765FF034F7150DA71B361B82C0;
// System.IFormatProvider
struct IFormatProvider_tF2AECC4B14F41D36718920D67F930CED940412DF;
// Microsoft.MixedReality.Toolkit.Input.IMixedRealityInputSystem
struct IMixedRealityInputSystem_t0EDEF390D5E8DB56C2251E372228BADDA9F6CF24;
// Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar
struct IMixedRealityServiceRegistrar_t81B35976BCAABB86634D8CAB6C5EBECE36D65D3A;
// Microsoft.Win32.IRegistryApi
struct IRegistryApi_t3B05FA1782C2EFEE5A2A5251BB4CE24F61272463;
// System.Resources.IResourceReader
struct IResourceReader_tB5A7F9D51AB1F5FEC29628E2E541338D44A88379;
// System.Int32
struct Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046;
// System.Threading.ManualResetEvent
struct ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA;
// Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystemProfile
struct MixedRealitySpatialAwarenessSystemProfile_tFA00D9B0001845CDB1DEB2D3E3BB08CB3A553891;
// Microsoft.MixedReality.Toolkit.Input.UnityInput.MouseController
struct MouseController_t3A7451F1C270293BDDED7C6012F92C6023F21E0C;
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50;
// System.Resources.ResourceReader
struct ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492;
// System.Security.Cryptography.SHA1Internal
struct SHA1Internal_t5D0A95A55E32BCC8976D5B91649E6C13C8334CD6;
// System.Runtime.InteropServices.SafeBuffer
struct SafeBuffer_tABA0D0B754FCCF3625CD905D535296E353C630D2;
// Microsoft.Win32.SafeHandles.SafeRegistryHandle
struct SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545;
// Microsoft.Win32.SafeHandles.SafeWaitHandle
struct SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1;
// System.Threading.SemaphoreSlim
struct SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385;
// System.Threading.Tasks.StackGuard
struct StackGuard_t88E1EE4741AD02CA5FEA04A4EB2CC70F230E0E6D;
// System.IO.Stream
struct Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB;
// System.String
struct String_t;
// System.Threading.Tasks.Task
struct Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60;
// System.Threading.Tasks.TaskFactory
struct TaskFactory_t22D999A05A967C31A4B5FFBD08864809BF35EA3B;
// System.Threading.Tasks.TaskScheduler
struct TaskScheduler_t74FBEEEDBDD5E0088FF0EEC18F45CD866B098D5D;
// Microsoft.MixedReality.Toolkit.Teleport.TeleportEventData
struct TeleportEventData_tD38237F467954AFE4C5D13E66D5BFBAB826AAAC2;
// System.Type
struct Type_t;
// System.IO.UnmanagedMemoryStream
struct UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62;
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5;
// Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem/SceneContentTracker
struct SceneContentTracker_t63E7FA6D49DD34641F8A8975B6808FFC39383B65;
// Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem/SceneLightingExecutor
struct SceneLightingExecutor_t284A3495A5AF7E28B3778E8605ACF1806F2A1556;
// UnityEngine.RectTransform/ReapplyDrivenProperties
struct ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE;
// Mono.RuntimeStructs/GPtrArray
struct GPtrArray_t481A0359CDF30AF32FB5B6D0DDBA2C26F55E3555;
// System.Threading.SemaphoreSlim/TaskNode
struct TaskNode_tD3014A57510D018F890E6524AC62F9417E2E6C4E;
// System.Collections.SortedList/KeyList
struct KeyList_t90FF026A62D56329DEFC1B768358977E70839881;
// System.Collections.SortedList/ValueList
struct ValueList_t3A0529729679D12F7F3AF77C48E10D5E6009CD3D;
// System.IO.Stream/ReadWriteTask
struct ReadWriteTask_t32CD2C230786712954C1DB518DBE420A1F4C7974;
// System.Threading.Tasks.Task/ContingentProperties
struct ContingentProperties_t1E249C737B8B8644ED1D60EEFA101D326B199EA0;
IL2CPP_EXTERN_C RuntimeClass* OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Rect_tC45F1DDF39812623644DE296D8057A4958176627_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* String_t_il2cpp_TypeInfo_var;
struct DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ;
struct Guid_t ;
struct IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB;
struct IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C;
struct Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ;
struct Rect_tC45F1DDF39812623644DE296D8057A4958176627 ;
struct Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ;
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ;
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.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.IReference`1<System.Single>
struct NOVTABLE IReference_1_tD4026FABBA608F648777776BC282618C51E2AF46 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m82E1812FB137290B0EE35532E1008D32226FE5F3(float* 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;
};
// Windows.Foundation.IClosable
struct NOVTABLE IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() = 0;
};
// System.Object
// System.Runtime.ConstrainedExecution.CriticalFinalizerObject
struct CriticalFinalizerObject_tA3367C832FFE7434EB3C15C7136AF25524150997 : public RuntimeObject
{
public:
public:
};
// System.Security.Cryptography.HashAlgorithm
struct HashAlgorithm_t7F831BEF35F9D0AF5016FFB0E474AF9F93908F31 : public RuntimeObject
{
public:
// System.Int32 System.Security.Cryptography.HashAlgorithm::HashSizeValue
int32_t ___HashSizeValue_0;
// System.Byte[] System.Security.Cryptography.HashAlgorithm::HashValue
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___HashValue_1;
// System.Int32 System.Security.Cryptography.HashAlgorithm::State
int32_t ___State_2;
// System.Boolean System.Security.Cryptography.HashAlgorithm::m_bDisposed
bool ___m_bDisposed_3;
public:
inline static int32_t get_offset_of_HashSizeValue_0() { return static_cast<int32_t>(offsetof(HashAlgorithm_t7F831BEF35F9D0AF5016FFB0E474AF9F93908F31, ___HashSizeValue_0)); }
inline int32_t get_HashSizeValue_0() const { return ___HashSizeValue_0; }
inline int32_t* get_address_of_HashSizeValue_0() { return &___HashSizeValue_0; }
inline void set_HashSizeValue_0(int32_t value)
{
___HashSizeValue_0 = value;
}
inline static int32_t get_offset_of_HashValue_1() { return static_cast<int32_t>(offsetof(HashAlgorithm_t7F831BEF35F9D0AF5016FFB0E474AF9F93908F31, ___HashValue_1)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_HashValue_1() const { return ___HashValue_1; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_HashValue_1() { return &___HashValue_1; }
inline void set_HashValue_1(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___HashValue_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___HashValue_1), (void*)value);
}
inline static int32_t get_offset_of_State_2() { return static_cast<int32_t>(offsetof(HashAlgorithm_t7F831BEF35F9D0AF5016FFB0E474AF9F93908F31, ___State_2)); }
inline int32_t get_State_2() const { return ___State_2; }
inline int32_t* get_address_of_State_2() { return &___State_2; }
inline void set_State_2(int32_t value)
{
___State_2 = value;
}
inline static int32_t get_offset_of_m_bDisposed_3() { return static_cast<int32_t>(offsetof(HashAlgorithm_t7F831BEF35F9D0AF5016FFB0E474AF9F93908F31, ___m_bDisposed_3)); }
inline bool get_m_bDisposed_3() const { return ___m_bDisposed_3; }
inline bool* get_address_of_m_bDisposed_3() { return &___m_bDisposed_3; }
inline void set_m_bDisposed_3(bool value)
{
___m_bDisposed_3 = value;
}
};
// System.MarshalByRefObject
struct MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8 : public RuntimeObject
{
public:
// System.Object System.MarshalByRefObject::_identity
RuntimeObject * ____identity_0;
public:
inline static int32_t get_offset_of__identity_0() { return static_cast<int32_t>(offsetof(MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8, ____identity_0)); }
inline RuntimeObject * get__identity_0() const { return ____identity_0; }
inline RuntimeObject ** get_address_of__identity_0() { return &____identity_0; }
inline void set__identity_0(RuntimeObject * value)
{
____identity_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____identity_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8_marshaled_pinvoke
{
Il2CppIUnknown* ____identity_0;
};
// Native definition for COM marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8_marshaled_com
{
Il2CppIUnknown* ____identity_0;
};
// System.Security.Cryptography.OidCollection
struct OidCollection_tA091E185B8840648BE96A6C547F0C26F88E3A902 : public RuntimeObject
{
public:
// System.Collections.ArrayList System.Security.Cryptography.OidCollection::m_list
ArrayList_t6C1A49839DC1F0D568E8E11FA1626FCF0EC06575 * ___m_list_0;
public:
inline static int32_t get_offset_of_m_list_0() { return static_cast<int32_t>(offsetof(OidCollection_tA091E185B8840648BE96A6C547F0C26F88E3A902, ___m_list_0)); }
inline ArrayList_t6C1A49839DC1F0D568E8E11FA1626FCF0EC06575 * get_m_list_0() const { return ___m_list_0; }
inline ArrayList_t6C1A49839DC1F0D568E8E11FA1626FCF0EC06575 ** get_address_of_m_list_0() { return &___m_list_0; }
inline void set_m_list_0(ArrayList_t6C1A49839DC1F0D568E8E11FA1626FCF0EC06575 * value)
{
___m_list_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_list_0), (void*)value);
}
};
// System.Collections.Queue
struct Queue_t66723C58C7422102C36F8570BE048BD0CC489E52 : public RuntimeObject
{
public:
// System.Object[] System.Collections.Queue::_array
ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* ____array_0;
// System.Int32 System.Collections.Queue::_head
int32_t ____head_1;
// System.Int32 System.Collections.Queue::_tail
int32_t ____tail_2;
// System.Int32 System.Collections.Queue::_size
int32_t ____size_3;
// System.Int32 System.Collections.Queue::_growFactor
int32_t ____growFactor_4;
// System.Int32 System.Collections.Queue::_version
int32_t ____version_5;
// System.Object System.Collections.Queue::_syncRoot
RuntimeObject * ____syncRoot_6;
public:
inline static int32_t get_offset_of__array_0() { return static_cast<int32_t>(offsetof(Queue_t66723C58C7422102C36F8570BE048BD0CC489E52, ____array_0)); }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* get__array_0() const { return ____array_0; }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE** get_address_of__array_0() { return &____array_0; }
inline void set__array_0(ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* value)
{
____array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____array_0), (void*)value);
}
inline static int32_t get_offset_of__head_1() { return static_cast<int32_t>(offsetof(Queue_t66723C58C7422102C36F8570BE048BD0CC489E52, ____head_1)); }
inline int32_t get__head_1() const { return ____head_1; }
inline int32_t* get_address_of__head_1() { return &____head_1; }
inline void set__head_1(int32_t value)
{
____head_1 = value;
}
inline static int32_t get_offset_of__tail_2() { return static_cast<int32_t>(offsetof(Queue_t66723C58C7422102C36F8570BE048BD0CC489E52, ____tail_2)); }
inline int32_t get__tail_2() const { return ____tail_2; }
inline int32_t* get_address_of__tail_2() { return &____tail_2; }
inline void set__tail_2(int32_t value)
{
____tail_2 = value;
}
inline static int32_t get_offset_of__size_3() { return static_cast<int32_t>(offsetof(Queue_t66723C58C7422102C36F8570BE048BD0CC489E52, ____size_3)); }
inline int32_t get__size_3() const { return ____size_3; }
inline int32_t* get_address_of__size_3() { return &____size_3; }
inline void set__size_3(int32_t value)
{
____size_3 = value;
}
inline static int32_t get_offset_of__growFactor_4() { return static_cast<int32_t>(offsetof(Queue_t66723C58C7422102C36F8570BE048BD0CC489E52, ____growFactor_4)); }
inline int32_t get__growFactor_4() const { return ____growFactor_4; }
inline int32_t* get_address_of__growFactor_4() { return &____growFactor_4; }
inline void set__growFactor_4(int32_t value)
{
____growFactor_4 = value;
}
inline static int32_t get_offset_of__version_5() { return static_cast<int32_t>(offsetof(Queue_t66723C58C7422102C36F8570BE048BD0CC489E52, ____version_5)); }
inline int32_t get__version_5() const { return ____version_5; }
inline int32_t* get_address_of__version_5() { return &____version_5; }
inline void set__version_5(int32_t value)
{
____version_5 = value;
}
inline static int32_t get_offset_of__syncRoot_6() { return static_cast<int32_t>(offsetof(Queue_t66723C58C7422102C36F8570BE048BD0CC489E52, ____syncRoot_6)); }
inline RuntimeObject * get__syncRoot_6() const { return ____syncRoot_6; }
inline RuntimeObject ** get_address_of__syncRoot_6() { return &____syncRoot_6; }
inline void set__syncRoot_6(RuntimeObject * value)
{
____syncRoot_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&____syncRoot_6), (void*)value);
}
};
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 : public RuntimeObject
{
public:
public:
};
// System.Resources.ResourceFallbackManager
struct ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652 : public RuntimeObject
{
public:
// System.Globalization.CultureInfo System.Resources.ResourceFallbackManager::m_startingCulture
CultureInfo_t1B787142231DB79ABDCE0659823F908A040E9A98 * ___m_startingCulture_0;
// System.Globalization.CultureInfo System.Resources.ResourceFallbackManager::m_neutralResourcesCulture
CultureInfo_t1B787142231DB79ABDCE0659823F908A040E9A98 * ___m_neutralResourcesCulture_1;
// System.Boolean System.Resources.ResourceFallbackManager::m_useParents
bool ___m_useParents_2;
public:
inline static int32_t get_offset_of_m_startingCulture_0() { return static_cast<int32_t>(offsetof(ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652, ___m_startingCulture_0)); }
inline CultureInfo_t1B787142231DB79ABDCE0659823F908A040E9A98 * get_m_startingCulture_0() const { return ___m_startingCulture_0; }
inline CultureInfo_t1B787142231DB79ABDCE0659823F908A040E9A98 ** get_address_of_m_startingCulture_0() { return &___m_startingCulture_0; }
inline void set_m_startingCulture_0(CultureInfo_t1B787142231DB79ABDCE0659823F908A040E9A98 * value)
{
___m_startingCulture_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_startingCulture_0), (void*)value);
}
inline static int32_t get_offset_of_m_neutralResourcesCulture_1() { return static_cast<int32_t>(offsetof(ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652, ___m_neutralResourcesCulture_1)); }
inline CultureInfo_t1B787142231DB79ABDCE0659823F908A040E9A98 * get_m_neutralResourcesCulture_1() const { return ___m_neutralResourcesCulture_1; }
inline CultureInfo_t1B787142231DB79ABDCE0659823F908A040E9A98 ** get_address_of_m_neutralResourcesCulture_1() { return &___m_neutralResourcesCulture_1; }
inline void set_m_neutralResourcesCulture_1(CultureInfo_t1B787142231DB79ABDCE0659823F908A040E9A98 * value)
{
___m_neutralResourcesCulture_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_neutralResourcesCulture_1), (void*)value);
}
inline static int32_t get_offset_of_m_useParents_2() { return static_cast<int32_t>(offsetof(ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652, ___m_useParents_2)); }
inline bool get_m_useParents_2() const { return ___m_useParents_2; }
inline bool* get_address_of_m_useParents_2() { return &___m_useParents_2; }
inline void set_m_useParents_2(bool value)
{
___m_useParents_2 = value;
}
};
// System.Resources.ResourceReader
struct ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492 : public RuntimeObject
{
public:
// System.IO.BinaryReader System.Resources.ResourceReader::_store
BinaryReader_t4F45C15FF44F8E1C105704A21FFBE58D60015128 * ____store_0;
// System.Collections.Generic.Dictionary`2<System.String,System.Resources.ResourceLocator> System.Resources.ResourceReader::_resCache
Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * ____resCache_1;
// System.Int64 System.Resources.ResourceReader::_nameSectionOffset
int64_t ____nameSectionOffset_2;
// System.Int64 System.Resources.ResourceReader::_dataSectionOffset
int64_t ____dataSectionOffset_3;
// System.Int32[] System.Resources.ResourceReader::_nameHashes
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ____nameHashes_4;
// System.Int32* System.Resources.ResourceReader::_nameHashesPtr
int32_t* ____nameHashesPtr_5;
// System.Int32[] System.Resources.ResourceReader::_namePositions
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ____namePositions_6;
// System.Int32* System.Resources.ResourceReader::_namePositionsPtr
int32_t* ____namePositionsPtr_7;
// System.RuntimeType[] System.Resources.ResourceReader::_typeTable
RuntimeTypeU5BU5D_t826186B59A32B687978751BFE46041623BCF4BA4* ____typeTable_8;
// System.Int32[] System.Resources.ResourceReader::_typeNamePositions
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ____typeNamePositions_9;
// System.Runtime.Serialization.Formatters.Binary.BinaryFormatter System.Resources.ResourceReader::_objFormatter
BinaryFormatter_tAA0465FE94B272FAC7C99F6AD38120E9319C5F55 * ____objFormatter_10;
// System.Int32 System.Resources.ResourceReader::_numResources
int32_t ____numResources_11;
// System.IO.UnmanagedMemoryStream System.Resources.ResourceReader::_ums
UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62 * ____ums_12;
// System.Int32 System.Resources.ResourceReader::_version
int32_t ____version_13;
public:
inline static int32_t get_offset_of__store_0() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____store_0)); }
inline BinaryReader_t4F45C15FF44F8E1C105704A21FFBE58D60015128 * get__store_0() const { return ____store_0; }
inline BinaryReader_t4F45C15FF44F8E1C105704A21FFBE58D60015128 ** get_address_of__store_0() { return &____store_0; }
inline void set__store_0(BinaryReader_t4F45C15FF44F8E1C105704A21FFBE58D60015128 * value)
{
____store_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____store_0), (void*)value);
}
inline static int32_t get_offset_of__resCache_1() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____resCache_1)); }
inline Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * get__resCache_1() const { return ____resCache_1; }
inline Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA ** get_address_of__resCache_1() { return &____resCache_1; }
inline void set__resCache_1(Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * value)
{
____resCache_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____resCache_1), (void*)value);
}
inline static int32_t get_offset_of__nameSectionOffset_2() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____nameSectionOffset_2)); }
inline int64_t get__nameSectionOffset_2() const { return ____nameSectionOffset_2; }
inline int64_t* get_address_of__nameSectionOffset_2() { return &____nameSectionOffset_2; }
inline void set__nameSectionOffset_2(int64_t value)
{
____nameSectionOffset_2 = value;
}
inline static int32_t get_offset_of__dataSectionOffset_3() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____dataSectionOffset_3)); }
inline int64_t get__dataSectionOffset_3() const { return ____dataSectionOffset_3; }
inline int64_t* get_address_of__dataSectionOffset_3() { return &____dataSectionOffset_3; }
inline void set__dataSectionOffset_3(int64_t value)
{
____dataSectionOffset_3 = value;
}
inline static int32_t get_offset_of__nameHashes_4() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____nameHashes_4)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get__nameHashes_4() const { return ____nameHashes_4; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of__nameHashes_4() { return &____nameHashes_4; }
inline void set__nameHashes_4(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
____nameHashes_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____nameHashes_4), (void*)value);
}
inline static int32_t get_offset_of__nameHashesPtr_5() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____nameHashesPtr_5)); }
inline int32_t* get__nameHashesPtr_5() const { return ____nameHashesPtr_5; }
inline int32_t** get_address_of__nameHashesPtr_5() { return &____nameHashesPtr_5; }
inline void set__nameHashesPtr_5(int32_t* value)
{
____nameHashesPtr_5 = value;
}
inline static int32_t get_offset_of__namePositions_6() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____namePositions_6)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get__namePositions_6() const { return ____namePositions_6; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of__namePositions_6() { return &____namePositions_6; }
inline void set__namePositions_6(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
____namePositions_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&____namePositions_6), (void*)value);
}
inline static int32_t get_offset_of__namePositionsPtr_7() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____namePositionsPtr_7)); }
inline int32_t* get__namePositionsPtr_7() const { return ____namePositionsPtr_7; }
inline int32_t** get_address_of__namePositionsPtr_7() { return &____namePositionsPtr_7; }
inline void set__namePositionsPtr_7(int32_t* value)
{
____namePositionsPtr_7 = value;
}
inline static int32_t get_offset_of__typeTable_8() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____typeTable_8)); }
inline RuntimeTypeU5BU5D_t826186B59A32B687978751BFE46041623BCF4BA4* get__typeTable_8() const { return ____typeTable_8; }
inline RuntimeTypeU5BU5D_t826186B59A32B687978751BFE46041623BCF4BA4** get_address_of__typeTable_8() { return &____typeTable_8; }
inline void set__typeTable_8(RuntimeTypeU5BU5D_t826186B59A32B687978751BFE46041623BCF4BA4* value)
{
____typeTable_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&____typeTable_8), (void*)value);
}
inline static int32_t get_offset_of__typeNamePositions_9() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____typeNamePositions_9)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get__typeNamePositions_9() const { return ____typeNamePositions_9; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of__typeNamePositions_9() { return &____typeNamePositions_9; }
inline void set__typeNamePositions_9(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
____typeNamePositions_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&____typeNamePositions_9), (void*)value);
}
inline static int32_t get_offset_of__objFormatter_10() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____objFormatter_10)); }
inline BinaryFormatter_tAA0465FE94B272FAC7C99F6AD38120E9319C5F55 * get__objFormatter_10() const { return ____objFormatter_10; }
inline BinaryFormatter_tAA0465FE94B272FAC7C99F6AD38120E9319C5F55 ** get_address_of__objFormatter_10() { return &____objFormatter_10; }
inline void set__objFormatter_10(BinaryFormatter_tAA0465FE94B272FAC7C99F6AD38120E9319C5F55 * value)
{
____objFormatter_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&____objFormatter_10), (void*)value);
}
inline static int32_t get_offset_of__numResources_11() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____numResources_11)); }
inline int32_t get__numResources_11() const { return ____numResources_11; }
inline int32_t* get_address_of__numResources_11() { return &____numResources_11; }
inline void set__numResources_11(int32_t value)
{
____numResources_11 = value;
}
inline static int32_t get_offset_of__ums_12() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____ums_12)); }
inline UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62 * get__ums_12() const { return ____ums_12; }
inline UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62 ** get_address_of__ums_12() { return &____ums_12; }
inline void set__ums_12(UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62 * value)
{
____ums_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____ums_12), (void*)value);
}
inline static int32_t get_offset_of__version_13() { return static_cast<int32_t>(offsetof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492, ____version_13)); }
inline int32_t get__version_13() const { return ____version_13; }
inline int32_t* get_address_of__version_13() { return &____version_13; }
inline void set__version_13(int32_t value)
{
____version_13 = value;
}
};
// System.Resources.ResourceSet
struct ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F : public RuntimeObject
{
public:
// System.Resources.IResourceReader System.Resources.ResourceSet::Reader
RuntimeObject* ___Reader_0;
// System.Collections.Hashtable System.Resources.ResourceSet::Table
Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC * ___Table_1;
// System.Collections.Hashtable System.Resources.ResourceSet::_caseInsensitiveTable
Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC * ____caseInsensitiveTable_2;
public:
inline static int32_t get_offset_of_Reader_0() { return static_cast<int32_t>(offsetof(ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F, ___Reader_0)); }
inline RuntimeObject* get_Reader_0() const { return ___Reader_0; }
inline RuntimeObject** get_address_of_Reader_0() { return &___Reader_0; }
inline void set_Reader_0(RuntimeObject* value)
{
___Reader_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Reader_0), (void*)value);
}
inline static int32_t get_offset_of_Table_1() { return static_cast<int32_t>(offsetof(ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F, ___Table_1)); }
inline Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC * get_Table_1() const { return ___Table_1; }
inline Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC ** get_address_of_Table_1() { return &___Table_1; }
inline void set_Table_1(Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC * value)
{
___Table_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Table_1), (void*)value);
}
inline static int32_t get_offset_of__caseInsensitiveTable_2() { return static_cast<int32_t>(offsetof(ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F, ____caseInsensitiveTable_2)); }
inline Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC * get__caseInsensitiveTable_2() const { return ____caseInsensitiveTable_2; }
inline Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC ** get_address_of__caseInsensitiveTable_2() { return &____caseInsensitiveTable_2; }
inline void set__caseInsensitiveTable_2(Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC * value)
{
____caseInsensitiveTable_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____caseInsensitiveTable_2), (void*)value);
}
};
// System.Collections.SortedList
struct SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165 : public RuntimeObject
{
public:
// System.Object[] System.Collections.SortedList::keys
ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* ___keys_0;
// System.Object[] System.Collections.SortedList::values
ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* ___values_1;
// System.Int32 System.Collections.SortedList::_size
int32_t ____size_2;
// System.Int32 System.Collections.SortedList::version
int32_t ___version_3;
// System.Collections.IComparer System.Collections.SortedList::comparer
RuntimeObject* ___comparer_4;
// System.Collections.SortedList/KeyList System.Collections.SortedList::keyList
KeyList_t90FF026A62D56329DEFC1B768358977E70839881 * ___keyList_5;
// System.Collections.SortedList/ValueList System.Collections.SortedList::valueList
ValueList_t3A0529729679D12F7F3AF77C48E10D5E6009CD3D * ___valueList_6;
// System.Object System.Collections.SortedList::_syncRoot
RuntimeObject * ____syncRoot_7;
public:
inline static int32_t get_offset_of_keys_0() { return static_cast<int32_t>(offsetof(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165, ___keys_0)); }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* get_keys_0() const { return ___keys_0; }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE** get_address_of_keys_0() { return &___keys_0; }
inline void set_keys_0(ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* value)
{
___keys_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___keys_0), (void*)value);
}
inline static int32_t get_offset_of_values_1() { return static_cast<int32_t>(offsetof(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165, ___values_1)); }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* get_values_1() const { return ___values_1; }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE** get_address_of_values_1() { return &___values_1; }
inline void set_values_1(ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* value)
{
___values_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___values_1), (void*)value);
}
inline static int32_t get_offset_of__size_2() { return static_cast<int32_t>(offsetof(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165, ____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(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165, ___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_comparer_4() { return static_cast<int32_t>(offsetof(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165, ___comparer_4)); }
inline RuntimeObject* get_comparer_4() const { return ___comparer_4; }
inline RuntimeObject** get_address_of_comparer_4() { return &___comparer_4; }
inline void set_comparer_4(RuntimeObject* value)
{
___comparer_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___comparer_4), (void*)value);
}
inline static int32_t get_offset_of_keyList_5() { return static_cast<int32_t>(offsetof(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165, ___keyList_5)); }
inline KeyList_t90FF026A62D56329DEFC1B768358977E70839881 * get_keyList_5() const { return ___keyList_5; }
inline KeyList_t90FF026A62D56329DEFC1B768358977E70839881 ** get_address_of_keyList_5() { return &___keyList_5; }
inline void set_keyList_5(KeyList_t90FF026A62D56329DEFC1B768358977E70839881 * value)
{
___keyList_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___keyList_5), (void*)value);
}
inline static int32_t get_offset_of_valueList_6() { return static_cast<int32_t>(offsetof(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165, ___valueList_6)); }
inline ValueList_t3A0529729679D12F7F3AF77C48E10D5E6009CD3D * get_valueList_6() const { return ___valueList_6; }
inline ValueList_t3A0529729679D12F7F3AF77C48E10D5E6009CD3D ** get_address_of_valueList_6() { return &___valueList_6; }
inline void set_valueList_6(ValueList_t3A0529729679D12F7F3AF77C48E10D5E6009CD3D * value)
{
___valueList_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___valueList_6), (void*)value);
}
inline static int32_t get_offset_of__syncRoot_7() { return static_cast<int32_t>(offsetof(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165, ____syncRoot_7)); }
inline RuntimeObject * get__syncRoot_7() const { return ____syncRoot_7; }
inline RuntimeObject ** get_address_of__syncRoot_7() { return &____syncRoot_7; }
inline void set__syncRoot_7(RuntimeObject * value)
{
____syncRoot_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&____syncRoot_7), (void*)value);
}
};
struct SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165_StaticFields
{
public:
// System.Object[] System.Collections.SortedList::emptyArray
ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* ___emptyArray_9;
public:
inline static int32_t get_offset_of_emptyArray_9() { return static_cast<int32_t>(offsetof(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165_StaticFields, ___emptyArray_9)); }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* get_emptyArray_9() const { return ___emptyArray_9; }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE** get_address_of_emptyArray_9() { return &___emptyArray_9; }
inline void set_emptyArray_9(ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* value)
{
___emptyArray_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___emptyArray_9), (void*)value);
}
};
// System.Collections.Stack
struct Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8 : public RuntimeObject
{
public:
// System.Object[] System.Collections.Stack::_array
ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* ____array_0;
// System.Int32 System.Collections.Stack::_size
int32_t ____size_1;
// System.Int32 System.Collections.Stack::_version
int32_t ____version_2;
// System.Object System.Collections.Stack::_syncRoot
RuntimeObject * ____syncRoot_3;
public:
inline static int32_t get_offset_of__array_0() { return static_cast<int32_t>(offsetof(Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8, ____array_0)); }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* get__array_0() const { return ____array_0; }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE** get_address_of__array_0() { return &____array_0; }
inline void set__array_0(ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* value)
{
____array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____array_0), (void*)value);
}
inline static int32_t get_offset_of__size_1() { return static_cast<int32_t>(offsetof(Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8, ____size_1)); }
inline int32_t get__size_1() const { return ____size_1; }
inline int32_t* get_address_of__size_1() { return &____size_1; }
inline void set__size_1(int32_t value)
{
____size_1 = value;
}
inline static int32_t get_offset_of__version_2() { return static_cast<int32_t>(offsetof(Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8, ____version_2)); }
inline int32_t get__version_2() const { return ____version_2; }
inline int32_t* get_address_of__version_2() { return &____version_2; }
inline void set__version_2(int32_t value)
{
____version_2 = value;
}
inline static int32_t get_offset_of__syncRoot_3() { return static_cast<int32_t>(offsetof(Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8, ____syncRoot_3)); }
inline RuntimeObject * get__syncRoot_3() const { return ____syncRoot_3; }
inline RuntimeObject ** get_address_of__syncRoot_3() { return &____syncRoot_3; }
inline void set__syncRoot_3(RuntimeObject * value)
{
____syncRoot_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&____syncRoot_3), (void*)value);
}
};
// 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((void**)(&___Empty_5), (void*)value);
}
};
// System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52 : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_com
{
};
// System.Nullable`1<System.Boolean>
struct Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3
{
public:
// T System.Nullable`1::value
bool ___value_0;
// System.Boolean System.Nullable`1::has_value
bool ___has_value_1;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3, ___value_0)); }
inline bool get_value_0() const { return ___value_0; }
inline bool* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(bool value)
{
___value_0 = value;
}
inline static int32_t get_offset_of_has_value_1() { return static_cast<int32_t>(offsetof(Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3, ___has_value_1)); }
inline bool get_has_value_1() const { return ___has_value_1; }
inline bool* get_address_of_has_value_1() { return &___has_value_1; }
inline void set_has_value_1(bool value)
{
___has_value_1 = value;
}
};
// System.Boolean
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37
{
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_t07D1E3F34E4813023D64F584DFF7B34C9D922F37, ___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_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_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_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_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((void**)(&___TrueString_5), (void*)value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_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((void**)(&___FalseString_6), (void*)value);
}
};
// Windows.Foundation.DateTime
struct DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C
{
public:
// System.Int64 Windows.Foundation.DateTime::UniversalTime
int64_t ___UniversalTime_0;
public:
inline static int32_t get_offset_of_UniversalTime_0() { return static_cast<int32_t>(offsetof(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C, ___UniversalTime_0)); }
inline int64_t get_UniversalTime_0() const { return ___UniversalTime_0; }
inline int64_t* get_address_of_UniversalTime_0() { return &___UniversalTime_0; }
inline void set_UniversalTime_0(int64_t value)
{
___UniversalTime_0 = value;
}
};
// System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA : public ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52
{
public:
public:
};
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___enumSeperatorCharArray_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_com
{
};
// System.Runtime.InteropServices.GCHandle
struct GCHandle_t757890BC4BBBEDE5A623A3C110013EDD24613603
{
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_t757890BC4BBBEDE5A623A3C110013EDD24613603, ___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;
}
};
// System.Guid
struct Guid_t
{
public:
// System.Int32 System.Guid::_a
int32_t ____a_1;
// System.Int16 System.Guid::_b
int16_t ____b_2;
// System.Int16 System.Guid::_c
int16_t ____c_3;
// System.Byte System.Guid::_d
uint8_t ____d_4;
// System.Byte System.Guid::_e
uint8_t ____e_5;
// System.Byte System.Guid::_f
uint8_t ____f_6;
// System.Byte System.Guid::_g
uint8_t ____g_7;
// System.Byte System.Guid::_h
uint8_t ____h_8;
// System.Byte System.Guid::_i
uint8_t ____i_9;
// System.Byte System.Guid::_j
uint8_t ____j_10;
// System.Byte System.Guid::_k
uint8_t ____k_11;
public:
inline static int32_t get_offset_of__a_1() { return static_cast<int32_t>(offsetof(Guid_t, ____a_1)); }
inline int32_t get__a_1() const { return ____a_1; }
inline int32_t* get_address_of__a_1() { return &____a_1; }
inline void set__a_1(int32_t value)
{
____a_1 = value;
}
inline static int32_t get_offset_of__b_2() { return static_cast<int32_t>(offsetof(Guid_t, ____b_2)); }
inline int16_t get__b_2() const { return ____b_2; }
inline int16_t* get_address_of__b_2() { return &____b_2; }
inline void set__b_2(int16_t value)
{
____b_2 = value;
}
inline static int32_t get_offset_of__c_3() { return static_cast<int32_t>(offsetof(Guid_t, ____c_3)); }
inline int16_t get__c_3() const { return ____c_3; }
inline int16_t* get_address_of__c_3() { return &____c_3; }
inline void set__c_3(int16_t value)
{
____c_3 = value;
}
inline static int32_t get_offset_of__d_4() { return static_cast<int32_t>(offsetof(Guid_t, ____d_4)); }
inline uint8_t get__d_4() const { return ____d_4; }
inline uint8_t* get_address_of__d_4() { return &____d_4; }
inline void set__d_4(uint8_t value)
{
____d_4 = value;
}
inline static int32_t get_offset_of__e_5() { return static_cast<int32_t>(offsetof(Guid_t, ____e_5)); }
inline uint8_t get__e_5() const { return ____e_5; }
inline uint8_t* get_address_of__e_5() { return &____e_5; }
inline void set__e_5(uint8_t value)
{
____e_5 = value;
}
inline static int32_t get_offset_of__f_6() { return static_cast<int32_t>(offsetof(Guid_t, ____f_6)); }
inline uint8_t get__f_6() const { return ____f_6; }
inline uint8_t* get_address_of__f_6() { return &____f_6; }
inline void set__f_6(uint8_t value)
{
____f_6 = value;
}
inline static int32_t get_offset_of__g_7() { return static_cast<int32_t>(offsetof(Guid_t, ____g_7)); }
inline uint8_t get__g_7() const { return ____g_7; }
inline uint8_t* get_address_of__g_7() { return &____g_7; }
inline void set__g_7(uint8_t value)
{
____g_7 = value;
}
inline static int32_t get_offset_of__h_8() { return static_cast<int32_t>(offsetof(Guid_t, ____h_8)); }
inline uint8_t get__h_8() const { return ____h_8; }
inline uint8_t* get_address_of__h_8() { return &____h_8; }
inline void set__h_8(uint8_t value)
{
____h_8 = value;
}
inline static int32_t get_offset_of__i_9() { return static_cast<int32_t>(offsetof(Guid_t, ____i_9)); }
inline uint8_t get__i_9() const { return ____i_9; }
inline uint8_t* get_address_of__i_9() { return &____i_9; }
inline void set__i_9(uint8_t value)
{
____i_9 = value;
}
inline static int32_t get_offset_of__j_10() { return static_cast<int32_t>(offsetof(Guid_t, ____j_10)); }
inline uint8_t get__j_10() const { return ____j_10; }
inline uint8_t* get_address_of__j_10() { return &____j_10; }
inline void set__j_10(uint8_t value)
{
____j_10 = value;
}
inline static int32_t get_offset_of__k_11() { return static_cast<int32_t>(offsetof(Guid_t, ____k_11)); }
inline uint8_t get__k_11() const { return ____k_11; }
inline uint8_t* get_address_of__k_11() { return &____k_11; }
inline void set__k_11(uint8_t value)
{
____k_11 = value;
}
};
struct Guid_t_StaticFields
{
public:
// System.Guid System.Guid::Empty
Guid_t ___Empty_0;
// System.Object System.Guid::_rngAccess
RuntimeObject * ____rngAccess_12;
// System.Security.Cryptography.RandomNumberGenerator System.Guid::_rng
RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * ____rng_13;
// System.Security.Cryptography.RandomNumberGenerator System.Guid::_fastRng
RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * ____fastRng_14;
public:
inline static int32_t get_offset_of_Empty_0() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ___Empty_0)); }
inline Guid_t get_Empty_0() const { return ___Empty_0; }
inline Guid_t * get_address_of_Empty_0() { return &___Empty_0; }
inline void set_Empty_0(Guid_t value)
{
___Empty_0 = value;
}
inline static int32_t get_offset_of__rngAccess_12() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____rngAccess_12)); }
inline RuntimeObject * get__rngAccess_12() const { return ____rngAccess_12; }
inline RuntimeObject ** get_address_of__rngAccess_12() { return &____rngAccess_12; }
inline void set__rngAccess_12(RuntimeObject * value)
{
____rngAccess_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rngAccess_12), (void*)value);
}
inline static int32_t get_offset_of__rng_13() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____rng_13)); }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * get__rng_13() const { return ____rng_13; }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 ** get_address_of__rng_13() { return &____rng_13; }
inline void set__rng_13(RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * value)
{
____rng_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rng_13), (void*)value);
}
inline static int32_t get_offset_of__fastRng_14() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____fastRng_14)); }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * get__fastRng_14() const { return ____fastRng_14; }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 ** get_address_of__fastRng_14() { return &____fastRng_14; }
inline void set__fastRng_14(RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * value)
{
____fastRng_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&____fastRng_14), (void*)value);
}
};
// UnityEngine.XR.InputDevice
struct InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E
{
public:
// System.UInt64 UnityEngine.XR.InputDevice::m_DeviceId
uint64_t ___m_DeviceId_0;
// System.Boolean UnityEngine.XR.InputDevice::m_Initialized
bool ___m_Initialized_1;
public:
inline static int32_t get_offset_of_m_DeviceId_0() { return static_cast<int32_t>(offsetof(InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E, ___m_DeviceId_0)); }
inline uint64_t get_m_DeviceId_0() const { return ___m_DeviceId_0; }
inline uint64_t* get_address_of_m_DeviceId_0() { return &___m_DeviceId_0; }
inline void set_m_DeviceId_0(uint64_t value)
{
___m_DeviceId_0 = value;
}
inline static int32_t get_offset_of_m_Initialized_1() { return static_cast<int32_t>(offsetof(InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E, ___m_Initialized_1)); }
inline bool get_m_Initialized_1() const { return ___m_Initialized_1; }
inline bool* get_address_of_m_Initialized_1() { return &___m_Initialized_1; }
inline void set_m_Initialized_1(bool value)
{
___m_Initialized_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.XR.InputDevice
struct InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E_marshaled_pinvoke
{
uint64_t ___m_DeviceId_0;
int32_t ___m_Initialized_1;
};
// Native definition for COM marshalling of UnityEngine.XR.InputDevice
struct InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E_marshaled_com
{
uint64_t ___m_DeviceId_0;
int32_t ___m_Initialized_1;
};
// System.Int32
struct Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046
{
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_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046, ___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;
}
};
// 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;
}
};
// Windows.Foundation.Point
struct Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578
{
public:
// System.Single Windows.Foundation.Point::_x
float ____x_0;
// System.Single Windows.Foundation.Point::_y
float ____y_1;
public:
inline static int32_t get_offset_of__x_0() { return static_cast<int32_t>(offsetof(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578, ____x_0)); }
inline float get__x_0() const { return ____x_0; }
inline float* get_address_of__x_0() { return &____x_0; }
inline void set__x_0(float value)
{
____x_0 = value;
}
inline static int32_t get_offset_of__y_1() { return static_cast<int32_t>(offsetof(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578, ____y_1)); }
inline float get__y_1() const { return ____y_1; }
inline float* get_address_of__y_1() { return &____y_1; }
inline void set__y_1(float value)
{
____y_1 = value;
}
};
// Windows.Foundation.Point
struct Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB
{
public:
// System.Single Windows.Foundation.Point::X
float ___X_0;
// System.Single Windows.Foundation.Point::Y
float ___Y_1;
public:
inline static int32_t get_offset_of_X_0() { return static_cast<int32_t>(offsetof(Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB, ___X_0)); }
inline float get_X_0() const { return ___X_0; }
inline float* get_address_of_X_0() { return &___X_0; }
inline void set_X_0(float value)
{
___X_0 = value;
}
inline static int32_t get_offset_of_Y_1() { return static_cast<int32_t>(offsetof(Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB, ___Y_1)); }
inline float get_Y_1() const { return ___Y_1; }
inline float* get_address_of_Y_1() { return &___Y_1; }
inline void set_Y_1(float value)
{
___Y_1 = value;
}
};
// System.Numerics.Quaternion
struct Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C
{
public:
// System.Single System.Numerics.Quaternion::X
float ___X_0;
// System.Single System.Numerics.Quaternion::Y
float ___Y_1;
// System.Single System.Numerics.Quaternion::Z
float ___Z_2;
// System.Single System.Numerics.Quaternion::W
float ___W_3;
public:
inline static int32_t get_offset_of_X_0() { return static_cast<int32_t>(offsetof(Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C, ___X_0)); }
inline float get_X_0() const { return ___X_0; }
inline float* get_address_of_X_0() { return &___X_0; }
inline void set_X_0(float value)
{
___X_0 = value;
}
inline static int32_t get_offset_of_Y_1() { return static_cast<int32_t>(offsetof(Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C, ___Y_1)); }
inline float get_Y_1() const { return ___Y_1; }
inline float* get_address_of_Y_1() { return &___Y_1; }
inline void set_Y_1(float value)
{
___Y_1 = value;
}
inline static int32_t get_offset_of_Z_2() { return static_cast<int32_t>(offsetof(Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C, ___Z_2)); }
inline float get_Z_2() const { return ___Z_2; }
inline float* get_address_of_Z_2() { return &___Z_2; }
inline void set_Z_2(float value)
{
___Z_2 = value;
}
inline static int32_t get_offset_of_W_3() { return static_cast<int32_t>(offsetof(Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C, ___W_3)); }
inline float get_W_3() const { return ___W_3; }
inline float* get_address_of_W_3() { return &___W_3; }
inline void set_W_3(float value)
{
___W_3 = value;
}
};
// Windows.Foundation.Numerics.Quaternion
struct Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22
{
public:
// System.Single Windows.Foundation.Numerics.Quaternion::X
float ___X_0;
// System.Single Windows.Foundation.Numerics.Quaternion::Y
float ___Y_1;
// System.Single Windows.Foundation.Numerics.Quaternion::Z
float ___Z_2;
// System.Single Windows.Foundation.Numerics.Quaternion::W
float ___W_3;
public:
inline static int32_t get_offset_of_X_0() { return static_cast<int32_t>(offsetof(Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22, ___X_0)); }
inline float get_X_0() const { return ___X_0; }
inline float* get_address_of_X_0() { return &___X_0; }
inline void set_X_0(float value)
{
___X_0 = value;
}
inline static int32_t get_offset_of_Y_1() { return static_cast<int32_t>(offsetof(Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22, ___Y_1)); }
inline float get_Y_1() const { return ___Y_1; }
inline float* get_address_of_Y_1() { return &___Y_1; }
inline void set_Y_1(float value)
{
___Y_1 = value;
}
inline static int32_t get_offset_of_Z_2() { return static_cast<int32_t>(offsetof(Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22, ___Z_2)); }
inline float get_Z_2() const { return ___Z_2; }
inline float* get_address_of_Z_2() { return &___Z_2; }
inline void set_Z_2(float value)
{
___Z_2 = value;
}
inline static int32_t get_offset_of_W_3() { return static_cast<int32_t>(offsetof(Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22, ___W_3)); }
inline float get_W_3() const { return ___W_3; }
inline float* get_address_of_W_3() { return &___W_3; }
inline void set_W_3(float value)
{
___W_3 = value;
}
};
// Windows.Foundation.Rect
struct Rect_tC45F1DDF39812623644DE296D8057A4958176627
{
public:
// System.Single Windows.Foundation.Rect::_x
float ____x_0;
// System.Single Windows.Foundation.Rect::_y
float ____y_1;
// System.Single Windows.Foundation.Rect::_width
float ____width_2;
// System.Single Windows.Foundation.Rect::_height
float ____height_3;
public:
inline static int32_t get_offset_of__x_0() { return static_cast<int32_t>(offsetof(Rect_tC45F1DDF39812623644DE296D8057A4958176627, ____x_0)); }
inline float get__x_0() const { return ____x_0; }
inline float* get_address_of__x_0() { return &____x_0; }
inline void set__x_0(float value)
{
____x_0 = value;
}
inline static int32_t get_offset_of__y_1() { return static_cast<int32_t>(offsetof(Rect_tC45F1DDF39812623644DE296D8057A4958176627, ____y_1)); }
inline float get__y_1() const { return ____y_1; }
inline float* get_address_of__y_1() { return &____y_1; }
inline void set__y_1(float value)
{
____y_1 = value;
}
inline static int32_t get_offset_of__width_2() { return static_cast<int32_t>(offsetof(Rect_tC45F1DDF39812623644DE296D8057A4958176627, ____width_2)); }
inline float get__width_2() const { return ____width_2; }
inline float* get_address_of__width_2() { return &____width_2; }
inline void set__width_2(float value)
{
____width_2 = value;
}
inline static int32_t get_offset_of__height_3() { return static_cast<int32_t>(offsetof(Rect_tC45F1DDF39812623644DE296D8057A4958176627, ____height_3)); }
inline float get__height_3() const { return ____height_3; }
inline float* get_address_of__height_3() { return &____height_3; }
inline void set__height_3(float value)
{
____height_3 = value;
}
};
// Windows.Foundation.Rect
struct Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891
{
public:
// System.Single Windows.Foundation.Rect::X
float ___X_0;
// System.Single Windows.Foundation.Rect::Y
float ___Y_1;
// System.Single Windows.Foundation.Rect::Width
float ___Width_2;
// System.Single Windows.Foundation.Rect::Height
float ___Height_3;
public:
inline static int32_t get_offset_of_X_0() { return static_cast<int32_t>(offsetof(Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891, ___X_0)); }
inline float get_X_0() const { return ___X_0; }
inline float* get_address_of_X_0() { return &___X_0; }
inline void set_X_0(float value)
{
___X_0 = value;
}
inline static int32_t get_offset_of_Y_1() { return static_cast<int32_t>(offsetof(Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891, ___Y_1)); }
inline float get_Y_1() const { return ___Y_1; }
inline float* get_address_of_Y_1() { return &___Y_1; }
inline void set_Y_1(float value)
{
___Y_1 = value;
}
inline static int32_t get_offset_of_Width_2() { return static_cast<int32_t>(offsetof(Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891, ___Width_2)); }
inline float get_Width_2() const { return ___Width_2; }
inline float* get_address_of_Width_2() { return &___Width_2; }
inline void set_Width_2(float value)
{
___Width_2 = value;
}
inline static int32_t get_offset_of_Height_3() { return static_cast<int32_t>(offsetof(Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891, ___Height_3)); }
inline float get_Height_3() const { return ___Height_3; }
inline float* get_address_of_Height_3() { return &___Height_3; }
inline void set_Height_3(float value)
{
___Height_3 = value;
}
};
// Microsoft.Win32.RegistryKey
struct RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268 : public MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8
{
public:
// System.Object Microsoft.Win32.RegistryKey::handle
RuntimeObject * ___handle_1;
// Microsoft.Win32.SafeHandles.SafeRegistryHandle Microsoft.Win32.RegistryKey::safe_handle
SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545 * ___safe_handle_2;
// System.Object Microsoft.Win32.RegistryKey::hive
RuntimeObject * ___hive_3;
// System.String Microsoft.Win32.RegistryKey::qname
String_t* ___qname_4;
// System.Boolean Microsoft.Win32.RegistryKey::isRemoteRoot
bool ___isRemoteRoot_5;
// System.Boolean Microsoft.Win32.RegistryKey::isWritable
bool ___isWritable_6;
public:
inline static int32_t get_offset_of_handle_1() { return static_cast<int32_t>(offsetof(RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268, ___handle_1)); }
inline RuntimeObject * get_handle_1() const { return ___handle_1; }
inline RuntimeObject ** get_address_of_handle_1() { return &___handle_1; }
inline void set_handle_1(RuntimeObject * value)
{
___handle_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___handle_1), (void*)value);
}
inline static int32_t get_offset_of_safe_handle_2() { return static_cast<int32_t>(offsetof(RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268, ___safe_handle_2)); }
inline SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545 * get_safe_handle_2() const { return ___safe_handle_2; }
inline SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545 ** get_address_of_safe_handle_2() { return &___safe_handle_2; }
inline void set_safe_handle_2(SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545 * value)
{
___safe_handle_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___safe_handle_2), (void*)value);
}
inline static int32_t get_offset_of_hive_3() { return static_cast<int32_t>(offsetof(RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268, ___hive_3)); }
inline RuntimeObject * get_hive_3() const { return ___hive_3; }
inline RuntimeObject ** get_address_of_hive_3() { return &___hive_3; }
inline void set_hive_3(RuntimeObject * value)
{
___hive_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___hive_3), (void*)value);
}
inline static int32_t get_offset_of_qname_4() { return static_cast<int32_t>(offsetof(RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268, ___qname_4)); }
inline String_t* get_qname_4() const { return ___qname_4; }
inline String_t** get_address_of_qname_4() { return &___qname_4; }
inline void set_qname_4(String_t* value)
{
___qname_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___qname_4), (void*)value);
}
inline static int32_t get_offset_of_isRemoteRoot_5() { return static_cast<int32_t>(offsetof(RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268, ___isRemoteRoot_5)); }
inline bool get_isRemoteRoot_5() const { return ___isRemoteRoot_5; }
inline bool* get_address_of_isRemoteRoot_5() { return &___isRemoteRoot_5; }
inline void set_isRemoteRoot_5(bool value)
{
___isRemoteRoot_5 = value;
}
inline static int32_t get_offset_of_isWritable_6() { return static_cast<int32_t>(offsetof(RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268, ___isWritable_6)); }
inline bool get_isWritable_6() const { return ___isWritable_6; }
inline bool* get_address_of_isWritable_6() { return &___isWritable_6; }
inline void set_isWritable_6(bool value)
{
___isWritable_6 = value;
}
};
struct RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268_StaticFields
{
public:
// Microsoft.Win32.IRegistryApi Microsoft.Win32.RegistryKey::RegistryApi
RuntimeObject* ___RegistryApi_7;
public:
inline static int32_t get_offset_of_RegistryApi_7() { return static_cast<int32_t>(offsetof(RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268_StaticFields, ___RegistryApi_7)); }
inline RuntimeObject* get_RegistryApi_7() const { return ___RegistryApi_7; }
inline RuntimeObject** get_address_of_RegistryApi_7() { return &___RegistryApi_7; }
inline void set_RegistryApi_7(RuntimeObject* value)
{
___RegistryApi_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___RegistryApi_7), (void*)value);
}
};
// Mono.RuntimeGPtrArrayHandle
struct RuntimeGPtrArrayHandle_tFFF90E5789EADA37BC5B24EE93680549771445B7
{
public:
// Mono.RuntimeStructs/GPtrArray* Mono.RuntimeGPtrArrayHandle::value
GPtrArray_t481A0359CDF30AF32FB5B6D0DDBA2C26F55E3555 * ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeGPtrArrayHandle_tFFF90E5789EADA37BC5B24EE93680549771445B7, ___value_0)); }
inline GPtrArray_t481A0359CDF30AF32FB5B6D0DDBA2C26F55E3555 * get_value_0() const { return ___value_0; }
inline GPtrArray_t481A0359CDF30AF32FB5B6D0DDBA2C26F55E3555 ** get_address_of_value_0() { return &___value_0; }
inline void set_value_0(GPtrArray_t481A0359CDF30AF32FB5B6D0DDBA2C26F55E3555 * value)
{
___value_0 = value;
}
};
// System.Resources.RuntimeResourceSet
struct RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A : public ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F
{
public:
// System.Collections.Generic.Dictionary`2<System.String,System.Resources.ResourceLocator> System.Resources.RuntimeResourceSet::_resCache
Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * ____resCache_4;
// System.Resources.ResourceReader System.Resources.RuntimeResourceSet::_defaultReader
ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492 * ____defaultReader_5;
// System.Collections.Generic.Dictionary`2<System.String,System.Resources.ResourceLocator> System.Resources.RuntimeResourceSet::_caseInsensitiveTable
Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * ____caseInsensitiveTable_6;
// System.Boolean System.Resources.RuntimeResourceSet::_haveReadFromReader
bool ____haveReadFromReader_7;
public:
inline static int32_t get_offset_of__resCache_4() { return static_cast<int32_t>(offsetof(RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A, ____resCache_4)); }
inline Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * get__resCache_4() const { return ____resCache_4; }
inline Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA ** get_address_of__resCache_4() { return &____resCache_4; }
inline void set__resCache_4(Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * value)
{
____resCache_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____resCache_4), (void*)value);
}
inline static int32_t get_offset_of__defaultReader_5() { return static_cast<int32_t>(offsetof(RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A, ____defaultReader_5)); }
inline ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492 * get__defaultReader_5() const { return ____defaultReader_5; }
inline ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492 ** get_address_of__defaultReader_5() { return &____defaultReader_5; }
inline void set__defaultReader_5(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492 * value)
{
____defaultReader_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____defaultReader_5), (void*)value);
}
inline static int32_t get_offset_of__caseInsensitiveTable_6() { return static_cast<int32_t>(offsetof(RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A, ____caseInsensitiveTable_6)); }
inline Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * get__caseInsensitiveTable_6() const { return ____caseInsensitiveTable_6; }
inline Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA ** get_address_of__caseInsensitiveTable_6() { return &____caseInsensitiveTable_6; }
inline void set__caseInsensitiveTable_6(Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * value)
{
____caseInsensitiveTable_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&____caseInsensitiveTable_6), (void*)value);
}
inline static int32_t get_offset_of__haveReadFromReader_7() { return static_cast<int32_t>(offsetof(RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A, ____haveReadFromReader_7)); }
inline bool get__haveReadFromReader_7() const { return ____haveReadFromReader_7; }
inline bool* get_address_of__haveReadFromReader_7() { return &____haveReadFromReader_7; }
inline void set__haveReadFromReader_7(bool value)
{
____haveReadFromReader_7 = value;
}
};
// System.Security.Cryptography.SHA1
struct SHA1_t15B592B9935E19EC3FD5679B969239AC572E2C0E : public HashAlgorithm_t7F831BEF35F9D0AF5016FFB0E474AF9F93908F31
{
public:
public:
};
// System.Single
struct Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E
{
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_tE07797BA3C98D4CA9B5A19413C19A76688AB899E, ___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;
}
};
// Windows.Foundation.Size
struct Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92
{
public:
// System.Single Windows.Foundation.Size::_width
float ____width_0;
// System.Single Windows.Foundation.Size::_height
float ____height_1;
public:
inline static int32_t get_offset_of__width_0() { return static_cast<int32_t>(offsetof(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92, ____width_0)); }
inline float get__width_0() const { return ____width_0; }
inline float* get_address_of__width_0() { return &____width_0; }
inline void set__width_0(float value)
{
____width_0 = value;
}
inline static int32_t get_offset_of__height_1() { return static_cast<int32_t>(offsetof(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92, ____height_1)); }
inline float get__height_1() const { return ____height_1; }
inline float* get_address_of__height_1() { return &____height_1; }
inline void set__height_1(float value)
{
____height_1 = value;
}
};
// Windows.Foundation.Size
struct Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5
{
public:
// System.Single Windows.Foundation.Size::Width
float ___Width_0;
// System.Single Windows.Foundation.Size::Height
float ___Height_1;
public:
inline static int32_t get_offset_of_Width_0() { return static_cast<int32_t>(offsetof(Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5, ___Width_0)); }
inline float get_Width_0() const { return ___Width_0; }
inline float* get_address_of_Width_0() { return &___Width_0; }
inline void set_Width_0(float value)
{
___Width_0 = value;
}
inline static int32_t get_offset_of_Height_1() { return static_cast<int32_t>(offsetof(Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5, ___Height_1)); }
inline float get_Height_1() const { return ___Height_1; }
inline float* get_address_of_Height_1() { return &___Height_1; }
inline void set_Height_1(float value)
{
___Height_1 = value;
}
};
// System.IO.Stream
struct Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB : public MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8
{
public:
// System.IO.Stream/ReadWriteTask System.IO.Stream::_activeReadWriteTask
ReadWriteTask_t32CD2C230786712954C1DB518DBE420A1F4C7974 * ____activeReadWriteTask_2;
// System.Threading.SemaphoreSlim System.IO.Stream::_asyncActiveSemaphore
SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385 * ____asyncActiveSemaphore_3;
public:
inline static int32_t get_offset_of__activeReadWriteTask_2() { return static_cast<int32_t>(offsetof(Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB, ____activeReadWriteTask_2)); }
inline ReadWriteTask_t32CD2C230786712954C1DB518DBE420A1F4C7974 * get__activeReadWriteTask_2() const { return ____activeReadWriteTask_2; }
inline ReadWriteTask_t32CD2C230786712954C1DB518DBE420A1F4C7974 ** get_address_of__activeReadWriteTask_2() { return &____activeReadWriteTask_2; }
inline void set__activeReadWriteTask_2(ReadWriteTask_t32CD2C230786712954C1DB518DBE420A1F4C7974 * value)
{
____activeReadWriteTask_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____activeReadWriteTask_2), (void*)value);
}
inline static int32_t get_offset_of__asyncActiveSemaphore_3() { return static_cast<int32_t>(offsetof(Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB, ____asyncActiveSemaphore_3)); }
inline SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385 * get__asyncActiveSemaphore_3() const { return ____asyncActiveSemaphore_3; }
inline SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385 ** get_address_of__asyncActiveSemaphore_3() { return &____asyncActiveSemaphore_3; }
inline void set__asyncActiveSemaphore_3(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385 * value)
{
____asyncActiveSemaphore_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&____asyncActiveSemaphore_3), (void*)value);
}
};
struct Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB_StaticFields
{
public:
// System.IO.Stream System.IO.Stream::Null
Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB * ___Null_1;
public:
inline static int32_t get_offset_of_Null_1() { return static_cast<int32_t>(offsetof(Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB_StaticFields, ___Null_1)); }
inline Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB * get_Null_1() const { return ___Null_1; }
inline Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB ** get_address_of_Null_1() { return &___Null_1; }
inline void set_Null_1(Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB * value)
{
___Null_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Null_1), (void*)value);
}
};
// System.IO.TextReader
struct TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F : public MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8
{
public:
public:
};
struct TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F_StaticFields
{
public:
// System.Func`2<System.Object,System.String> System.IO.TextReader::_ReadLineDelegate
Func_2_t060A650AB95DEF14D4F579FA5999ACEFEEE0FD82 * ____ReadLineDelegate_1;
// System.Func`2<System.Object,System.Int32> System.IO.TextReader::_ReadDelegate
Func_2_t0CEE9D1C856153BA9C23BB9D7E929D577AF37A2C * ____ReadDelegate_2;
// System.IO.TextReader System.IO.TextReader::Null
TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F * ___Null_3;
public:
inline static int32_t get_offset_of__ReadLineDelegate_1() { return static_cast<int32_t>(offsetof(TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F_StaticFields, ____ReadLineDelegate_1)); }
inline Func_2_t060A650AB95DEF14D4F579FA5999ACEFEEE0FD82 * get__ReadLineDelegate_1() const { return ____ReadLineDelegate_1; }
inline Func_2_t060A650AB95DEF14D4F579FA5999ACEFEEE0FD82 ** get_address_of__ReadLineDelegate_1() { return &____ReadLineDelegate_1; }
inline void set__ReadLineDelegate_1(Func_2_t060A650AB95DEF14D4F579FA5999ACEFEEE0FD82 * value)
{
____ReadLineDelegate_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____ReadLineDelegate_1), (void*)value);
}
inline static int32_t get_offset_of__ReadDelegate_2() { return static_cast<int32_t>(offsetof(TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F_StaticFields, ____ReadDelegate_2)); }
inline Func_2_t0CEE9D1C856153BA9C23BB9D7E929D577AF37A2C * get__ReadDelegate_2() const { return ____ReadDelegate_2; }
inline Func_2_t0CEE9D1C856153BA9C23BB9D7E929D577AF37A2C ** get_address_of__ReadDelegate_2() { return &____ReadDelegate_2; }
inline void set__ReadDelegate_2(Func_2_t0CEE9D1C856153BA9C23BB9D7E929D577AF37A2C * value)
{
____ReadDelegate_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____ReadDelegate_2), (void*)value);
}
inline static int32_t get_offset_of_Null_3() { return static_cast<int32_t>(offsetof(TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F_StaticFields, ___Null_3)); }
inline TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F * get_Null_3() const { return ___Null_3; }
inline TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F ** get_address_of_Null_3() { return &___Null_3; }
inline void set_Null_3(TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F * value)
{
___Null_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Null_3), (void*)value);
}
};
// UnityEngine.Vector3
struct Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E
{
public:
// System.Single UnityEngine.Vector3::x
float ___x_2;
// System.Single UnityEngine.Vector3::y
float ___y_3;
// System.Single UnityEngine.Vector3::z
float ___z_4;
public:
inline static int32_t get_offset_of_x_2() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E, ___x_2)); }
inline float get_x_2() const { return ___x_2; }
inline float* get_address_of_x_2() { return &___x_2; }
inline void set_x_2(float value)
{
___x_2 = value;
}
inline static int32_t get_offset_of_y_3() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E, ___y_3)); }
inline float get_y_3() const { return ___y_3; }
inline float* get_address_of_y_3() { return &___y_3; }
inline void set_y_3(float value)
{
___y_3 = value;
}
inline static int32_t get_offset_of_z_4() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E, ___z_4)); }
inline float get_z_4() const { return ___z_4; }
inline float* get_address_of_z_4() { return &___z_4; }
inline void set_z_4(float value)
{
___z_4 = value;
}
};
struct Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields
{
public:
// UnityEngine.Vector3 UnityEngine.Vector3::zeroVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___zeroVector_5;
// UnityEngine.Vector3 UnityEngine.Vector3::oneVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___oneVector_6;
// UnityEngine.Vector3 UnityEngine.Vector3::upVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___upVector_7;
// UnityEngine.Vector3 UnityEngine.Vector3::downVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___downVector_8;
// UnityEngine.Vector3 UnityEngine.Vector3::leftVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___leftVector_9;
// UnityEngine.Vector3 UnityEngine.Vector3::rightVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___rightVector_10;
// UnityEngine.Vector3 UnityEngine.Vector3::forwardVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___forwardVector_11;
// UnityEngine.Vector3 UnityEngine.Vector3::backVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___backVector_12;
// UnityEngine.Vector3 UnityEngine.Vector3::positiveInfinityVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___positiveInfinityVector_13;
// UnityEngine.Vector3 UnityEngine.Vector3::negativeInfinityVector
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___negativeInfinityVector_14;
public:
inline static int32_t get_offset_of_zeroVector_5() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___zeroVector_5)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_zeroVector_5() const { return ___zeroVector_5; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_zeroVector_5() { return &___zeroVector_5; }
inline void set_zeroVector_5(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___zeroVector_5 = value;
}
inline static int32_t get_offset_of_oneVector_6() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___oneVector_6)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_oneVector_6() const { return ___oneVector_6; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_oneVector_6() { return &___oneVector_6; }
inline void set_oneVector_6(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___oneVector_6 = value;
}
inline static int32_t get_offset_of_upVector_7() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___upVector_7)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_upVector_7() const { return ___upVector_7; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_upVector_7() { return &___upVector_7; }
inline void set_upVector_7(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___upVector_7 = value;
}
inline static int32_t get_offset_of_downVector_8() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___downVector_8)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_downVector_8() const { return ___downVector_8; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_downVector_8() { return &___downVector_8; }
inline void set_downVector_8(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___downVector_8 = value;
}
inline static int32_t get_offset_of_leftVector_9() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___leftVector_9)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_leftVector_9() const { return ___leftVector_9; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_leftVector_9() { return &___leftVector_9; }
inline void set_leftVector_9(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___leftVector_9 = value;
}
inline static int32_t get_offset_of_rightVector_10() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___rightVector_10)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_rightVector_10() const { return ___rightVector_10; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_rightVector_10() { return &___rightVector_10; }
inline void set_rightVector_10(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___rightVector_10 = value;
}
inline static int32_t get_offset_of_forwardVector_11() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___forwardVector_11)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_forwardVector_11() const { return ___forwardVector_11; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_forwardVector_11() { return &___forwardVector_11; }
inline void set_forwardVector_11(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___forwardVector_11 = value;
}
inline static int32_t get_offset_of_backVector_12() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___backVector_12)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_backVector_12() const { return ___backVector_12; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_backVector_12() { return &___backVector_12; }
inline void set_backVector_12(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___backVector_12 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_13() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___positiveInfinityVector_13)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_positiveInfinityVector_13() const { return ___positiveInfinityVector_13; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_positiveInfinityVector_13() { return &___positiveInfinityVector_13; }
inline void set_positiveInfinityVector_13(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___positiveInfinityVector_13 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_14() { return static_cast<int32_t>(offsetof(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E_StaticFields, ___negativeInfinityVector_14)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_negativeInfinityVector_14() const { return ___negativeInfinityVector_14; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_negativeInfinityVector_14() { return &___negativeInfinityVector_14; }
inline void set_negativeInfinityVector_14(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___negativeInfinityVector_14 = value;
}
};
// Windows.Foundation.IReference`1<Windows.Foundation.Point>
struct NOVTABLE IReference_1_t7F259CA808F8CA00C0A7F31D57D93E94ABE7FD38 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m6BBE84644D81C739672BB5FE7BD65AD8AD6C044B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) = 0;
};
// Windows.Foundation.IReference`1<Windows.Foundation.Point>
struct NOVTABLE IReference_1_t22FB8AE92DF2358ED21FB1C7C5B2FFCAEB97C590 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m0FC3B384D7E37F93935DFB33EA2D44E3FC3E8F49(Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB * comReturnValue) = 0;
};
// Windows.Foundation.IReference`1<System.Numerics.Quaternion>
struct NOVTABLE IReference_1_t33EFD59F5EFEE8E48055FF4CB9A75732C6EA2E31 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_mC9B0A6358249758D52E8655254FFC53AB4E48D2F(Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C * comReturnValue) = 0;
};
// Windows.Foundation.IReference`1<Windows.Foundation.Numerics.Quaternion>
struct NOVTABLE IReference_1_t3A0E57B1670337C77F71EEB98E7BC1AFBB35812A : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m223D1D22BBB08115FECD12012F70419914365276(Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22 * comReturnValue) = 0;
};
// Windows.Foundation.IReference`1<Windows.Foundation.Rect>
struct NOVTABLE IReference_1_tBCFA9924A47B56774AFEF690310BA37E1A800808 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m64387D2D55E86DABEC832FDADDA12CBF1C7C1D5E(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) = 0;
};
// Windows.Foundation.IReference`1<Windows.Foundation.Rect>
struct NOVTABLE IReference_1_t6C2C9667B4A9B53CCB0776745CBB938B87C32F2E : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m96AACCD499BB14F3DBACD6CA120C283ABCE73263(Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891 * comReturnValue) = 0;
};
// Windows.Foundation.IReference`1<Windows.Foundation.Size>
struct NOVTABLE IReference_1_t6AF48AEDBAB54EEF81D7BE93983928A632CEA6B7 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m4E45D3537EF0FB1FFE8AF3B2DCB63DB98A3A45AA(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) = 0;
};
// Windows.Foundation.IReference`1<Windows.Foundation.Size>
struct NOVTABLE IReference_1_tF1450FE2A758CB62295758B955692AA1A5A3CCA9 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m3496400E5AB203A0F7596D49F46B68601F66DD77(Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5 * comReturnValue) = 0;
};
// Microsoft.MixedReality.Toolkit.BaseService
struct BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16 : public RuntimeObject
{
public:
// System.String Microsoft.MixedReality.Toolkit.BaseService::<Name>k__BackingField
String_t* ___U3CNameU3Ek__BackingField_1;
// System.UInt32 Microsoft.MixedReality.Toolkit.BaseService::<Priority>k__BackingField
uint32_t ___U3CPriorityU3Ek__BackingField_2;
// Microsoft.MixedReality.Toolkit.BaseMixedRealityProfile Microsoft.MixedReality.Toolkit.BaseService::<ConfigurationProfile>k__BackingField
BaseMixedRealityProfile_tC5DBD7146B1E1D467DE81BA1EAB45133408A59E1 * ___U3CConfigurationProfileU3Ek__BackingField_3;
// System.Nullable`1<System.Boolean> Microsoft.MixedReality.Toolkit.BaseService::isInitialized
Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 ___isInitialized_4;
// System.Nullable`1<System.Boolean> Microsoft.MixedReality.Toolkit.BaseService::isEnabled
Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 ___isEnabled_5;
// System.Nullable`1<System.Boolean> Microsoft.MixedReality.Toolkit.BaseService::isMarkedDestroyed
Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 ___isMarkedDestroyed_6;
// System.Boolean Microsoft.MixedReality.Toolkit.BaseService::disposed
bool ___disposed_7;
public:
inline static int32_t get_offset_of_U3CNameU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16, ___U3CNameU3Ek__BackingField_1)); }
inline String_t* get_U3CNameU3Ek__BackingField_1() const { return ___U3CNameU3Ek__BackingField_1; }
inline String_t** get_address_of_U3CNameU3Ek__BackingField_1() { return &___U3CNameU3Ek__BackingField_1; }
inline void set_U3CNameU3Ek__BackingField_1(String_t* value)
{
___U3CNameU3Ek__BackingField_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CNameU3Ek__BackingField_1), (void*)value);
}
inline static int32_t get_offset_of_U3CPriorityU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16, ___U3CPriorityU3Ek__BackingField_2)); }
inline uint32_t get_U3CPriorityU3Ek__BackingField_2() const { return ___U3CPriorityU3Ek__BackingField_2; }
inline uint32_t* get_address_of_U3CPriorityU3Ek__BackingField_2() { return &___U3CPriorityU3Ek__BackingField_2; }
inline void set_U3CPriorityU3Ek__BackingField_2(uint32_t value)
{
___U3CPriorityU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CConfigurationProfileU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16, ___U3CConfigurationProfileU3Ek__BackingField_3)); }
inline BaseMixedRealityProfile_tC5DBD7146B1E1D467DE81BA1EAB45133408A59E1 * get_U3CConfigurationProfileU3Ek__BackingField_3() const { return ___U3CConfigurationProfileU3Ek__BackingField_3; }
inline BaseMixedRealityProfile_tC5DBD7146B1E1D467DE81BA1EAB45133408A59E1 ** get_address_of_U3CConfigurationProfileU3Ek__BackingField_3() { return &___U3CConfigurationProfileU3Ek__BackingField_3; }
inline void set_U3CConfigurationProfileU3Ek__BackingField_3(BaseMixedRealityProfile_tC5DBD7146B1E1D467DE81BA1EAB45133408A59E1 * value)
{
___U3CConfigurationProfileU3Ek__BackingField_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CConfigurationProfileU3Ek__BackingField_3), (void*)value);
}
inline static int32_t get_offset_of_isInitialized_4() { return static_cast<int32_t>(offsetof(BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16, ___isInitialized_4)); }
inline Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 get_isInitialized_4() const { return ___isInitialized_4; }
inline Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 * get_address_of_isInitialized_4() { return &___isInitialized_4; }
inline void set_isInitialized_4(Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 value)
{
___isInitialized_4 = value;
}
inline static int32_t get_offset_of_isEnabled_5() { return static_cast<int32_t>(offsetof(BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16, ___isEnabled_5)); }
inline Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 get_isEnabled_5() const { return ___isEnabled_5; }
inline Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 * get_address_of_isEnabled_5() { return &___isEnabled_5; }
inline void set_isEnabled_5(Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 value)
{
___isEnabled_5 = value;
}
inline static int32_t get_offset_of_isMarkedDestroyed_6() { return static_cast<int32_t>(offsetof(BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16, ___isMarkedDestroyed_6)); }
inline Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 get_isMarkedDestroyed_6() const { return ___isMarkedDestroyed_6; }
inline Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 * get_address_of_isMarkedDestroyed_6() { return &___isMarkedDestroyed_6; }
inline void set_isMarkedDestroyed_6(Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 value)
{
___isMarkedDestroyed_6 = value;
}
inline static int32_t get_offset_of_disposed_7() { return static_cast<int32_t>(offsetof(BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16, ___disposed_7)); }
inline bool get_disposed_7() const { return ___disposed_7; }
inline bool* get_address_of_disposed_7() { return &___disposed_7; }
inline void set_disposed_7(bool value)
{
___disposed_7 = value;
}
};
// UnityEngine.Windows.WebCam.CapturePixelFormat
struct CapturePixelFormat_t862C8DB99BB8A10907BDC63453CD3DAD3E422A61
{
public:
// System.Int32 UnityEngine.Windows.WebCam.CapturePixelFormat::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(CapturePixelFormat_t862C8DB99BB8A10907BDC63453CD3DAD3E422A61, ___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;
}
};
// System.IO.FileAccess
struct FileAccess_t09E176678AB8520C44024354E0DB2F01D40A2F5B
{
public:
// System.Int32 System.IO.FileAccess::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(FileAccess_t09E176678AB8520C44024354E0DB2F01D40A2F5B, ___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;
}
};
// UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Object::m_CachedPtr
intptr_t ___m_CachedPtr_0;
public:
inline static int32_t get_offset_of_m_CachedPtr_0() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A, ___m_CachedPtr_0)); }
inline intptr_t get_m_CachedPtr_0() const { return ___m_CachedPtr_0; }
inline intptr_t* get_address_of_m_CachedPtr_0() { return &___m_CachedPtr_0; }
inline void set_m_CachedPtr_0(intptr_t value)
{
___m_CachedPtr_0 = value;
}
};
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields
{
public:
// System.Int32 UnityEngine.Object::OffsetOfInstanceIDInCPlusPlusObject
int32_t ___OffsetOfInstanceIDInCPlusPlusObject_1;
public:
inline static int32_t get_offset_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields, ___OffsetOfInstanceIDInCPlusPlusObject_1)); }
inline int32_t get_OffsetOfInstanceIDInCPlusPlusObject_1() const { return ___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline int32_t* get_address_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return &___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline void set_OffsetOfInstanceIDInCPlusPlusObject_1(int32_t value)
{
___OffsetOfInstanceIDInCPlusPlusObject_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_pinvoke
{
intptr_t ___m_CachedPtr_0;
};
// Native definition for COM marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_com
{
intptr_t ___m_CachedPtr_0;
};
// UnityEngine.Windows.WebCam.PhotoCapture
struct PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74 : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Windows.WebCam.PhotoCapture::m_NativePtr
intptr_t ___m_NativePtr_0;
public:
inline static int32_t get_offset_of_m_NativePtr_0() { return static_cast<int32_t>(offsetof(PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74, ___m_NativePtr_0)); }
inline intptr_t get_m_NativePtr_0() const { return ___m_NativePtr_0; }
inline intptr_t* get_address_of_m_NativePtr_0() { return &___m_NativePtr_0; }
inline void set_m_NativePtr_0(intptr_t value)
{
___m_NativePtr_0 = value;
}
};
struct PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_StaticFields
{
public:
// System.Int64 UnityEngine.Windows.WebCam.PhotoCapture::HR_SUCCESS
int64_t ___HR_SUCCESS_1;
public:
inline static int32_t get_offset_of_HR_SUCCESS_1() { return static_cast<int32_t>(offsetof(PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_StaticFields, ___HR_SUCCESS_1)); }
inline int64_t get_HR_SUCCESS_1() const { return ___HR_SUCCESS_1; }
inline int64_t* get_address_of_HR_SUCCESS_1() { return &___HR_SUCCESS_1; }
inline void set_HR_SUCCESS_1(int64_t value)
{
___HR_SUCCESS_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Windows.WebCam.PhotoCapture
struct PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_marshaled_pinvoke
{
intptr_t ___m_NativePtr_0;
};
// Native definition for COM marshalling of UnityEngine.Windows.WebCam.PhotoCapture
struct PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_marshaled_com
{
intptr_t ___m_NativePtr_0;
};
// Unity.Profiling.ProfilerMarker
struct ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1
{
public:
// System.IntPtr Unity.Profiling.ProfilerMarker::m_Ptr
intptr_t ___m_Ptr_0;
public:
inline static int32_t get_offset_of_m_Ptr_0() { return static_cast<int32_t>(offsetof(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1, ___m_Ptr_0)); }
inline intptr_t get_m_Ptr_0() const { return ___m_Ptr_0; }
inline intptr_t* get_address_of_m_Ptr_0() { return &___m_Ptr_0; }
inline void set_m_Ptr_0(intptr_t value)
{
___m_Ptr_0 = value;
}
};
// Windows.Foundation.PropertyType
struct PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808
{
public:
// System.Int32 Windows.Foundation.PropertyType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808, ___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;
}
};
// System.Security.Cryptography.RNGCryptoServiceProvider
struct RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1 : public RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50
{
public:
// System.IntPtr System.Security.Cryptography.RNGCryptoServiceProvider::_handle
intptr_t ____handle_1;
public:
inline static int32_t get_offset_of__handle_1() { return static_cast<int32_t>(offsetof(RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1, ____handle_1)); }
inline intptr_t get__handle_1() const { return ____handle_1; }
inline intptr_t* get_address_of__handle_1() { return &____handle_1; }
inline void set__handle_1(intptr_t value)
{
____handle_1 = value;
}
};
struct RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1_StaticFields
{
public:
// System.Object System.Security.Cryptography.RNGCryptoServiceProvider::_lock
RuntimeObject * ____lock_0;
public:
inline static int32_t get_offset_of__lock_0() { return static_cast<int32_t>(offsetof(RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1_StaticFields, ____lock_0)); }
inline RuntimeObject * get__lock_0() const { return ____lock_0; }
inline RuntimeObject ** get_address_of__lock_0() { return &____lock_0; }
inline void set__lock_0(RuntimeObject * value)
{
____lock_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____lock_0), (void*)value);
}
};
// UnityEngine.Ray
struct Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6
{
public:
// UnityEngine.Vector3 UnityEngine.Ray::m_Origin
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Origin_0;
// UnityEngine.Vector3 UnityEngine.Ray::m_Direction
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___m_Direction_1;
public:
inline static int32_t get_offset_of_m_Origin_0() { return static_cast<int32_t>(offsetof(Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6, ___m_Origin_0)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Origin_0() const { return ___m_Origin_0; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Origin_0() { return &___m_Origin_0; }
inline void set_m_Origin_0(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Origin_0 = value;
}
inline static int32_t get_offset_of_m_Direction_1() { return static_cast<int32_t>(offsetof(Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6, ___m_Direction_1)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_m_Direction_1() const { return ___m_Direction_1; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_m_Direction_1() { return &___m_Direction_1; }
inline void set_m_Direction_1(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___m_Direction_1 = value;
}
};
// System.Security.Cryptography.SHA1CryptoServiceProvider
struct SHA1CryptoServiceProvider_tFCC9EF75A0DCF3E1A50E64B525EA9599E5927EF7 : public SHA1_t15B592B9935E19EC3FD5679B969239AC572E2C0E
{
public:
// System.Security.Cryptography.SHA1Internal System.Security.Cryptography.SHA1CryptoServiceProvider::sha
SHA1Internal_t5D0A95A55E32BCC8976D5B91649E6C13C8334CD6 * ___sha_4;
public:
inline static int32_t get_offset_of_sha_4() { return static_cast<int32_t>(offsetof(SHA1CryptoServiceProvider_tFCC9EF75A0DCF3E1A50E64B525EA9599E5927EF7, ___sha_4)); }
inline SHA1Internal_t5D0A95A55E32BCC8976D5B91649E6C13C8334CD6 * get_sha_4() const { return ___sha_4; }
inline SHA1Internal_t5D0A95A55E32BCC8976D5B91649E6C13C8334CD6 ** get_address_of_sha_4() { return &___sha_4; }
inline void set_sha_4(SHA1Internal_t5D0A95A55E32BCC8976D5B91649E6C13C8334CD6 * value)
{
___sha_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___sha_4), (void*)value);
}
};
// Mono.SafeGPtrArrayHandle
struct SafeGPtrArrayHandle_tAEC97FDEAA1FFF2E1C1475EECB98B945EF86141A
{
public:
// Mono.RuntimeGPtrArrayHandle Mono.SafeGPtrArrayHandle::handle
RuntimeGPtrArrayHandle_tFFF90E5789EADA37BC5B24EE93680549771445B7 ___handle_0;
public:
inline static int32_t get_offset_of_handle_0() { return static_cast<int32_t>(offsetof(SafeGPtrArrayHandle_tAEC97FDEAA1FFF2E1C1475EECB98B945EF86141A, ___handle_0)); }
inline RuntimeGPtrArrayHandle_tFFF90E5789EADA37BC5B24EE93680549771445B7 get_handle_0() const { return ___handle_0; }
inline RuntimeGPtrArrayHandle_tFFF90E5789EADA37BC5B24EE93680549771445B7 * get_address_of_handle_0() { return &___handle_0; }
inline void set_handle_0(RuntimeGPtrArrayHandle_tFFF90E5789EADA37BC5B24EE93680549771445B7 value)
{
___handle_0 = value;
}
};
// System.Runtime.InteropServices.SafeHandle
struct SafeHandle_tC07DCA2CABF6988953342757EFB1547363E5A36B : public CriticalFinalizerObject_tA3367C832FFE7434EB3C15C7136AF25524150997
{
public:
// System.IntPtr System.Runtime.InteropServices.SafeHandle::handle
intptr_t ___handle_0;
// System.Int32 System.Runtime.InteropServices.SafeHandle::_state
int32_t ____state_1;
// System.Boolean System.Runtime.InteropServices.SafeHandle::_ownsHandle
bool ____ownsHandle_2;
// System.Boolean System.Runtime.InteropServices.SafeHandle::_fullyInitialized
bool ____fullyInitialized_3;
public:
inline static int32_t get_offset_of_handle_0() { return static_cast<int32_t>(offsetof(SafeHandle_tC07DCA2CABF6988953342757EFB1547363E5A36B, ___handle_0)); }
inline intptr_t get_handle_0() const { return ___handle_0; }
inline intptr_t* get_address_of_handle_0() { return &___handle_0; }
inline void set_handle_0(intptr_t value)
{
___handle_0 = value;
}
inline static int32_t get_offset_of__state_1() { return static_cast<int32_t>(offsetof(SafeHandle_tC07DCA2CABF6988953342757EFB1547363E5A36B, ____state_1)); }
inline int32_t get__state_1() const { return ____state_1; }
inline int32_t* get_address_of__state_1() { return &____state_1; }
inline void set__state_1(int32_t value)
{
____state_1 = value;
}
inline static int32_t get_offset_of__ownsHandle_2() { return static_cast<int32_t>(offsetof(SafeHandle_tC07DCA2CABF6988953342757EFB1547363E5A36B, ____ownsHandle_2)); }
inline bool get__ownsHandle_2() const { return ____ownsHandle_2; }
inline bool* get_address_of__ownsHandle_2() { return &____ownsHandle_2; }
inline void set__ownsHandle_2(bool value)
{
____ownsHandle_2 = value;
}
inline static int32_t get_offset_of__fullyInitialized_3() { return static_cast<int32_t>(offsetof(SafeHandle_tC07DCA2CABF6988953342757EFB1547363E5A36B, ____fullyInitialized_3)); }
inline bool get__fullyInitialized_3() const { return ____fullyInitialized_3; }
inline bool* get_address_of__fullyInitialized_3() { return &____fullyInitialized_3; }
inline void set__fullyInitialized_3(bool value)
{
____fullyInitialized_3 = value;
}
};
// Mono.SafeStringMarshal
struct SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E
{
public:
// System.String Mono.SafeStringMarshal::str
String_t* ___str_0;
// System.IntPtr Mono.SafeStringMarshal::marshaled_string
intptr_t ___marshaled_string_1;
public:
inline static int32_t get_offset_of_str_0() { return static_cast<int32_t>(offsetof(SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E, ___str_0)); }
inline String_t* get_str_0() const { return ___str_0; }
inline String_t** get_address_of_str_0() { return &___str_0; }
inline void set_str_0(String_t* value)
{
___str_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___str_0), (void*)value);
}
inline static int32_t get_offset_of_marshaled_string_1() { return static_cast<int32_t>(offsetof(SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E, ___marshaled_string_1)); }
inline intptr_t get_marshaled_string_1() const { return ___marshaled_string_1; }
inline intptr_t* get_address_of_marshaled_string_1() { return &___marshaled_string_1; }
inline void set_marshaled_string_1(intptr_t value)
{
___marshaled_string_1 = value;
}
};
// Native definition for P/Invoke marshalling of Mono.SafeStringMarshal
struct SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E_marshaled_pinvoke
{
char* ___str_0;
intptr_t ___marshaled_string_1;
};
// Native definition for COM marshalling of Mono.SafeStringMarshal
struct SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E_marshaled_com
{
Il2CppChar* ___str_0;
intptr_t ___marshaled_string_1;
};
// System.Threading.SemaphoreSlim
struct SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385 : public RuntimeObject
{
public:
// System.Int32 modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.SemaphoreSlim::m_currentCount
int32_t ___m_currentCount_0;
// System.Int32 System.Threading.SemaphoreSlim::m_maxCount
int32_t ___m_maxCount_1;
// System.Int32 modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.SemaphoreSlim::m_waitCount
int32_t ___m_waitCount_2;
// System.Object System.Threading.SemaphoreSlim::m_lockObj
RuntimeObject * ___m_lockObj_3;
// System.Threading.ManualResetEvent modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.SemaphoreSlim::m_waitHandle
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___m_waitHandle_4;
// System.Threading.SemaphoreSlim/TaskNode System.Threading.SemaphoreSlim::m_asyncHead
TaskNode_tD3014A57510D018F890E6524AC62F9417E2E6C4E * ___m_asyncHead_5;
// System.Threading.SemaphoreSlim/TaskNode System.Threading.SemaphoreSlim::m_asyncTail
TaskNode_tD3014A57510D018F890E6524AC62F9417E2E6C4E * ___m_asyncTail_6;
public:
inline static int32_t get_offset_of_m_currentCount_0() { return static_cast<int32_t>(offsetof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385, ___m_currentCount_0)); }
inline int32_t get_m_currentCount_0() const { return ___m_currentCount_0; }
inline int32_t* get_address_of_m_currentCount_0() { return &___m_currentCount_0; }
inline void set_m_currentCount_0(int32_t value)
{
___m_currentCount_0 = value;
}
inline static int32_t get_offset_of_m_maxCount_1() { return static_cast<int32_t>(offsetof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385, ___m_maxCount_1)); }
inline int32_t get_m_maxCount_1() const { return ___m_maxCount_1; }
inline int32_t* get_address_of_m_maxCount_1() { return &___m_maxCount_1; }
inline void set_m_maxCount_1(int32_t value)
{
___m_maxCount_1 = value;
}
inline static int32_t get_offset_of_m_waitCount_2() { return static_cast<int32_t>(offsetof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385, ___m_waitCount_2)); }
inline int32_t get_m_waitCount_2() const { return ___m_waitCount_2; }
inline int32_t* get_address_of_m_waitCount_2() { return &___m_waitCount_2; }
inline void set_m_waitCount_2(int32_t value)
{
___m_waitCount_2 = value;
}
inline static int32_t get_offset_of_m_lockObj_3() { return static_cast<int32_t>(offsetof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385, ___m_lockObj_3)); }
inline RuntimeObject * get_m_lockObj_3() const { return ___m_lockObj_3; }
inline RuntimeObject ** get_address_of_m_lockObj_3() { return &___m_lockObj_3; }
inline void set_m_lockObj_3(RuntimeObject * value)
{
___m_lockObj_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_lockObj_3), (void*)value);
}
inline static int32_t get_offset_of_m_waitHandle_4() { return static_cast<int32_t>(offsetof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385, ___m_waitHandle_4)); }
inline ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * get_m_waitHandle_4() const { return ___m_waitHandle_4; }
inline ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA ** get_address_of_m_waitHandle_4() { return &___m_waitHandle_4; }
inline void set_m_waitHandle_4(ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * value)
{
___m_waitHandle_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_waitHandle_4), (void*)value);
}
inline static int32_t get_offset_of_m_asyncHead_5() { return static_cast<int32_t>(offsetof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385, ___m_asyncHead_5)); }
inline TaskNode_tD3014A57510D018F890E6524AC62F9417E2E6C4E * get_m_asyncHead_5() const { return ___m_asyncHead_5; }
inline TaskNode_tD3014A57510D018F890E6524AC62F9417E2E6C4E ** get_address_of_m_asyncHead_5() { return &___m_asyncHead_5; }
inline void set_m_asyncHead_5(TaskNode_tD3014A57510D018F890E6524AC62F9417E2E6C4E * value)
{
___m_asyncHead_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_asyncHead_5), (void*)value);
}
inline static int32_t get_offset_of_m_asyncTail_6() { return static_cast<int32_t>(offsetof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385, ___m_asyncTail_6)); }
inline TaskNode_tD3014A57510D018F890E6524AC62F9417E2E6C4E * get_m_asyncTail_6() const { return ___m_asyncTail_6; }
inline TaskNode_tD3014A57510D018F890E6524AC62F9417E2E6C4E ** get_address_of_m_asyncTail_6() { return &___m_asyncTail_6; }
inline void set_m_asyncTail_6(TaskNode_tD3014A57510D018F890E6524AC62F9417E2E6C4E * value)
{
___m_asyncTail_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_asyncTail_6), (void*)value);
}
};
struct SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385_StaticFields
{
public:
// System.Threading.Tasks.Task`1<System.Boolean> System.Threading.SemaphoreSlim::s_trueTask
Task_1_t9C1FE9F18F52F3409B9E970FA38801A443AE7849 * ___s_trueTask_7;
// System.Action`1<System.Object> System.Threading.SemaphoreSlim::s_cancellationTokenCanceledEventHandler
Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC * ___s_cancellationTokenCanceledEventHandler_8;
public:
inline static int32_t get_offset_of_s_trueTask_7() { return static_cast<int32_t>(offsetof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385_StaticFields, ___s_trueTask_7)); }
inline Task_1_t9C1FE9F18F52F3409B9E970FA38801A443AE7849 * get_s_trueTask_7() const { return ___s_trueTask_7; }
inline Task_1_t9C1FE9F18F52F3409B9E970FA38801A443AE7849 ** get_address_of_s_trueTask_7() { return &___s_trueTask_7; }
inline void set_s_trueTask_7(Task_1_t9C1FE9F18F52F3409B9E970FA38801A443AE7849 * value)
{
___s_trueTask_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_trueTask_7), (void*)value);
}
inline static int32_t get_offset_of_s_cancellationTokenCanceledEventHandler_8() { return static_cast<int32_t>(offsetof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385_StaticFields, ___s_cancellationTokenCanceledEventHandler_8)); }
inline Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC * get_s_cancellationTokenCanceledEventHandler_8() const { return ___s_cancellationTokenCanceledEventHandler_8; }
inline Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC ** get_address_of_s_cancellationTokenCanceledEventHandler_8() { return &___s_cancellationTokenCanceledEventHandler_8; }
inline void set_s_cancellationTokenCanceledEventHandler_8(Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC * value)
{
___s_cancellationTokenCanceledEventHandler_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_cancellationTokenCanceledEventHandler_8), (void*)value);
}
};
// Windows.UI.Input.Spatial.SpatialInteractionSourceHandedness
struct SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B
{
public:
// System.Int32 Windows.UI.Input.Spatial.SpatialInteractionSourceHandedness::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B, ___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;
}
};
// Windows.UI.Input.Spatial.SpatialInteractionSourceKind
struct SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7
{
public:
// System.Int32 Windows.UI.Input.Spatial.SpatialInteractionSourceKind::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7, ___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;
}
};
// System.IO.StreamReader
struct StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3 : public TextReader_t25B06DCA1906FEAD02150DB14313EBEA4CD78D2F
{
public:
// System.IO.Stream System.IO.StreamReader::stream
Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB * ___stream_5;
// System.Text.Encoding System.IO.StreamReader::encoding
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___encoding_6;
// System.Text.Decoder System.IO.StreamReader::decoder
Decoder_t91B2ED8AEC25AA24D23A00265203BE992B12C370 * ___decoder_7;
// System.Byte[] System.IO.StreamReader::byteBuffer
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___byteBuffer_8;
// System.Char[] System.IO.StreamReader::charBuffer
CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* ___charBuffer_9;
// System.Byte[] System.IO.StreamReader::_preamble
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ____preamble_10;
// System.Int32 System.IO.StreamReader::charPos
int32_t ___charPos_11;
// System.Int32 System.IO.StreamReader::charLen
int32_t ___charLen_12;
// System.Int32 System.IO.StreamReader::byteLen
int32_t ___byteLen_13;
// System.Int32 System.IO.StreamReader::bytePos
int32_t ___bytePos_14;
// System.Int32 System.IO.StreamReader::_maxCharsPerBuffer
int32_t ____maxCharsPerBuffer_15;
// System.Boolean System.IO.StreamReader::_detectEncoding
bool ____detectEncoding_16;
// System.Boolean System.IO.StreamReader::_checkPreamble
bool ____checkPreamble_17;
// System.Boolean System.IO.StreamReader::_isBlocked
bool ____isBlocked_18;
// System.Boolean System.IO.StreamReader::_closable
bool ____closable_19;
// System.Threading.Tasks.Task modreq(System.Runtime.CompilerServices.IsVolatile) System.IO.StreamReader::_asyncReadTask
Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * ____asyncReadTask_20;
public:
inline static int32_t get_offset_of_stream_5() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ___stream_5)); }
inline Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB * get_stream_5() const { return ___stream_5; }
inline Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB ** get_address_of_stream_5() { return &___stream_5; }
inline void set_stream_5(Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB * value)
{
___stream_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___stream_5), (void*)value);
}
inline static int32_t get_offset_of_encoding_6() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ___encoding_6)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_encoding_6() const { return ___encoding_6; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_encoding_6() { return &___encoding_6; }
inline void set_encoding_6(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___encoding_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___encoding_6), (void*)value);
}
inline static int32_t get_offset_of_decoder_7() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ___decoder_7)); }
inline Decoder_t91B2ED8AEC25AA24D23A00265203BE992B12C370 * get_decoder_7() const { return ___decoder_7; }
inline Decoder_t91B2ED8AEC25AA24D23A00265203BE992B12C370 ** get_address_of_decoder_7() { return &___decoder_7; }
inline void set_decoder_7(Decoder_t91B2ED8AEC25AA24D23A00265203BE992B12C370 * value)
{
___decoder_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___decoder_7), (void*)value);
}
inline static int32_t get_offset_of_byteBuffer_8() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ___byteBuffer_8)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_byteBuffer_8() const { return ___byteBuffer_8; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_byteBuffer_8() { return &___byteBuffer_8; }
inline void set_byteBuffer_8(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___byteBuffer_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___byteBuffer_8), (void*)value);
}
inline static int32_t get_offset_of_charBuffer_9() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ___charBuffer_9)); }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* get_charBuffer_9() const { return ___charBuffer_9; }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34** get_address_of_charBuffer_9() { return &___charBuffer_9; }
inline void set_charBuffer_9(CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* value)
{
___charBuffer_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___charBuffer_9), (void*)value);
}
inline static int32_t get_offset_of__preamble_10() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ____preamble_10)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get__preamble_10() const { return ____preamble_10; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of__preamble_10() { return &____preamble_10; }
inline void set__preamble_10(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
____preamble_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&____preamble_10), (void*)value);
}
inline static int32_t get_offset_of_charPos_11() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ___charPos_11)); }
inline int32_t get_charPos_11() const { return ___charPos_11; }
inline int32_t* get_address_of_charPos_11() { return &___charPos_11; }
inline void set_charPos_11(int32_t value)
{
___charPos_11 = value;
}
inline static int32_t get_offset_of_charLen_12() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ___charLen_12)); }
inline int32_t get_charLen_12() const { return ___charLen_12; }
inline int32_t* get_address_of_charLen_12() { return &___charLen_12; }
inline void set_charLen_12(int32_t value)
{
___charLen_12 = value;
}
inline static int32_t get_offset_of_byteLen_13() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ___byteLen_13)); }
inline int32_t get_byteLen_13() const { return ___byteLen_13; }
inline int32_t* get_address_of_byteLen_13() { return &___byteLen_13; }
inline void set_byteLen_13(int32_t value)
{
___byteLen_13 = value;
}
inline static int32_t get_offset_of_bytePos_14() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ___bytePos_14)); }
inline int32_t get_bytePos_14() const { return ___bytePos_14; }
inline int32_t* get_address_of_bytePos_14() { return &___bytePos_14; }
inline void set_bytePos_14(int32_t value)
{
___bytePos_14 = value;
}
inline static int32_t get_offset_of__maxCharsPerBuffer_15() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ____maxCharsPerBuffer_15)); }
inline int32_t get__maxCharsPerBuffer_15() const { return ____maxCharsPerBuffer_15; }
inline int32_t* get_address_of__maxCharsPerBuffer_15() { return &____maxCharsPerBuffer_15; }
inline void set__maxCharsPerBuffer_15(int32_t value)
{
____maxCharsPerBuffer_15 = value;
}
inline static int32_t get_offset_of__detectEncoding_16() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ____detectEncoding_16)); }
inline bool get__detectEncoding_16() const { return ____detectEncoding_16; }
inline bool* get_address_of__detectEncoding_16() { return &____detectEncoding_16; }
inline void set__detectEncoding_16(bool value)
{
____detectEncoding_16 = value;
}
inline static int32_t get_offset_of__checkPreamble_17() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ____checkPreamble_17)); }
inline bool get__checkPreamble_17() const { return ____checkPreamble_17; }
inline bool* get_address_of__checkPreamble_17() { return &____checkPreamble_17; }
inline void set__checkPreamble_17(bool value)
{
____checkPreamble_17 = value;
}
inline static int32_t get_offset_of__isBlocked_18() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ____isBlocked_18)); }
inline bool get__isBlocked_18() const { return ____isBlocked_18; }
inline bool* get_address_of__isBlocked_18() { return &____isBlocked_18; }
inline void set__isBlocked_18(bool value)
{
____isBlocked_18 = value;
}
inline static int32_t get_offset_of__closable_19() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ____closable_19)); }
inline bool get__closable_19() const { return ____closable_19; }
inline bool* get_address_of__closable_19() { return &____closable_19; }
inline void set__closable_19(bool value)
{
____closable_19 = value;
}
inline static int32_t get_offset_of__asyncReadTask_20() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3, ____asyncReadTask_20)); }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * get__asyncReadTask_20() const { return ____asyncReadTask_20; }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 ** get_address_of__asyncReadTask_20() { return &____asyncReadTask_20; }
inline void set__asyncReadTask_20(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * value)
{
____asyncReadTask_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&____asyncReadTask_20), (void*)value);
}
};
struct StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3_StaticFields
{
public:
// System.IO.StreamReader System.IO.StreamReader::Null
StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3 * ___Null_4;
public:
inline static int32_t get_offset_of_Null_4() { return static_cast<int32_t>(offsetof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3_StaticFields, ___Null_4)); }
inline StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3 * get_Null_4() const { return ___Null_4; }
inline StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3 ** get_address_of_Null_4() { return &___Null_4; }
inline void set_Null_4(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3 * value)
{
___Null_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Null_4), (void*)value);
}
};
// System.Threading.Tasks.Task
struct Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 : public RuntimeObject
{
public:
// System.Int32 modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.Tasks.Task::m_taskId
int32_t ___m_taskId_4;
// System.Object System.Threading.Tasks.Task::m_action
RuntimeObject * ___m_action_5;
// System.Object System.Threading.Tasks.Task::m_stateObject
RuntimeObject * ___m_stateObject_6;
// System.Threading.Tasks.TaskScheduler System.Threading.Tasks.Task::m_taskScheduler
TaskScheduler_t74FBEEEDBDD5E0088FF0EEC18F45CD866B098D5D * ___m_taskScheduler_7;
// System.Threading.Tasks.Task System.Threading.Tasks.Task::m_parent
Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * ___m_parent_8;
// System.Int32 modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.Tasks.Task::m_stateFlags
int32_t ___m_stateFlags_9;
// System.Object modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.Tasks.Task::m_continuationObject
RuntimeObject * ___m_continuationObject_10;
// System.Threading.Tasks.Task/ContingentProperties modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.Tasks.Task::m_contingentProperties
ContingentProperties_t1E249C737B8B8644ED1D60EEFA101D326B199EA0 * ___m_contingentProperties_15;
public:
inline static int32_t get_offset_of_m_taskId_4() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60, ___m_taskId_4)); }
inline int32_t get_m_taskId_4() const { return ___m_taskId_4; }
inline int32_t* get_address_of_m_taskId_4() { return &___m_taskId_4; }
inline void set_m_taskId_4(int32_t value)
{
___m_taskId_4 = value;
}
inline static int32_t get_offset_of_m_action_5() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60, ___m_action_5)); }
inline RuntimeObject * get_m_action_5() const { return ___m_action_5; }
inline RuntimeObject ** get_address_of_m_action_5() { return &___m_action_5; }
inline void set_m_action_5(RuntimeObject * value)
{
___m_action_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_action_5), (void*)value);
}
inline static int32_t get_offset_of_m_stateObject_6() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60, ___m_stateObject_6)); }
inline RuntimeObject * get_m_stateObject_6() const { return ___m_stateObject_6; }
inline RuntimeObject ** get_address_of_m_stateObject_6() { return &___m_stateObject_6; }
inline void set_m_stateObject_6(RuntimeObject * value)
{
___m_stateObject_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_stateObject_6), (void*)value);
}
inline static int32_t get_offset_of_m_taskScheduler_7() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60, ___m_taskScheduler_7)); }
inline TaskScheduler_t74FBEEEDBDD5E0088FF0EEC18F45CD866B098D5D * get_m_taskScheduler_7() const { return ___m_taskScheduler_7; }
inline TaskScheduler_t74FBEEEDBDD5E0088FF0EEC18F45CD866B098D5D ** get_address_of_m_taskScheduler_7() { return &___m_taskScheduler_7; }
inline void set_m_taskScheduler_7(TaskScheduler_t74FBEEEDBDD5E0088FF0EEC18F45CD866B098D5D * value)
{
___m_taskScheduler_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_taskScheduler_7), (void*)value);
}
inline static int32_t get_offset_of_m_parent_8() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60, ___m_parent_8)); }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * get_m_parent_8() const { return ___m_parent_8; }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 ** get_address_of_m_parent_8() { return &___m_parent_8; }
inline void set_m_parent_8(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * value)
{
___m_parent_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_parent_8), (void*)value);
}
inline static int32_t get_offset_of_m_stateFlags_9() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60, ___m_stateFlags_9)); }
inline int32_t get_m_stateFlags_9() const { return ___m_stateFlags_9; }
inline int32_t* get_address_of_m_stateFlags_9() { return &___m_stateFlags_9; }
inline void set_m_stateFlags_9(int32_t value)
{
___m_stateFlags_9 = value;
}
inline static int32_t get_offset_of_m_continuationObject_10() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60, ___m_continuationObject_10)); }
inline RuntimeObject * get_m_continuationObject_10() const { return ___m_continuationObject_10; }
inline RuntimeObject ** get_address_of_m_continuationObject_10() { return &___m_continuationObject_10; }
inline void set_m_continuationObject_10(RuntimeObject * value)
{
___m_continuationObject_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_continuationObject_10), (void*)value);
}
inline static int32_t get_offset_of_m_contingentProperties_15() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60, ___m_contingentProperties_15)); }
inline ContingentProperties_t1E249C737B8B8644ED1D60EEFA101D326B199EA0 * get_m_contingentProperties_15() const { return ___m_contingentProperties_15; }
inline ContingentProperties_t1E249C737B8B8644ED1D60EEFA101D326B199EA0 ** get_address_of_m_contingentProperties_15() { return &___m_contingentProperties_15; }
inline void set_m_contingentProperties_15(ContingentProperties_t1E249C737B8B8644ED1D60EEFA101D326B199EA0 * value)
{
___m_contingentProperties_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_contingentProperties_15), (void*)value);
}
};
struct Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields
{
public:
// System.Int32 System.Threading.Tasks.Task::s_taskIdCounter
int32_t ___s_taskIdCounter_2;
// System.Threading.Tasks.TaskFactory System.Threading.Tasks.Task::s_factory
TaskFactory_t22D999A05A967C31A4B5FFBD08864809BF35EA3B * ___s_factory_3;
// System.Object System.Threading.Tasks.Task::s_taskCompletionSentinel
RuntimeObject * ___s_taskCompletionSentinel_11;
// System.Boolean System.Threading.Tasks.Task::s_asyncDebuggingEnabled
bool ___s_asyncDebuggingEnabled_12;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Threading.Tasks.Task> System.Threading.Tasks.Task::s_currentActiveTasks
Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8 * ___s_currentActiveTasks_13;
// System.Object System.Threading.Tasks.Task::s_activeTasksLock
RuntimeObject * ___s_activeTasksLock_14;
// System.Action`1<System.Object> System.Threading.Tasks.Task::s_taskCancelCallback
Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC * ___s_taskCancelCallback_16;
// System.Func`1<System.Threading.Tasks.Task/ContingentProperties> System.Threading.Tasks.Task::s_createContingentProperties
Func_1_tBCF42601FA307876E83080BE4204110820F8BF3B * ___s_createContingentProperties_17;
// System.Threading.Tasks.Task System.Threading.Tasks.Task::s_completedTask
Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * ___s_completedTask_18;
// System.Predicate`1<System.Threading.Tasks.Task> System.Threading.Tasks.Task::s_IsExceptionObservedByParentPredicate
Predicate_1_tC0DBBC8498BD1EE6ABFFAA5628024105FA7D11BD * ___s_IsExceptionObservedByParentPredicate_19;
// System.Threading.ContextCallback System.Threading.Tasks.Task::s_ecCallback
ContextCallback_t93707E0430F4FF3E15E1FB5A4844BE89C657AE8B * ___s_ecCallback_20;
// System.Predicate`1<System.Object> System.Threading.Tasks.Task::s_IsTaskContinuationNullPredicate
Predicate_1_t5C96B81B31A697B11C4C3767E3298773AF25DFEB * ___s_IsTaskContinuationNullPredicate_21;
public:
inline static int32_t get_offset_of_s_taskIdCounter_2() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_taskIdCounter_2)); }
inline int32_t get_s_taskIdCounter_2() const { return ___s_taskIdCounter_2; }
inline int32_t* get_address_of_s_taskIdCounter_2() { return &___s_taskIdCounter_2; }
inline void set_s_taskIdCounter_2(int32_t value)
{
___s_taskIdCounter_2 = value;
}
inline static int32_t get_offset_of_s_factory_3() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_factory_3)); }
inline TaskFactory_t22D999A05A967C31A4B5FFBD08864809BF35EA3B * get_s_factory_3() const { return ___s_factory_3; }
inline TaskFactory_t22D999A05A967C31A4B5FFBD08864809BF35EA3B ** get_address_of_s_factory_3() { return &___s_factory_3; }
inline void set_s_factory_3(TaskFactory_t22D999A05A967C31A4B5FFBD08864809BF35EA3B * value)
{
___s_factory_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_factory_3), (void*)value);
}
inline static int32_t get_offset_of_s_taskCompletionSentinel_11() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_taskCompletionSentinel_11)); }
inline RuntimeObject * get_s_taskCompletionSentinel_11() const { return ___s_taskCompletionSentinel_11; }
inline RuntimeObject ** get_address_of_s_taskCompletionSentinel_11() { return &___s_taskCompletionSentinel_11; }
inline void set_s_taskCompletionSentinel_11(RuntimeObject * value)
{
___s_taskCompletionSentinel_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_taskCompletionSentinel_11), (void*)value);
}
inline static int32_t get_offset_of_s_asyncDebuggingEnabled_12() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_asyncDebuggingEnabled_12)); }
inline bool get_s_asyncDebuggingEnabled_12() const { return ___s_asyncDebuggingEnabled_12; }
inline bool* get_address_of_s_asyncDebuggingEnabled_12() { return &___s_asyncDebuggingEnabled_12; }
inline void set_s_asyncDebuggingEnabled_12(bool value)
{
___s_asyncDebuggingEnabled_12 = value;
}
inline static int32_t get_offset_of_s_currentActiveTasks_13() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_currentActiveTasks_13)); }
inline Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8 * get_s_currentActiveTasks_13() const { return ___s_currentActiveTasks_13; }
inline Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8 ** get_address_of_s_currentActiveTasks_13() { return &___s_currentActiveTasks_13; }
inline void set_s_currentActiveTasks_13(Dictionary_2_tB758E2A2593CD827EFC041BE1F1BB4B68DE1C3E8 * value)
{
___s_currentActiveTasks_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_currentActiveTasks_13), (void*)value);
}
inline static int32_t get_offset_of_s_activeTasksLock_14() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_activeTasksLock_14)); }
inline RuntimeObject * get_s_activeTasksLock_14() const { return ___s_activeTasksLock_14; }
inline RuntimeObject ** get_address_of_s_activeTasksLock_14() { return &___s_activeTasksLock_14; }
inline void set_s_activeTasksLock_14(RuntimeObject * value)
{
___s_activeTasksLock_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_activeTasksLock_14), (void*)value);
}
inline static int32_t get_offset_of_s_taskCancelCallback_16() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_taskCancelCallback_16)); }
inline Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC * get_s_taskCancelCallback_16() const { return ___s_taskCancelCallback_16; }
inline Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC ** get_address_of_s_taskCancelCallback_16() { return &___s_taskCancelCallback_16; }
inline void set_s_taskCancelCallback_16(Action_1_tD9663D9715FAA4E62035CFCF1AD4D094EE7872DC * value)
{
___s_taskCancelCallback_16 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_taskCancelCallback_16), (void*)value);
}
inline static int32_t get_offset_of_s_createContingentProperties_17() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_createContingentProperties_17)); }
inline Func_1_tBCF42601FA307876E83080BE4204110820F8BF3B * get_s_createContingentProperties_17() const { return ___s_createContingentProperties_17; }
inline Func_1_tBCF42601FA307876E83080BE4204110820F8BF3B ** get_address_of_s_createContingentProperties_17() { return &___s_createContingentProperties_17; }
inline void set_s_createContingentProperties_17(Func_1_tBCF42601FA307876E83080BE4204110820F8BF3B * value)
{
___s_createContingentProperties_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_createContingentProperties_17), (void*)value);
}
inline static int32_t get_offset_of_s_completedTask_18() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_completedTask_18)); }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * get_s_completedTask_18() const { return ___s_completedTask_18; }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 ** get_address_of_s_completedTask_18() { return &___s_completedTask_18; }
inline void set_s_completedTask_18(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * value)
{
___s_completedTask_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_completedTask_18), (void*)value);
}
inline static int32_t get_offset_of_s_IsExceptionObservedByParentPredicate_19() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_IsExceptionObservedByParentPredicate_19)); }
inline Predicate_1_tC0DBBC8498BD1EE6ABFFAA5628024105FA7D11BD * get_s_IsExceptionObservedByParentPredicate_19() const { return ___s_IsExceptionObservedByParentPredicate_19; }
inline Predicate_1_tC0DBBC8498BD1EE6ABFFAA5628024105FA7D11BD ** get_address_of_s_IsExceptionObservedByParentPredicate_19() { return &___s_IsExceptionObservedByParentPredicate_19; }
inline void set_s_IsExceptionObservedByParentPredicate_19(Predicate_1_tC0DBBC8498BD1EE6ABFFAA5628024105FA7D11BD * value)
{
___s_IsExceptionObservedByParentPredicate_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_IsExceptionObservedByParentPredicate_19), (void*)value);
}
inline static int32_t get_offset_of_s_ecCallback_20() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_ecCallback_20)); }
inline ContextCallback_t93707E0430F4FF3E15E1FB5A4844BE89C657AE8B * get_s_ecCallback_20() const { return ___s_ecCallback_20; }
inline ContextCallback_t93707E0430F4FF3E15E1FB5A4844BE89C657AE8B ** get_address_of_s_ecCallback_20() { return &___s_ecCallback_20; }
inline void set_s_ecCallback_20(ContextCallback_t93707E0430F4FF3E15E1FB5A4844BE89C657AE8B * value)
{
___s_ecCallback_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_ecCallback_20), (void*)value);
}
inline static int32_t get_offset_of_s_IsTaskContinuationNullPredicate_21() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_StaticFields, ___s_IsTaskContinuationNullPredicate_21)); }
inline Predicate_1_t5C96B81B31A697B11C4C3767E3298773AF25DFEB * get_s_IsTaskContinuationNullPredicate_21() const { return ___s_IsTaskContinuationNullPredicate_21; }
inline Predicate_1_t5C96B81B31A697B11C4C3767E3298773AF25DFEB ** get_address_of_s_IsTaskContinuationNullPredicate_21() { return &___s_IsTaskContinuationNullPredicate_21; }
inline void set_s_IsTaskContinuationNullPredicate_21(Predicate_1_t5C96B81B31A697B11C4C3767E3298773AF25DFEB * value)
{
___s_IsTaskContinuationNullPredicate_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_IsTaskContinuationNullPredicate_21), (void*)value);
}
};
struct Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_ThreadStaticFields
{
public:
// System.Threading.Tasks.Task System.Threading.Tasks.Task::t_currentTask
Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * ___t_currentTask_0;
// System.Threading.Tasks.StackGuard System.Threading.Tasks.Task::t_stackGuard
StackGuard_t88E1EE4741AD02CA5FEA04A4EB2CC70F230E0E6D * ___t_stackGuard_1;
public:
inline static int32_t get_offset_of_t_currentTask_0() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_ThreadStaticFields, ___t_currentTask_0)); }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * get_t_currentTask_0() const { return ___t_currentTask_0; }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 ** get_address_of_t_currentTask_0() { return &___t_currentTask_0; }
inline void set_t_currentTask_0(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * value)
{
___t_currentTask_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___t_currentTask_0), (void*)value);
}
inline static int32_t get_offset_of_t_stackGuard_1() { return static_cast<int32_t>(offsetof(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60_ThreadStaticFields, ___t_stackGuard_1)); }
inline StackGuard_t88E1EE4741AD02CA5FEA04A4EB2CC70F230E0E6D * get_t_stackGuard_1() const { return ___t_stackGuard_1; }
inline StackGuard_t88E1EE4741AD02CA5FEA04A4EB2CC70F230E0E6D ** get_address_of_t_stackGuard_1() { return &___t_stackGuard_1; }
inline void set_t_stackGuard_1(StackGuard_t88E1EE4741AD02CA5FEA04A4EB2CC70F230E0E6D * value)
{
___t_stackGuard_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___t_stackGuard_1), (void*)value);
}
};
// System.TimeSpan
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203
{
public:
// System.Int64 System.TimeSpan::_ticks
int64_t ____ticks_3;
public:
inline static int32_t get_offset_of__ticks_3() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203, ____ticks_3)); }
inline int64_t get__ticks_3() const { return ____ticks_3; }
inline int64_t* get_address_of__ticks_3() { return &____ticks_3; }
inline void set__ticks_3(int64_t value)
{
____ticks_3 = value;
}
};
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields
{
public:
// System.TimeSpan System.TimeSpan::Zero
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___Zero_0;
// System.TimeSpan System.TimeSpan::MaxValue
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___MaxValue_1;
// System.TimeSpan System.TimeSpan::MinValue
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___MinValue_2;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyConfigChecked
bool ____legacyConfigChecked_4;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyMode
bool ____legacyMode_5;
public:
inline static int32_t get_offset_of_Zero_0() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___Zero_0)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_Zero_0() const { return ___Zero_0; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_Zero_0() { return &___Zero_0; }
inline void set_Zero_0(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___Zero_0 = value;
}
inline static int32_t get_offset_of_MaxValue_1() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___MaxValue_1)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_MaxValue_1() const { return ___MaxValue_1; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_MaxValue_1() { return &___MaxValue_1; }
inline void set_MaxValue_1(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___MaxValue_1 = value;
}
inline static int32_t get_offset_of_MinValue_2() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___MinValue_2)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_MinValue_2() const { return ___MinValue_2; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_MinValue_2() { return &___MinValue_2; }
inline void set_MinValue_2(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___MinValue_2 = value;
}
inline static int32_t get_offset_of__legacyConfigChecked_4() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ____legacyConfigChecked_4)); }
inline bool get__legacyConfigChecked_4() const { return ____legacyConfigChecked_4; }
inline bool* get_address_of__legacyConfigChecked_4() { return &____legacyConfigChecked_4; }
inline void set__legacyConfigChecked_4(bool value)
{
____legacyConfigChecked_4 = value;
}
inline static int32_t get_offset_of__legacyMode_5() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ____legacyMode_5)); }
inline bool get__legacyMode_5() const { return ____legacyMode_5; }
inline bool* get_address_of__legacyMode_5() { return &____legacyMode_5; }
inline void set__legacyMode_5(bool value)
{
____legacyMode_5 = value;
}
};
// System.Threading.WaitHandle
struct WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842 : public MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8
{
public:
// System.IntPtr System.Threading.WaitHandle::waitHandle
intptr_t ___waitHandle_3;
// Microsoft.Win32.SafeHandles.SafeWaitHandle modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.WaitHandle::safeWaitHandle
SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1 * ___safeWaitHandle_4;
// System.Boolean System.Threading.WaitHandle::hasThreadAffinity
bool ___hasThreadAffinity_5;
public:
inline static int32_t get_offset_of_waitHandle_3() { return static_cast<int32_t>(offsetof(WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842, ___waitHandle_3)); }
inline intptr_t get_waitHandle_3() const { return ___waitHandle_3; }
inline intptr_t* get_address_of_waitHandle_3() { return &___waitHandle_3; }
inline void set_waitHandle_3(intptr_t value)
{
___waitHandle_3 = value;
}
inline static int32_t get_offset_of_safeWaitHandle_4() { return static_cast<int32_t>(offsetof(WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842, ___safeWaitHandle_4)); }
inline SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1 * get_safeWaitHandle_4() const { return ___safeWaitHandle_4; }
inline SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1 ** get_address_of_safeWaitHandle_4() { return &___safeWaitHandle_4; }
inline void set_safeWaitHandle_4(SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1 * value)
{
___safeWaitHandle_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___safeWaitHandle_4), (void*)value);
}
inline static int32_t get_offset_of_hasThreadAffinity_5() { return static_cast<int32_t>(offsetof(WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842, ___hasThreadAffinity_5)); }
inline bool get_hasThreadAffinity_5() const { return ___hasThreadAffinity_5; }
inline bool* get_address_of_hasThreadAffinity_5() { return &___hasThreadAffinity_5; }
inline void set_hasThreadAffinity_5(bool value)
{
___hasThreadAffinity_5 = value;
}
};
struct WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842_StaticFields
{
public:
// System.IntPtr System.Threading.WaitHandle::InvalidHandle
intptr_t ___InvalidHandle_10;
public:
inline static int32_t get_offset_of_InvalidHandle_10() { return static_cast<int32_t>(offsetof(WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842_StaticFields, ___InvalidHandle_10)); }
inline intptr_t get_InvalidHandle_10() const { return ___InvalidHandle_10; }
inline intptr_t* get_address_of_InvalidHandle_10() { return &___InvalidHandle_10; }
inline void set_InvalidHandle_10(intptr_t value)
{
___InvalidHandle_10 = value;
}
};
// Native definition for P/Invoke marshalling of System.Threading.WaitHandle
struct WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842_marshaled_pinvoke : public MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8_marshaled_pinvoke
{
intptr_t ___waitHandle_3;
void* ___safeWaitHandle_4;
int32_t ___hasThreadAffinity_5;
};
// Native definition for COM marshalling of System.Threading.WaitHandle
struct WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842_marshaled_com : public MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8_marshaled_com
{
intptr_t ___waitHandle_3;
void* ___safeWaitHandle_4;
int32_t ___hasThreadAffinity_5;
};
// Microsoft.MixedReality.Toolkit.BaseDataProvider`1<Microsoft.MixedReality.Toolkit.Input.IMixedRealityInputSystem>
struct BaseDataProvider_1_t3589CFF3526B1A6A8BD790F9940DB1CA28C43A02 : public BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16
{
public:
// Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar Microsoft.MixedReality.Toolkit.BaseDataProvider`1::<Registrar>k__BackingField
RuntimeObject* ___U3CRegistrarU3Ek__BackingField_8;
// T Microsoft.MixedReality.Toolkit.BaseDataProvider`1::<Service>k__BackingField
RuntimeObject* ___U3CServiceU3Ek__BackingField_9;
public:
inline static int32_t get_offset_of_U3CRegistrarU3Ek__BackingField_8() { return static_cast<int32_t>(offsetof(BaseDataProvider_1_t3589CFF3526B1A6A8BD790F9940DB1CA28C43A02, ___U3CRegistrarU3Ek__BackingField_8)); }
inline RuntimeObject* get_U3CRegistrarU3Ek__BackingField_8() const { return ___U3CRegistrarU3Ek__BackingField_8; }
inline RuntimeObject** get_address_of_U3CRegistrarU3Ek__BackingField_8() { return &___U3CRegistrarU3Ek__BackingField_8; }
inline void set_U3CRegistrarU3Ek__BackingField_8(RuntimeObject* value)
{
___U3CRegistrarU3Ek__BackingField_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CRegistrarU3Ek__BackingField_8), (void*)value);
}
inline static int32_t get_offset_of_U3CServiceU3Ek__BackingField_9() { return static_cast<int32_t>(offsetof(BaseDataProvider_1_t3589CFF3526B1A6A8BD790F9940DB1CA28C43A02, ___U3CServiceU3Ek__BackingField_9)); }
inline RuntimeObject* get_U3CServiceU3Ek__BackingField_9() const { return ___U3CServiceU3Ek__BackingField_9; }
inline RuntimeObject** get_address_of_U3CServiceU3Ek__BackingField_9() { return &___U3CServiceU3Ek__BackingField_9; }
inline void set_U3CServiceU3Ek__BackingField_9(RuntimeObject* value)
{
___U3CServiceU3Ek__BackingField_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CServiceU3Ek__BackingField_9), (void*)value);
}
};
// Windows.Foundation.IReference`1<Windows.Foundation.PropertyType>
struct NOVTABLE IReference_1_tA4E67817B79498EFBA69D3B855B0D877416F6A8B : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_mAFDC3A521A2D5078E107CAAA4F124AFC2D25F526(int32_t* comReturnValue) = 0;
};
// Windows.Foundation.IReference`1<Windows.UI.Input.Spatial.SpatialInteractionSourceHandedness>
struct NOVTABLE IReference_1_t0976D6A3C4B3A2296DE9EC238663EBCA4B18240B : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m31DA5B4095EA7D9AC3547820AEF5AC55A293E816(int32_t* comReturnValue) = 0;
};
// Windows.Foundation.IReference`1<Windows.UI.Input.Spatial.SpatialInteractionSourceKind>
struct NOVTABLE IReference_1_tFBF6EDC09F056C59D8EEFE81E5EA39206D2AF70C : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReference_1_get_Value_m5388021AB708A278C93226BC20DDA41AD0DF74EC(int32_t* comReturnValue) = 0;
};
// System.Nullable`1<UnityEngine.Ray>
struct Nullable_1_tCE70D5232DA58B57AD93CA774181BD1FAA49A963
{
public:
// T System.Nullable`1::value
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___value_0;
// System.Boolean System.Nullable`1::has_value
bool ___has_value_1;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(Nullable_1_tCE70D5232DA58B57AD93CA774181BD1FAA49A963, ___value_0)); }
inline Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 get_value_0() const { return ___value_0; }
inline Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * get_address_of_value_0() { return &___value_0; }
inline void set_value_0(Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 value)
{
___value_0 = value;
}
inline static int32_t get_offset_of_has_value_1() { return static_cast<int32_t>(offsetof(Nullable_1_tCE70D5232DA58B57AD93CA774181BD1FAA49A963, ___has_value_1)); }
inline bool get_has_value_1() const { return ___has_value_1; }
inline bool* get_address_of_has_value_1() { return &___has_value_1; }
inline void set_has_value_1(bool value)
{
___has_value_1 = value;
}
};
// Microsoft.MixedReality.Toolkit.BaseEventSystem
struct BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC : public BaseService_tF2C2512816D1D0EE872AC911E3BAF7F9E5A44C16
{
public:
// System.Int32 Microsoft.MixedReality.Toolkit.BaseEventSystem::eventExecutionDepth
int32_t ___eventExecutionDepth_9;
// System.Type Microsoft.MixedReality.Toolkit.BaseEventSystem::eventSystemHandlerType
Type_t * ___eventSystemHandlerType_10;
// System.Collections.Generic.List`1<System.Tuple`3<Microsoft.MixedReality.Toolkit.BaseEventSystem/Action,System.Type,UnityEngine.EventSystems.IEventSystemHandler>> Microsoft.MixedReality.Toolkit.BaseEventSystem::postponedActions
List_1_tB2338FC47817B39A67EDF98A81C666A585CBB1B0 * ___postponedActions_11;
// System.Collections.Generic.List`1<System.Tuple`2<Microsoft.MixedReality.Toolkit.BaseEventSystem/Action,UnityEngine.GameObject>> Microsoft.MixedReality.Toolkit.BaseEventSystem::postponedObjectActions
List_1_tFBD74CBAB85AF6A2E49F61373B8A7503C022E2CD * ___postponedObjectActions_12;
// System.Collections.Generic.Dictionary`2<System.Type,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry>> Microsoft.MixedReality.Toolkit.BaseEventSystem::<EventHandlersByType>k__BackingField
Dictionary_2_t9C346C961DA726D2E935BCA9F27BF39FE4EB463B * ___U3CEventHandlersByTypeU3Ek__BackingField_13;
// System.Collections.Generic.List`1<UnityEngine.GameObject> Microsoft.MixedReality.Toolkit.BaseEventSystem::<EventListeners>k__BackingField
List_1_t6D0A10F47F3440798295D2FFFC6D016477AF38E5 * ___U3CEventListenersU3Ek__BackingField_14;
public:
inline static int32_t get_offset_of_eventExecutionDepth_9() { return static_cast<int32_t>(offsetof(BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC, ___eventExecutionDepth_9)); }
inline int32_t get_eventExecutionDepth_9() const { return ___eventExecutionDepth_9; }
inline int32_t* get_address_of_eventExecutionDepth_9() { return &___eventExecutionDepth_9; }
inline void set_eventExecutionDepth_9(int32_t value)
{
___eventExecutionDepth_9 = value;
}
inline static int32_t get_offset_of_eventSystemHandlerType_10() { return static_cast<int32_t>(offsetof(BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC, ___eventSystemHandlerType_10)); }
inline Type_t * get_eventSystemHandlerType_10() const { return ___eventSystemHandlerType_10; }
inline Type_t ** get_address_of_eventSystemHandlerType_10() { return &___eventSystemHandlerType_10; }
inline void set_eventSystemHandlerType_10(Type_t * value)
{
___eventSystemHandlerType_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___eventSystemHandlerType_10), (void*)value);
}
inline static int32_t get_offset_of_postponedActions_11() { return static_cast<int32_t>(offsetof(BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC, ___postponedActions_11)); }
inline List_1_tB2338FC47817B39A67EDF98A81C666A585CBB1B0 * get_postponedActions_11() const { return ___postponedActions_11; }
inline List_1_tB2338FC47817B39A67EDF98A81C666A585CBB1B0 ** get_address_of_postponedActions_11() { return &___postponedActions_11; }
inline void set_postponedActions_11(List_1_tB2338FC47817B39A67EDF98A81C666A585CBB1B0 * value)
{
___postponedActions_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___postponedActions_11), (void*)value);
}
inline static int32_t get_offset_of_postponedObjectActions_12() { return static_cast<int32_t>(offsetof(BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC, ___postponedObjectActions_12)); }
inline List_1_tFBD74CBAB85AF6A2E49F61373B8A7503C022E2CD * get_postponedObjectActions_12() const { return ___postponedObjectActions_12; }
inline List_1_tFBD74CBAB85AF6A2E49F61373B8A7503C022E2CD ** get_address_of_postponedObjectActions_12() { return &___postponedObjectActions_12; }
inline void set_postponedObjectActions_12(List_1_tFBD74CBAB85AF6A2E49F61373B8A7503C022E2CD * value)
{
___postponedObjectActions_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___postponedObjectActions_12), (void*)value);
}
inline static int32_t get_offset_of_U3CEventHandlersByTypeU3Ek__BackingField_13() { return static_cast<int32_t>(offsetof(BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC, ___U3CEventHandlersByTypeU3Ek__BackingField_13)); }
inline Dictionary_2_t9C346C961DA726D2E935BCA9F27BF39FE4EB463B * get_U3CEventHandlersByTypeU3Ek__BackingField_13() const { return ___U3CEventHandlersByTypeU3Ek__BackingField_13; }
inline Dictionary_2_t9C346C961DA726D2E935BCA9F27BF39FE4EB463B ** get_address_of_U3CEventHandlersByTypeU3Ek__BackingField_13() { return &___U3CEventHandlersByTypeU3Ek__BackingField_13; }
inline void set_U3CEventHandlersByTypeU3Ek__BackingField_13(Dictionary_2_t9C346C961DA726D2E935BCA9F27BF39FE4EB463B * value)
{
___U3CEventHandlersByTypeU3Ek__BackingField_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CEventHandlersByTypeU3Ek__BackingField_13), (void*)value);
}
inline static int32_t get_offset_of_U3CEventListenersU3Ek__BackingField_14() { return static_cast<int32_t>(offsetof(BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC, ___U3CEventListenersU3Ek__BackingField_14)); }
inline List_1_t6D0A10F47F3440798295D2FFFC6D016477AF38E5 * get_U3CEventListenersU3Ek__BackingField_14() const { return ___U3CEventListenersU3Ek__BackingField_14; }
inline List_1_t6D0A10F47F3440798295D2FFFC6D016477AF38E5 ** get_address_of_U3CEventListenersU3Ek__BackingField_14() { return &___U3CEventListenersU3Ek__BackingField_14; }
inline void set_U3CEventListenersU3Ek__BackingField_14(List_1_t6D0A10F47F3440798295D2FFFC6D016477AF38E5 * value)
{
___U3CEventListenersU3Ek__BackingField_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CEventListenersU3Ek__BackingField_14), (void*)value);
}
};
struct BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC_StaticFields
{
public:
// System.Boolean Microsoft.MixedReality.Toolkit.BaseEventSystem::enableDanglingHandlerDiagnostics
bool ___enableDanglingHandlerDiagnostics_8;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.BaseEventSystem::TraverseEventSystemHandlerHierarchyPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___TraverseEventSystemHandlerHierarchyPerfMarker_15;
public:
inline static int32_t get_offset_of_enableDanglingHandlerDiagnostics_8() { return static_cast<int32_t>(offsetof(BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC_StaticFields, ___enableDanglingHandlerDiagnostics_8)); }
inline bool get_enableDanglingHandlerDiagnostics_8() const { return ___enableDanglingHandlerDiagnostics_8; }
inline bool* get_address_of_enableDanglingHandlerDiagnostics_8() { return &___enableDanglingHandlerDiagnostics_8; }
inline void set_enableDanglingHandlerDiagnostics_8(bool value)
{
___enableDanglingHandlerDiagnostics_8 = value;
}
inline static int32_t get_offset_of_TraverseEventSystemHandlerHierarchyPerfMarker_15() { return static_cast<int32_t>(offsetof(BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC_StaticFields, ___TraverseEventSystemHandlerHierarchyPerfMarker_15)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_TraverseEventSystemHandlerHierarchyPerfMarker_15() const { return ___TraverseEventSystemHandlerHierarchyPerfMarker_15; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_TraverseEventSystemHandlerHierarchyPerfMarker_15() { return &___TraverseEventSystemHandlerHierarchyPerfMarker_15; }
inline void set_TraverseEventSystemHandlerHierarchyPerfMarker_15(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___TraverseEventSystemHandlerHierarchyPerfMarker_15 = value;
}
};
// UnityEngine.Component
struct Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684 : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A
{
public:
public:
};
// Windows.Foundation.IPropertyValue
struct NOVTABLE IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) = 0;
};
// System.Threading.Mutex
struct Mutex_tA342933FCB3E3E679E3CD498804DE36CD81801B5 : public WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842
{
public:
public:
};
// System.Threading.Tasks.ParallelForReplicaTask
struct ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6 : public Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60
{
public:
// System.Object System.Threading.Tasks.ParallelForReplicaTask::m_stateForNextReplica
RuntimeObject * ___m_stateForNextReplica_22;
// System.Object System.Threading.Tasks.ParallelForReplicaTask::m_stateFromPreviousReplica
RuntimeObject * ___m_stateFromPreviousReplica_23;
// System.Threading.Tasks.Task System.Threading.Tasks.ParallelForReplicaTask::m_handedOverChildReplica
Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * ___m_handedOverChildReplica_24;
public:
inline static int32_t get_offset_of_m_stateForNextReplica_22() { return static_cast<int32_t>(offsetof(ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6, ___m_stateForNextReplica_22)); }
inline RuntimeObject * get_m_stateForNextReplica_22() const { return ___m_stateForNextReplica_22; }
inline RuntimeObject ** get_address_of_m_stateForNextReplica_22() { return &___m_stateForNextReplica_22; }
inline void set_m_stateForNextReplica_22(RuntimeObject * value)
{
___m_stateForNextReplica_22 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_stateForNextReplica_22), (void*)value);
}
inline static int32_t get_offset_of_m_stateFromPreviousReplica_23() { return static_cast<int32_t>(offsetof(ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6, ___m_stateFromPreviousReplica_23)); }
inline RuntimeObject * get_m_stateFromPreviousReplica_23() const { return ___m_stateFromPreviousReplica_23; }
inline RuntimeObject ** get_address_of_m_stateFromPreviousReplica_23() { return &___m_stateFromPreviousReplica_23; }
inline void set_m_stateFromPreviousReplica_23(RuntimeObject * value)
{
___m_stateFromPreviousReplica_23 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_stateFromPreviousReplica_23), (void*)value);
}
inline static int32_t get_offset_of_m_handedOverChildReplica_24() { return static_cast<int32_t>(offsetof(ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6, ___m_handedOverChildReplica_24)); }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * get_m_handedOverChildReplica_24() const { return ___m_handedOverChildReplica_24; }
inline Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 ** get_address_of_m_handedOverChildReplica_24() { return &___m_handedOverChildReplica_24; }
inline void set_m_handedOverChildReplica_24(Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60 * value)
{
___m_handedOverChildReplica_24 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_handedOverChildReplica_24), (void*)value);
}
};
// System.Threading.Tasks.ParallelForReplicatingTask
struct ParallelForReplicatingTask_t5C662CB60CF2C6AAAFD99BCE33295652B32762A9 : public Task_t804B25CFE3FC13AAEE16C8FA3BF52513F2A8DB60
{
public:
// System.Int32 System.Threading.Tasks.ParallelForReplicatingTask::m_replicationDownCount
int32_t ___m_replicationDownCount_22;
public:
inline static int32_t get_offset_of_m_replicationDownCount_22() { return static_cast<int32_t>(offsetof(ParallelForReplicatingTask_t5C662CB60CF2C6AAAFD99BCE33295652B32762A9, ___m_replicationDownCount_22)); }
inline int32_t get_m_replicationDownCount_22() const { return ___m_replicationDownCount_22; }
inline int32_t* get_address_of_m_replicationDownCount_22() { return &___m_replicationDownCount_22; }
inline void set_m_replicationDownCount_22(int32_t value)
{
___m_replicationDownCount_22 = value;
}
};
// UnityEngine.Windows.WebCam.PhotoCaptureFrame
struct PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0 : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Windows.WebCam.PhotoCaptureFrame::m_NativePtr
intptr_t ___m_NativePtr_0;
// System.Int32 UnityEngine.Windows.WebCam.PhotoCaptureFrame::<dataLength>k__BackingField
int32_t ___U3CdataLengthU3Ek__BackingField_1;
// System.Boolean UnityEngine.Windows.WebCam.PhotoCaptureFrame::<hasLocationData>k__BackingField
bool ___U3ChasLocationDataU3Ek__BackingField_2;
// UnityEngine.Windows.WebCam.CapturePixelFormat UnityEngine.Windows.WebCam.PhotoCaptureFrame::<pixelFormat>k__BackingField
int32_t ___U3CpixelFormatU3Ek__BackingField_3;
public:
inline static int32_t get_offset_of_m_NativePtr_0() { return static_cast<int32_t>(offsetof(PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0, ___m_NativePtr_0)); }
inline intptr_t get_m_NativePtr_0() const { return ___m_NativePtr_0; }
inline intptr_t* get_address_of_m_NativePtr_0() { return &___m_NativePtr_0; }
inline void set_m_NativePtr_0(intptr_t value)
{
___m_NativePtr_0 = value;
}
inline static int32_t get_offset_of_U3CdataLengthU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0, ___U3CdataLengthU3Ek__BackingField_1)); }
inline int32_t get_U3CdataLengthU3Ek__BackingField_1() const { return ___U3CdataLengthU3Ek__BackingField_1; }
inline int32_t* get_address_of_U3CdataLengthU3Ek__BackingField_1() { return &___U3CdataLengthU3Ek__BackingField_1; }
inline void set_U3CdataLengthU3Ek__BackingField_1(int32_t value)
{
___U3CdataLengthU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3ChasLocationDataU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0, ___U3ChasLocationDataU3Ek__BackingField_2)); }
inline bool get_U3ChasLocationDataU3Ek__BackingField_2() const { return ___U3ChasLocationDataU3Ek__BackingField_2; }
inline bool* get_address_of_U3ChasLocationDataU3Ek__BackingField_2() { return &___U3ChasLocationDataU3Ek__BackingField_2; }
inline void set_U3ChasLocationDataU3Ek__BackingField_2(bool value)
{
___U3ChasLocationDataU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CpixelFormatU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0, ___U3CpixelFormatU3Ek__BackingField_3)); }
inline int32_t get_U3CpixelFormatU3Ek__BackingField_3() const { return ___U3CpixelFormatU3Ek__BackingField_3; }
inline int32_t* get_address_of_U3CpixelFormatU3Ek__BackingField_3() { return &___U3CpixelFormatU3Ek__BackingField_3; }
inline void set_U3CpixelFormatU3Ek__BackingField_3(int32_t value)
{
___U3CpixelFormatU3Ek__BackingField_3 = value;
}
};
// Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid
struct SafeHandleZeroOrMinusOneIsInvalid_t0C690C7DC958D0C04E529E2BB0F6569956328B45 : public SafeHandle_tC07DCA2CABF6988953342757EFB1547363E5A36B
{
public:
public:
};
// System.IO.UnmanagedMemoryStream
struct UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62 : public Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB
{
public:
// System.Runtime.InteropServices.SafeBuffer System.IO.UnmanagedMemoryStream::_buffer
SafeBuffer_tABA0D0B754FCCF3625CD905D535296E353C630D2 * ____buffer_4;
// System.Byte* System.IO.UnmanagedMemoryStream::_mem
uint8_t* ____mem_5;
// System.Int64 System.IO.UnmanagedMemoryStream::_length
int64_t ____length_6;
// System.Int64 System.IO.UnmanagedMemoryStream::_capacity
int64_t ____capacity_7;
// System.Int64 System.IO.UnmanagedMemoryStream::_position
int64_t ____position_8;
// System.Int64 System.IO.UnmanagedMemoryStream::_offset
int64_t ____offset_9;
// System.IO.FileAccess System.IO.UnmanagedMemoryStream::_access
int32_t ____access_10;
// System.Boolean System.IO.UnmanagedMemoryStream::_isOpen
bool ____isOpen_11;
public:
inline static int32_t get_offset_of__buffer_4() { return static_cast<int32_t>(offsetof(UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62, ____buffer_4)); }
inline SafeBuffer_tABA0D0B754FCCF3625CD905D535296E353C630D2 * get__buffer_4() const { return ____buffer_4; }
inline SafeBuffer_tABA0D0B754FCCF3625CD905D535296E353C630D2 ** get_address_of__buffer_4() { return &____buffer_4; }
inline void set__buffer_4(SafeBuffer_tABA0D0B754FCCF3625CD905D535296E353C630D2 * value)
{
____buffer_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____buffer_4), (void*)value);
}
inline static int32_t get_offset_of__mem_5() { return static_cast<int32_t>(offsetof(UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62, ____mem_5)); }
inline uint8_t* get__mem_5() const { return ____mem_5; }
inline uint8_t** get_address_of__mem_5() { return &____mem_5; }
inline void set__mem_5(uint8_t* value)
{
____mem_5 = value;
}
inline static int32_t get_offset_of__length_6() { return static_cast<int32_t>(offsetof(UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62, ____length_6)); }
inline int64_t get__length_6() const { return ____length_6; }
inline int64_t* get_address_of__length_6() { return &____length_6; }
inline void set__length_6(int64_t value)
{
____length_6 = value;
}
inline static int32_t get_offset_of__capacity_7() { return static_cast<int32_t>(offsetof(UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62, ____capacity_7)); }
inline int64_t get__capacity_7() const { return ____capacity_7; }
inline int64_t* get_address_of__capacity_7() { return &____capacity_7; }
inline void set__capacity_7(int64_t value)
{
____capacity_7 = value;
}
inline static int32_t get_offset_of__position_8() { return static_cast<int32_t>(offsetof(UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62, ____position_8)); }
inline int64_t get__position_8() const { return ____position_8; }
inline int64_t* get_address_of__position_8() { return &____position_8; }
inline void set__position_8(int64_t value)
{
____position_8 = value;
}
inline static int32_t get_offset_of__offset_9() { return static_cast<int32_t>(offsetof(UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62, ____offset_9)); }
inline int64_t get__offset_9() const { return ____offset_9; }
inline int64_t* get_address_of__offset_9() { return &____offset_9; }
inline void set__offset_9(int64_t value)
{
____offset_9 = value;
}
inline static int32_t get_offset_of__access_10() { return static_cast<int32_t>(offsetof(UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62, ____access_10)); }
inline int32_t get__access_10() const { return ____access_10; }
inline int32_t* get_address_of__access_10() { return &____access_10; }
inline void set__access_10(int32_t value)
{
____access_10 = value;
}
inline static int32_t get_offset_of__isOpen_11() { return static_cast<int32_t>(offsetof(UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62, ____isOpen_11)); }
inline bool get__isOpen_11() const { return ____isOpen_11; }
inline bool* get_address_of__isOpen_11() { return &____isOpen_11; }
inline void set__isOpen_11(bool value)
{
____isOpen_11 = value;
}
};
// Microsoft.MixedReality.Toolkit.BaseCoreSystem
struct BaseCoreSystem_tD60FB642C7AFAB28F3D023BEDD98D52A0ED105D1 : public BaseEventSystem_t3D8C69A25D5A24E2D5A9D4AA786DA498318ACBCC
{
public:
// Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar Microsoft.MixedReality.Toolkit.BaseCoreSystem::<Registrar>k__BackingField
RuntimeObject* ___U3CRegistrarU3Ek__BackingField_16;
public:
inline static int32_t get_offset_of_U3CRegistrarU3Ek__BackingField_16() { return static_cast<int32_t>(offsetof(BaseCoreSystem_tD60FB642C7AFAB28F3D023BEDD98D52A0ED105D1, ___U3CRegistrarU3Ek__BackingField_16)); }
inline RuntimeObject* get_U3CRegistrarU3Ek__BackingField_16() const { return ___U3CRegistrarU3Ek__BackingField_16; }
inline RuntimeObject** get_address_of_U3CRegistrarU3Ek__BackingField_16() { return &___U3CRegistrarU3Ek__BackingField_16; }
inline void set_U3CRegistrarU3Ek__BackingField_16(RuntimeObject* value)
{
___U3CRegistrarU3Ek__BackingField_16 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CRegistrarU3Ek__BackingField_16), (void*)value);
}
};
// Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager
struct BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB : public BaseDataProvider_1_t3589CFF3526B1A6A8BD790F9940DB1CA28C43A02
{
public:
// System.Boolean Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager::enablePointerCache
bool ___enablePointerCache_10;
// Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager/PointerConfig[] Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager::pointerConfigurations
PointerConfigU5BU5D_t17182F245D18BDE8E16CCF14BC0FF2793EF9B08E* ___pointerConfigurations_11;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.Input.IMixedRealityPointer,System.UInt32> Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager::activePointersToConfig
Dictionary_2_tB877F46A6C20A56DEA8ED6DC3E004A3171647E3B * ___activePointersToConfig_13;
public:
inline static int32_t get_offset_of_enablePointerCache_10() { return static_cast<int32_t>(offsetof(BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB, ___enablePointerCache_10)); }
inline bool get_enablePointerCache_10() const { return ___enablePointerCache_10; }
inline bool* get_address_of_enablePointerCache_10() { return &___enablePointerCache_10; }
inline void set_enablePointerCache_10(bool value)
{
___enablePointerCache_10 = value;
}
inline static int32_t get_offset_of_pointerConfigurations_11() { return static_cast<int32_t>(offsetof(BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB, ___pointerConfigurations_11)); }
inline PointerConfigU5BU5D_t17182F245D18BDE8E16CCF14BC0FF2793EF9B08E* get_pointerConfigurations_11() const { return ___pointerConfigurations_11; }
inline PointerConfigU5BU5D_t17182F245D18BDE8E16CCF14BC0FF2793EF9B08E** get_address_of_pointerConfigurations_11() { return &___pointerConfigurations_11; }
inline void set_pointerConfigurations_11(PointerConfigU5BU5D_t17182F245D18BDE8E16CCF14BC0FF2793EF9B08E* value)
{
___pointerConfigurations_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___pointerConfigurations_11), (void*)value);
}
inline static int32_t get_offset_of_activePointersToConfig_13() { return static_cast<int32_t>(offsetof(BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB, ___activePointersToConfig_13)); }
inline Dictionary_2_tB877F46A6C20A56DEA8ED6DC3E004A3171647E3B * get_activePointersToConfig_13() const { return ___activePointersToConfig_13; }
inline Dictionary_2_tB877F46A6C20A56DEA8ED6DC3E004A3171647E3B ** get_address_of_activePointersToConfig_13() { return &___activePointersToConfig_13; }
inline void set_activePointersToConfig_13(Dictionary_2_tB877F46A6C20A56DEA8ED6DC3E004A3171647E3B * value)
{
___activePointersToConfig_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___activePointersToConfig_13), (void*)value);
}
};
struct BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB_StaticFields
{
public:
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager::RequestPointersPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___RequestPointersPerfMarker_12;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager::RecyclePointersPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___RecyclePointersPerfMarker_14;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager::CreatePointerPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___CreatePointerPerfMarker_15;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Input.BaseInputDeviceManager::CleanActivePointersPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___CleanActivePointersPerfMarker_16;
public:
inline static int32_t get_offset_of_RequestPointersPerfMarker_12() { return static_cast<int32_t>(offsetof(BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB_StaticFields, ___RequestPointersPerfMarker_12)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_RequestPointersPerfMarker_12() const { return ___RequestPointersPerfMarker_12; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_RequestPointersPerfMarker_12() { return &___RequestPointersPerfMarker_12; }
inline void set_RequestPointersPerfMarker_12(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___RequestPointersPerfMarker_12 = value;
}
inline static int32_t get_offset_of_RecyclePointersPerfMarker_14() { return static_cast<int32_t>(offsetof(BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB_StaticFields, ___RecyclePointersPerfMarker_14)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_RecyclePointersPerfMarker_14() const { return ___RecyclePointersPerfMarker_14; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_RecyclePointersPerfMarker_14() { return &___RecyclePointersPerfMarker_14; }
inline void set_RecyclePointersPerfMarker_14(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___RecyclePointersPerfMarker_14 = value;
}
inline static int32_t get_offset_of_CreatePointerPerfMarker_15() { return static_cast<int32_t>(offsetof(BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB_StaticFields, ___CreatePointerPerfMarker_15)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_CreatePointerPerfMarker_15() const { return ___CreatePointerPerfMarker_15; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_CreatePointerPerfMarker_15() { return &___CreatePointerPerfMarker_15; }
inline void set_CreatePointerPerfMarker_15(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___CreatePointerPerfMarker_15 = value;
}
inline static int32_t get_offset_of_CleanActivePointersPerfMarker_16() { return static_cast<int32_t>(offsetof(BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB_StaticFields, ___CleanActivePointersPerfMarker_16)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_CleanActivePointersPerfMarker_16() const { return ___CleanActivePointersPerfMarker_16; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_CleanActivePointersPerfMarker_16() { return &___CleanActivePointersPerfMarker_16; }
inline void set_CleanActivePointersPerfMarker_16(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___CleanActivePointersPerfMarker_16 = value;
}
};
// System.IO.PinnedBufferMemoryStream
struct PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78 : public UnmanagedMemoryStream_tCF65E90F0047A6F54D79A6A5E681BC98AE6C2F62
{
public:
// System.Byte[] System.IO.PinnedBufferMemoryStream::_array
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ____array_12;
// System.Runtime.InteropServices.GCHandle System.IO.PinnedBufferMemoryStream::_pinningHandle
GCHandle_t757890BC4BBBEDE5A623A3C110013EDD24613603 ____pinningHandle_13;
public:
inline static int32_t get_offset_of__array_12() { return static_cast<int32_t>(offsetof(PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78, ____array_12)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get__array_12() const { return ____array_12; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of__array_12() { return &____array_12; }
inline void set__array_12(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
____array_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____array_12), (void*)value);
}
inline static int32_t get_offset_of__pinningHandle_13() { return static_cast<int32_t>(offsetof(PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78, ____pinningHandle_13)); }
inline GCHandle_t757890BC4BBBEDE5A623A3C110013EDD24613603 get__pinningHandle_13() const { return ____pinningHandle_13; }
inline GCHandle_t757890BC4BBBEDE5A623A3C110013EDD24613603 * get_address_of__pinningHandle_13() { return &____pinningHandle_13; }
inline void set__pinningHandle_13(GCHandle_t757890BC4BBBEDE5A623A3C110013EDD24613603 value)
{
____pinningHandle_13 = value;
}
};
// Microsoft.Win32.SafeHandles.SafeFileHandle
struct SafeFileHandle_tC77A9860A03C31DC46AD2C08EC10EACDC3B7A662 : public SafeHandleZeroOrMinusOneIsInvalid_t0C690C7DC958D0C04E529E2BB0F6569956328B45
{
public:
public:
};
// Microsoft.Win32.SafeHandles.SafeFindHandle
struct SafeFindHandle_t0E0D5349FC3144C1CAB2D20DCD3023B25833B8BD : public SafeHandleZeroOrMinusOneIsInvalid_t0C690C7DC958D0C04E529E2BB0F6569956328B45
{
public:
public:
};
// Microsoft.Win32.SafeHandles.SafeRegistryHandle
struct SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545 : public SafeHandleZeroOrMinusOneIsInvalid_t0C690C7DC958D0C04E529E2BB0F6569956328B45
{
public:
public:
};
// Microsoft.Win32.SafeHandles.SafeWaitHandle
struct SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1 : public SafeHandleZeroOrMinusOneIsInvalid_t0C690C7DC958D0C04E529E2BB0F6569956328B45
{
public:
public:
};
// UnityEngine.Transform
struct Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 : public Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684
{
public:
public:
};
// Microsoft.MixedReality.Toolkit.BaseDataProviderAccessCoreSystem
struct BaseDataProviderAccessCoreSystem_t7A7B0A8F1AA8A4A6F16E2590B1A5125C9D6B6B47 : public BaseCoreSystem_tD60FB642C7AFAB28F3D023BEDD98D52A0ED105D1
{
public:
// System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.IMixedRealityDataProvider> Microsoft.MixedReality.Toolkit.BaseDataProviderAccessCoreSystem::dataProviders
List_1_t94FC783F2185B5CB832CD245C5E89430CC6533D4 * ___dataProviders_17;
public:
inline static int32_t get_offset_of_dataProviders_17() { return static_cast<int32_t>(offsetof(BaseDataProviderAccessCoreSystem_t7A7B0A8F1AA8A4A6F16E2590B1A5125C9D6B6B47, ___dataProviders_17)); }
inline List_1_t94FC783F2185B5CB832CD245C5E89430CC6533D4 * get_dataProviders_17() const { return ___dataProviders_17; }
inline List_1_t94FC783F2185B5CB832CD245C5E89430CC6533D4 ** get_address_of_dataProviders_17() { return &___dataProviders_17; }
inline void set_dataProviders_17(List_1_t94FC783F2185B5CB832CD245C5E89430CC6533D4 * value)
{
___dataProviders_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dataProviders_17), (void*)value);
}
};
struct BaseDataProviderAccessCoreSystem_t7A7B0A8F1AA8A4A6F16E2590B1A5125C9D6B6B47_StaticFields
{
public:
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.BaseDataProviderAccessCoreSystem::UpdatePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___UpdatePerfMarker_18;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.BaseDataProviderAccessCoreSystem::LateUpdatePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___LateUpdatePerfMarker_19;
public:
inline static int32_t get_offset_of_UpdatePerfMarker_18() { return static_cast<int32_t>(offsetof(BaseDataProviderAccessCoreSystem_t7A7B0A8F1AA8A4A6F16E2590B1A5125C9D6B6B47_StaticFields, ___UpdatePerfMarker_18)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_UpdatePerfMarker_18() const { return ___UpdatePerfMarker_18; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_UpdatePerfMarker_18() { return &___UpdatePerfMarker_18; }
inline void set_UpdatePerfMarker_18(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___UpdatePerfMarker_18 = value;
}
inline static int32_t get_offset_of_LateUpdatePerfMarker_19() { return static_cast<int32_t>(offsetof(BaseDataProviderAccessCoreSystem_t7A7B0A8F1AA8A4A6F16E2590B1A5125C9D6B6B47_StaticFields, ___LateUpdatePerfMarker_19)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_LateUpdatePerfMarker_19() const { return ___LateUpdatePerfMarker_19; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_LateUpdatePerfMarker_19() { return &___LateUpdatePerfMarker_19; }
inline void set_LateUpdatePerfMarker_19(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___LateUpdatePerfMarker_19 = value;
}
};
// Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem
struct MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00 : public BaseCoreSystem_tD60FB642C7AFAB28F3D023BEDD98D52A0ED105D1
{
public:
// System.Boolean Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::managerSceneOpInProgress
bool ___managerSceneOpInProgress_18;
// System.Single Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::managerSceneOpProgress
float ___managerSceneOpProgress_19;
// Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem/SceneContentTracker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::contentTracker
SceneContentTracker_t63E7FA6D49DD34641F8A8975B6808FFC39383B65 * ___contentTracker_20;
// Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem/SceneLightingExecutor Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::lightingExecutor
SceneLightingExecutor_t284A3495A5AF7E28B3778E8605ACF1806F2A1556 * ___lightingExecutor_21;
// System.String Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<Name>k__BackingField
String_t* ___U3CNameU3Ek__BackingField_22;
// System.Action`1<System.Collections.Generic.IEnumerable`1<System.String>> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnWillLoadContent>k__BackingField
Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * ___U3COnWillLoadContentU3Ek__BackingField_23;
// System.Action`1<System.Collections.Generic.IEnumerable`1<System.String>> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnContentLoaded>k__BackingField
Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * ___U3COnContentLoadedU3Ek__BackingField_24;
// System.Action`1<System.Collections.Generic.IEnumerable`1<System.String>> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnWillUnloadContent>k__BackingField
Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * ___U3COnWillUnloadContentU3Ek__BackingField_25;
// System.Action`1<System.Collections.Generic.IEnumerable`1<System.String>> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnContentUnloaded>k__BackingField
Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * ___U3COnContentUnloadedU3Ek__BackingField_26;
// System.Action`1<System.String> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnWillLoadLighting>k__BackingField
Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * ___U3COnWillLoadLightingU3Ek__BackingField_27;
// System.Action`1<System.String> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnLightingLoaded>k__BackingField
Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * ___U3COnLightingLoadedU3Ek__BackingField_28;
// System.Action`1<System.String> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnWillUnloadLighting>k__BackingField
Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * ___U3COnWillUnloadLightingU3Ek__BackingField_29;
// System.Action`1<System.String> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnLightingUnloaded>k__BackingField
Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * ___U3COnLightingUnloadedU3Ek__BackingField_30;
// System.Action`1<System.String> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnWillLoadScene>k__BackingField
Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * ___U3COnWillLoadSceneU3Ek__BackingField_31;
// System.Action`1<System.String> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnSceneLoaded>k__BackingField
Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * ___U3COnSceneLoadedU3Ek__BackingField_32;
// System.Action`1<System.String> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnWillUnloadScene>k__BackingField
Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * ___U3COnWillUnloadSceneU3Ek__BackingField_33;
// System.Action`1<System.String> Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<OnSceneUnloaded>k__BackingField
Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * ___U3COnSceneUnloadedU3Ek__BackingField_34;
// System.Boolean Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<SceneOperationInProgress>k__BackingField
bool ___U3CSceneOperationInProgressU3Ek__BackingField_35;
// System.Single Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<SceneOperationProgress>k__BackingField
float ___U3CSceneOperationProgressU3Ek__BackingField_36;
// System.Boolean Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<LightingOperationInProgress>k__BackingField
bool ___U3CLightingOperationInProgressU3Ek__BackingField_37;
// System.Single Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<LightingOperationProgress>k__BackingField
float ___U3CLightingOperationProgressU3Ek__BackingField_38;
// System.String Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<ActiveLightingScene>k__BackingField
String_t* ___U3CActiveLightingSceneU3Ek__BackingField_39;
// System.Boolean Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<WaitingToProceed>k__BackingField
bool ___U3CWaitingToProceedU3Ek__BackingField_40;
// System.UInt32 Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<SourceId>k__BackingField
uint32_t ___U3CSourceIdU3Ek__BackingField_41;
// System.String Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::<SourceName>k__BackingField
String_t* ___U3CSourceNameU3Ek__BackingField_42;
public:
inline static int32_t get_offset_of_managerSceneOpInProgress_18() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___managerSceneOpInProgress_18)); }
inline bool get_managerSceneOpInProgress_18() const { return ___managerSceneOpInProgress_18; }
inline bool* get_address_of_managerSceneOpInProgress_18() { return &___managerSceneOpInProgress_18; }
inline void set_managerSceneOpInProgress_18(bool value)
{
___managerSceneOpInProgress_18 = value;
}
inline static int32_t get_offset_of_managerSceneOpProgress_19() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___managerSceneOpProgress_19)); }
inline float get_managerSceneOpProgress_19() const { return ___managerSceneOpProgress_19; }
inline float* get_address_of_managerSceneOpProgress_19() { return &___managerSceneOpProgress_19; }
inline void set_managerSceneOpProgress_19(float value)
{
___managerSceneOpProgress_19 = value;
}
inline static int32_t get_offset_of_contentTracker_20() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___contentTracker_20)); }
inline SceneContentTracker_t63E7FA6D49DD34641F8A8975B6808FFC39383B65 * get_contentTracker_20() const { return ___contentTracker_20; }
inline SceneContentTracker_t63E7FA6D49DD34641F8A8975B6808FFC39383B65 ** get_address_of_contentTracker_20() { return &___contentTracker_20; }
inline void set_contentTracker_20(SceneContentTracker_t63E7FA6D49DD34641F8A8975B6808FFC39383B65 * value)
{
___contentTracker_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___contentTracker_20), (void*)value);
}
inline static int32_t get_offset_of_lightingExecutor_21() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___lightingExecutor_21)); }
inline SceneLightingExecutor_t284A3495A5AF7E28B3778E8605ACF1806F2A1556 * get_lightingExecutor_21() const { return ___lightingExecutor_21; }
inline SceneLightingExecutor_t284A3495A5AF7E28B3778E8605ACF1806F2A1556 ** get_address_of_lightingExecutor_21() { return &___lightingExecutor_21; }
inline void set_lightingExecutor_21(SceneLightingExecutor_t284A3495A5AF7E28B3778E8605ACF1806F2A1556 * value)
{
___lightingExecutor_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___lightingExecutor_21), (void*)value);
}
inline static int32_t get_offset_of_U3CNameU3Ek__BackingField_22() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3CNameU3Ek__BackingField_22)); }
inline String_t* get_U3CNameU3Ek__BackingField_22() const { return ___U3CNameU3Ek__BackingField_22; }
inline String_t** get_address_of_U3CNameU3Ek__BackingField_22() { return &___U3CNameU3Ek__BackingField_22; }
inline void set_U3CNameU3Ek__BackingField_22(String_t* value)
{
___U3CNameU3Ek__BackingField_22 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CNameU3Ek__BackingField_22), (void*)value);
}
inline static int32_t get_offset_of_U3COnWillLoadContentU3Ek__BackingField_23() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnWillLoadContentU3Ek__BackingField_23)); }
inline Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * get_U3COnWillLoadContentU3Ek__BackingField_23() const { return ___U3COnWillLoadContentU3Ek__BackingField_23; }
inline Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 ** get_address_of_U3COnWillLoadContentU3Ek__BackingField_23() { return &___U3COnWillLoadContentU3Ek__BackingField_23; }
inline void set_U3COnWillLoadContentU3Ek__BackingField_23(Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * value)
{
___U3COnWillLoadContentU3Ek__BackingField_23 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnWillLoadContentU3Ek__BackingField_23), (void*)value);
}
inline static int32_t get_offset_of_U3COnContentLoadedU3Ek__BackingField_24() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnContentLoadedU3Ek__BackingField_24)); }
inline Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * get_U3COnContentLoadedU3Ek__BackingField_24() const { return ___U3COnContentLoadedU3Ek__BackingField_24; }
inline Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 ** get_address_of_U3COnContentLoadedU3Ek__BackingField_24() { return &___U3COnContentLoadedU3Ek__BackingField_24; }
inline void set_U3COnContentLoadedU3Ek__BackingField_24(Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * value)
{
___U3COnContentLoadedU3Ek__BackingField_24 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnContentLoadedU3Ek__BackingField_24), (void*)value);
}
inline static int32_t get_offset_of_U3COnWillUnloadContentU3Ek__BackingField_25() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnWillUnloadContentU3Ek__BackingField_25)); }
inline Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * get_U3COnWillUnloadContentU3Ek__BackingField_25() const { return ___U3COnWillUnloadContentU3Ek__BackingField_25; }
inline Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 ** get_address_of_U3COnWillUnloadContentU3Ek__BackingField_25() { return &___U3COnWillUnloadContentU3Ek__BackingField_25; }
inline void set_U3COnWillUnloadContentU3Ek__BackingField_25(Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * value)
{
___U3COnWillUnloadContentU3Ek__BackingField_25 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnWillUnloadContentU3Ek__BackingField_25), (void*)value);
}
inline static int32_t get_offset_of_U3COnContentUnloadedU3Ek__BackingField_26() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnContentUnloadedU3Ek__BackingField_26)); }
inline Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * get_U3COnContentUnloadedU3Ek__BackingField_26() const { return ___U3COnContentUnloadedU3Ek__BackingField_26; }
inline Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 ** get_address_of_U3COnContentUnloadedU3Ek__BackingField_26() { return &___U3COnContentUnloadedU3Ek__BackingField_26; }
inline void set_U3COnContentUnloadedU3Ek__BackingField_26(Action_1_t8B3FD6155D04E2C2D284B5C21B863CDC18E89439 * value)
{
___U3COnContentUnloadedU3Ek__BackingField_26 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnContentUnloadedU3Ek__BackingField_26), (void*)value);
}
inline static int32_t get_offset_of_U3COnWillLoadLightingU3Ek__BackingField_27() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnWillLoadLightingU3Ek__BackingField_27)); }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * get_U3COnWillLoadLightingU3Ek__BackingField_27() const { return ___U3COnWillLoadLightingU3Ek__BackingField_27; }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 ** get_address_of_U3COnWillLoadLightingU3Ek__BackingField_27() { return &___U3COnWillLoadLightingU3Ek__BackingField_27; }
inline void set_U3COnWillLoadLightingU3Ek__BackingField_27(Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * value)
{
___U3COnWillLoadLightingU3Ek__BackingField_27 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnWillLoadLightingU3Ek__BackingField_27), (void*)value);
}
inline static int32_t get_offset_of_U3COnLightingLoadedU3Ek__BackingField_28() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnLightingLoadedU3Ek__BackingField_28)); }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * get_U3COnLightingLoadedU3Ek__BackingField_28() const { return ___U3COnLightingLoadedU3Ek__BackingField_28; }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 ** get_address_of_U3COnLightingLoadedU3Ek__BackingField_28() { return &___U3COnLightingLoadedU3Ek__BackingField_28; }
inline void set_U3COnLightingLoadedU3Ek__BackingField_28(Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * value)
{
___U3COnLightingLoadedU3Ek__BackingField_28 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnLightingLoadedU3Ek__BackingField_28), (void*)value);
}
inline static int32_t get_offset_of_U3COnWillUnloadLightingU3Ek__BackingField_29() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnWillUnloadLightingU3Ek__BackingField_29)); }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * get_U3COnWillUnloadLightingU3Ek__BackingField_29() const { return ___U3COnWillUnloadLightingU3Ek__BackingField_29; }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 ** get_address_of_U3COnWillUnloadLightingU3Ek__BackingField_29() { return &___U3COnWillUnloadLightingU3Ek__BackingField_29; }
inline void set_U3COnWillUnloadLightingU3Ek__BackingField_29(Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * value)
{
___U3COnWillUnloadLightingU3Ek__BackingField_29 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnWillUnloadLightingU3Ek__BackingField_29), (void*)value);
}
inline static int32_t get_offset_of_U3COnLightingUnloadedU3Ek__BackingField_30() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnLightingUnloadedU3Ek__BackingField_30)); }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * get_U3COnLightingUnloadedU3Ek__BackingField_30() const { return ___U3COnLightingUnloadedU3Ek__BackingField_30; }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 ** get_address_of_U3COnLightingUnloadedU3Ek__BackingField_30() { return &___U3COnLightingUnloadedU3Ek__BackingField_30; }
inline void set_U3COnLightingUnloadedU3Ek__BackingField_30(Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * value)
{
___U3COnLightingUnloadedU3Ek__BackingField_30 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnLightingUnloadedU3Ek__BackingField_30), (void*)value);
}
inline static int32_t get_offset_of_U3COnWillLoadSceneU3Ek__BackingField_31() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnWillLoadSceneU3Ek__BackingField_31)); }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * get_U3COnWillLoadSceneU3Ek__BackingField_31() const { return ___U3COnWillLoadSceneU3Ek__BackingField_31; }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 ** get_address_of_U3COnWillLoadSceneU3Ek__BackingField_31() { return &___U3COnWillLoadSceneU3Ek__BackingField_31; }
inline void set_U3COnWillLoadSceneU3Ek__BackingField_31(Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * value)
{
___U3COnWillLoadSceneU3Ek__BackingField_31 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnWillLoadSceneU3Ek__BackingField_31), (void*)value);
}
inline static int32_t get_offset_of_U3COnSceneLoadedU3Ek__BackingField_32() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnSceneLoadedU3Ek__BackingField_32)); }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * get_U3COnSceneLoadedU3Ek__BackingField_32() const { return ___U3COnSceneLoadedU3Ek__BackingField_32; }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 ** get_address_of_U3COnSceneLoadedU3Ek__BackingField_32() { return &___U3COnSceneLoadedU3Ek__BackingField_32; }
inline void set_U3COnSceneLoadedU3Ek__BackingField_32(Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * value)
{
___U3COnSceneLoadedU3Ek__BackingField_32 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnSceneLoadedU3Ek__BackingField_32), (void*)value);
}
inline static int32_t get_offset_of_U3COnWillUnloadSceneU3Ek__BackingField_33() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnWillUnloadSceneU3Ek__BackingField_33)); }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * get_U3COnWillUnloadSceneU3Ek__BackingField_33() const { return ___U3COnWillUnloadSceneU3Ek__BackingField_33; }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 ** get_address_of_U3COnWillUnloadSceneU3Ek__BackingField_33() { return &___U3COnWillUnloadSceneU3Ek__BackingField_33; }
inline void set_U3COnWillUnloadSceneU3Ek__BackingField_33(Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * value)
{
___U3COnWillUnloadSceneU3Ek__BackingField_33 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnWillUnloadSceneU3Ek__BackingField_33), (void*)value);
}
inline static int32_t get_offset_of_U3COnSceneUnloadedU3Ek__BackingField_34() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3COnSceneUnloadedU3Ek__BackingField_34)); }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * get_U3COnSceneUnloadedU3Ek__BackingField_34() const { return ___U3COnSceneUnloadedU3Ek__BackingField_34; }
inline Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 ** get_address_of_U3COnSceneUnloadedU3Ek__BackingField_34() { return &___U3COnSceneUnloadedU3Ek__BackingField_34; }
inline void set_U3COnSceneUnloadedU3Ek__BackingField_34(Action_1_tC0D73E03177C82525D78670CDC2165F7CBF0A9C3 * value)
{
___U3COnSceneUnloadedU3Ek__BackingField_34 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3COnSceneUnloadedU3Ek__BackingField_34), (void*)value);
}
inline static int32_t get_offset_of_U3CSceneOperationInProgressU3Ek__BackingField_35() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3CSceneOperationInProgressU3Ek__BackingField_35)); }
inline bool get_U3CSceneOperationInProgressU3Ek__BackingField_35() const { return ___U3CSceneOperationInProgressU3Ek__BackingField_35; }
inline bool* get_address_of_U3CSceneOperationInProgressU3Ek__BackingField_35() { return &___U3CSceneOperationInProgressU3Ek__BackingField_35; }
inline void set_U3CSceneOperationInProgressU3Ek__BackingField_35(bool value)
{
___U3CSceneOperationInProgressU3Ek__BackingField_35 = value;
}
inline static int32_t get_offset_of_U3CSceneOperationProgressU3Ek__BackingField_36() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3CSceneOperationProgressU3Ek__BackingField_36)); }
inline float get_U3CSceneOperationProgressU3Ek__BackingField_36() const { return ___U3CSceneOperationProgressU3Ek__BackingField_36; }
inline float* get_address_of_U3CSceneOperationProgressU3Ek__BackingField_36() { return &___U3CSceneOperationProgressU3Ek__BackingField_36; }
inline void set_U3CSceneOperationProgressU3Ek__BackingField_36(float value)
{
___U3CSceneOperationProgressU3Ek__BackingField_36 = value;
}
inline static int32_t get_offset_of_U3CLightingOperationInProgressU3Ek__BackingField_37() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3CLightingOperationInProgressU3Ek__BackingField_37)); }
inline bool get_U3CLightingOperationInProgressU3Ek__BackingField_37() const { return ___U3CLightingOperationInProgressU3Ek__BackingField_37; }
inline bool* get_address_of_U3CLightingOperationInProgressU3Ek__BackingField_37() { return &___U3CLightingOperationInProgressU3Ek__BackingField_37; }
inline void set_U3CLightingOperationInProgressU3Ek__BackingField_37(bool value)
{
___U3CLightingOperationInProgressU3Ek__BackingField_37 = value;
}
inline static int32_t get_offset_of_U3CLightingOperationProgressU3Ek__BackingField_38() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3CLightingOperationProgressU3Ek__BackingField_38)); }
inline float get_U3CLightingOperationProgressU3Ek__BackingField_38() const { return ___U3CLightingOperationProgressU3Ek__BackingField_38; }
inline float* get_address_of_U3CLightingOperationProgressU3Ek__BackingField_38() { return &___U3CLightingOperationProgressU3Ek__BackingField_38; }
inline void set_U3CLightingOperationProgressU3Ek__BackingField_38(float value)
{
___U3CLightingOperationProgressU3Ek__BackingField_38 = value;
}
inline static int32_t get_offset_of_U3CActiveLightingSceneU3Ek__BackingField_39() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3CActiveLightingSceneU3Ek__BackingField_39)); }
inline String_t* get_U3CActiveLightingSceneU3Ek__BackingField_39() const { return ___U3CActiveLightingSceneU3Ek__BackingField_39; }
inline String_t** get_address_of_U3CActiveLightingSceneU3Ek__BackingField_39() { return &___U3CActiveLightingSceneU3Ek__BackingField_39; }
inline void set_U3CActiveLightingSceneU3Ek__BackingField_39(String_t* value)
{
___U3CActiveLightingSceneU3Ek__BackingField_39 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CActiveLightingSceneU3Ek__BackingField_39), (void*)value);
}
inline static int32_t get_offset_of_U3CWaitingToProceedU3Ek__BackingField_40() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3CWaitingToProceedU3Ek__BackingField_40)); }
inline bool get_U3CWaitingToProceedU3Ek__BackingField_40() const { return ___U3CWaitingToProceedU3Ek__BackingField_40; }
inline bool* get_address_of_U3CWaitingToProceedU3Ek__BackingField_40() { return &___U3CWaitingToProceedU3Ek__BackingField_40; }
inline void set_U3CWaitingToProceedU3Ek__BackingField_40(bool value)
{
___U3CWaitingToProceedU3Ek__BackingField_40 = value;
}
inline static int32_t get_offset_of_U3CSourceIdU3Ek__BackingField_41() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3CSourceIdU3Ek__BackingField_41)); }
inline uint32_t get_U3CSourceIdU3Ek__BackingField_41() const { return ___U3CSourceIdU3Ek__BackingField_41; }
inline uint32_t* get_address_of_U3CSourceIdU3Ek__BackingField_41() { return &___U3CSourceIdU3Ek__BackingField_41; }
inline void set_U3CSourceIdU3Ek__BackingField_41(uint32_t value)
{
___U3CSourceIdU3Ek__BackingField_41 = value;
}
inline static int32_t get_offset_of_U3CSourceNameU3Ek__BackingField_42() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00, ___U3CSourceNameU3Ek__BackingField_42)); }
inline String_t* get_U3CSourceNameU3Ek__BackingField_42() const { return ___U3CSourceNameU3Ek__BackingField_42; }
inline String_t** get_address_of_U3CSourceNameU3Ek__BackingField_42() { return &___U3CSourceNameU3Ek__BackingField_42; }
inline void set_U3CSourceNameU3Ek__BackingField_42(String_t* value)
{
___U3CSourceNameU3Ek__BackingField_42 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CSourceNameU3Ek__BackingField_42), (void*)value);
}
};
struct MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields
{
public:
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::UpdatePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___UpdatePerfMarker_43;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::LoadNextContentPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___LoadNextContentPerfMarker_44;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::LoadPrevContentPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___LoadPrevContentPerfMarker_45;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::LoadContentByTagPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___LoadContentByTagPerfMarker_46;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::UnloadContentByTagPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___UnloadContentByTagPerfMarker_47;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::LoadContentPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___LoadContentPerfMarker_48;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::UnloadContentPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___UnloadContentPerfMarker_49;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::IsContentLoadedPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___IsContentLoadedPerfMarker_50;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::SetLightingScenePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___SetLightingScenePerfMarker_51;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::SetManagerScenePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___SetManagerScenePerfMarker_52;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::LoadScenesInternalPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___LoadScenesInternalPerfMarker_53;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::UnloadScenesInternalPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___UnloadScenesInternalPerfMarker_54;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::InvokeLoadedActionsPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___InvokeLoadedActionsPerfMarker_55;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::InvokeWillLoadActionsPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___InvokeWillLoadActionsPerfMarker_56;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::InvokeWillUnloadActionsPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___InvokeWillUnloadActionsPerfMarker_57;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::InvokeUnloadedActionsPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___InvokeUnloadedActionsPerfMarker_58;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::GetScenePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetScenePerfMarker_59;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem::GetLoadedContentScenesPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetLoadedContentScenesPerfMarker_60;
public:
inline static int32_t get_offset_of_UpdatePerfMarker_43() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___UpdatePerfMarker_43)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_UpdatePerfMarker_43() const { return ___UpdatePerfMarker_43; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_UpdatePerfMarker_43() { return &___UpdatePerfMarker_43; }
inline void set_UpdatePerfMarker_43(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___UpdatePerfMarker_43 = value;
}
inline static int32_t get_offset_of_LoadNextContentPerfMarker_44() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___LoadNextContentPerfMarker_44)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_LoadNextContentPerfMarker_44() const { return ___LoadNextContentPerfMarker_44; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_LoadNextContentPerfMarker_44() { return &___LoadNextContentPerfMarker_44; }
inline void set_LoadNextContentPerfMarker_44(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___LoadNextContentPerfMarker_44 = value;
}
inline static int32_t get_offset_of_LoadPrevContentPerfMarker_45() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___LoadPrevContentPerfMarker_45)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_LoadPrevContentPerfMarker_45() const { return ___LoadPrevContentPerfMarker_45; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_LoadPrevContentPerfMarker_45() { return &___LoadPrevContentPerfMarker_45; }
inline void set_LoadPrevContentPerfMarker_45(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___LoadPrevContentPerfMarker_45 = value;
}
inline static int32_t get_offset_of_LoadContentByTagPerfMarker_46() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___LoadContentByTagPerfMarker_46)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_LoadContentByTagPerfMarker_46() const { return ___LoadContentByTagPerfMarker_46; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_LoadContentByTagPerfMarker_46() { return &___LoadContentByTagPerfMarker_46; }
inline void set_LoadContentByTagPerfMarker_46(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___LoadContentByTagPerfMarker_46 = value;
}
inline static int32_t get_offset_of_UnloadContentByTagPerfMarker_47() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___UnloadContentByTagPerfMarker_47)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_UnloadContentByTagPerfMarker_47() const { return ___UnloadContentByTagPerfMarker_47; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_UnloadContentByTagPerfMarker_47() { return &___UnloadContentByTagPerfMarker_47; }
inline void set_UnloadContentByTagPerfMarker_47(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___UnloadContentByTagPerfMarker_47 = value;
}
inline static int32_t get_offset_of_LoadContentPerfMarker_48() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___LoadContentPerfMarker_48)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_LoadContentPerfMarker_48() const { return ___LoadContentPerfMarker_48; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_LoadContentPerfMarker_48() { return &___LoadContentPerfMarker_48; }
inline void set_LoadContentPerfMarker_48(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___LoadContentPerfMarker_48 = value;
}
inline static int32_t get_offset_of_UnloadContentPerfMarker_49() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___UnloadContentPerfMarker_49)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_UnloadContentPerfMarker_49() const { return ___UnloadContentPerfMarker_49; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_UnloadContentPerfMarker_49() { return &___UnloadContentPerfMarker_49; }
inline void set_UnloadContentPerfMarker_49(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___UnloadContentPerfMarker_49 = value;
}
inline static int32_t get_offset_of_IsContentLoadedPerfMarker_50() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___IsContentLoadedPerfMarker_50)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_IsContentLoadedPerfMarker_50() const { return ___IsContentLoadedPerfMarker_50; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_IsContentLoadedPerfMarker_50() { return &___IsContentLoadedPerfMarker_50; }
inline void set_IsContentLoadedPerfMarker_50(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___IsContentLoadedPerfMarker_50 = value;
}
inline static int32_t get_offset_of_SetLightingScenePerfMarker_51() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___SetLightingScenePerfMarker_51)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_SetLightingScenePerfMarker_51() const { return ___SetLightingScenePerfMarker_51; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_SetLightingScenePerfMarker_51() { return &___SetLightingScenePerfMarker_51; }
inline void set_SetLightingScenePerfMarker_51(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___SetLightingScenePerfMarker_51 = value;
}
inline static int32_t get_offset_of_SetManagerScenePerfMarker_52() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___SetManagerScenePerfMarker_52)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_SetManagerScenePerfMarker_52() const { return ___SetManagerScenePerfMarker_52; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_SetManagerScenePerfMarker_52() { return &___SetManagerScenePerfMarker_52; }
inline void set_SetManagerScenePerfMarker_52(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___SetManagerScenePerfMarker_52 = value;
}
inline static int32_t get_offset_of_LoadScenesInternalPerfMarker_53() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___LoadScenesInternalPerfMarker_53)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_LoadScenesInternalPerfMarker_53() const { return ___LoadScenesInternalPerfMarker_53; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_LoadScenesInternalPerfMarker_53() { return &___LoadScenesInternalPerfMarker_53; }
inline void set_LoadScenesInternalPerfMarker_53(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___LoadScenesInternalPerfMarker_53 = value;
}
inline static int32_t get_offset_of_UnloadScenesInternalPerfMarker_54() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___UnloadScenesInternalPerfMarker_54)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_UnloadScenesInternalPerfMarker_54() const { return ___UnloadScenesInternalPerfMarker_54; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_UnloadScenesInternalPerfMarker_54() { return &___UnloadScenesInternalPerfMarker_54; }
inline void set_UnloadScenesInternalPerfMarker_54(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___UnloadScenesInternalPerfMarker_54 = value;
}
inline static int32_t get_offset_of_InvokeLoadedActionsPerfMarker_55() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___InvokeLoadedActionsPerfMarker_55)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_InvokeLoadedActionsPerfMarker_55() const { return ___InvokeLoadedActionsPerfMarker_55; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_InvokeLoadedActionsPerfMarker_55() { return &___InvokeLoadedActionsPerfMarker_55; }
inline void set_InvokeLoadedActionsPerfMarker_55(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___InvokeLoadedActionsPerfMarker_55 = value;
}
inline static int32_t get_offset_of_InvokeWillLoadActionsPerfMarker_56() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___InvokeWillLoadActionsPerfMarker_56)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_InvokeWillLoadActionsPerfMarker_56() const { return ___InvokeWillLoadActionsPerfMarker_56; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_InvokeWillLoadActionsPerfMarker_56() { return &___InvokeWillLoadActionsPerfMarker_56; }
inline void set_InvokeWillLoadActionsPerfMarker_56(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___InvokeWillLoadActionsPerfMarker_56 = value;
}
inline static int32_t get_offset_of_InvokeWillUnloadActionsPerfMarker_57() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___InvokeWillUnloadActionsPerfMarker_57)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_InvokeWillUnloadActionsPerfMarker_57() const { return ___InvokeWillUnloadActionsPerfMarker_57; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_InvokeWillUnloadActionsPerfMarker_57() { return &___InvokeWillUnloadActionsPerfMarker_57; }
inline void set_InvokeWillUnloadActionsPerfMarker_57(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___InvokeWillUnloadActionsPerfMarker_57 = value;
}
inline static int32_t get_offset_of_InvokeUnloadedActionsPerfMarker_58() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___InvokeUnloadedActionsPerfMarker_58)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_InvokeUnloadedActionsPerfMarker_58() const { return ___InvokeUnloadedActionsPerfMarker_58; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_InvokeUnloadedActionsPerfMarker_58() { return &___InvokeUnloadedActionsPerfMarker_58; }
inline void set_InvokeUnloadedActionsPerfMarker_58(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___InvokeUnloadedActionsPerfMarker_58 = value;
}
inline static int32_t get_offset_of_GetScenePerfMarker_59() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___GetScenePerfMarker_59)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetScenePerfMarker_59() const { return ___GetScenePerfMarker_59; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetScenePerfMarker_59() { return &___GetScenePerfMarker_59; }
inline void set_GetScenePerfMarker_59(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetScenePerfMarker_59 = value;
}
inline static int32_t get_offset_of_GetLoadedContentScenesPerfMarker_60() { return static_cast<int32_t>(offsetof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_StaticFields, ___GetLoadedContentScenesPerfMarker_60)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetLoadedContentScenesPerfMarker_60() const { return ___GetLoadedContentScenesPerfMarker_60; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetLoadedContentScenesPerfMarker_60() { return &___GetLoadedContentScenesPerfMarker_60; }
inline void set_GetLoadedContentScenesPerfMarker_60(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetLoadedContentScenesPerfMarker_60 = value;
}
};
// Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem
struct MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4 : public BaseCoreSystem_tD60FB642C7AFAB28F3D023BEDD98D52A0ED105D1
{
public:
// Microsoft.MixedReality.Toolkit.Teleport.TeleportEventData Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::teleportEventData
TeleportEventData_tD38237F467954AFE4C5D13E66D5BFBAB826AAAC2 * ___teleportEventData_17;
// System.Boolean Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::isTeleporting
bool ___isTeleporting_18;
// System.Boolean Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::isProcessingTeleportRequest
bool ___isProcessingTeleportRequest_19;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::targetPosition
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___targetPosition_20;
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::targetRotation
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___targetRotation_21;
// UnityEngine.GameObject Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::eventSystemReference
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___eventSystemReference_22;
// System.String Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::<Name>k__BackingField
String_t* ___U3CNameU3Ek__BackingField_23;
// System.Single Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::teleportDuration
float ___teleportDuration_25;
public:
inline static int32_t get_offset_of_teleportEventData_17() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4, ___teleportEventData_17)); }
inline TeleportEventData_tD38237F467954AFE4C5D13E66D5BFBAB826AAAC2 * get_teleportEventData_17() const { return ___teleportEventData_17; }
inline TeleportEventData_tD38237F467954AFE4C5D13E66D5BFBAB826AAAC2 ** get_address_of_teleportEventData_17() { return &___teleportEventData_17; }
inline void set_teleportEventData_17(TeleportEventData_tD38237F467954AFE4C5D13E66D5BFBAB826AAAC2 * value)
{
___teleportEventData_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___teleportEventData_17), (void*)value);
}
inline static int32_t get_offset_of_isTeleporting_18() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4, ___isTeleporting_18)); }
inline bool get_isTeleporting_18() const { return ___isTeleporting_18; }
inline bool* get_address_of_isTeleporting_18() { return &___isTeleporting_18; }
inline void set_isTeleporting_18(bool value)
{
___isTeleporting_18 = value;
}
inline static int32_t get_offset_of_isProcessingTeleportRequest_19() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4, ___isProcessingTeleportRequest_19)); }
inline bool get_isProcessingTeleportRequest_19() const { return ___isProcessingTeleportRequest_19; }
inline bool* get_address_of_isProcessingTeleportRequest_19() { return &___isProcessingTeleportRequest_19; }
inline void set_isProcessingTeleportRequest_19(bool value)
{
___isProcessingTeleportRequest_19 = value;
}
inline static int32_t get_offset_of_targetPosition_20() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4, ___targetPosition_20)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_targetPosition_20() const { return ___targetPosition_20; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_targetPosition_20() { return &___targetPosition_20; }
inline void set_targetPosition_20(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___targetPosition_20 = value;
}
inline static int32_t get_offset_of_targetRotation_21() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4, ___targetRotation_21)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_targetRotation_21() const { return ___targetRotation_21; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_targetRotation_21() { return &___targetRotation_21; }
inline void set_targetRotation_21(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___targetRotation_21 = value;
}
inline static int32_t get_offset_of_eventSystemReference_22() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4, ___eventSystemReference_22)); }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * get_eventSystemReference_22() const { return ___eventSystemReference_22; }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 ** get_address_of_eventSystemReference_22() { return &___eventSystemReference_22; }
inline void set_eventSystemReference_22(GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * value)
{
___eventSystemReference_22 = value;
Il2CppCodeGenWriteBarrier((void**)(&___eventSystemReference_22), (void*)value);
}
inline static int32_t get_offset_of_U3CNameU3Ek__BackingField_23() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4, ___U3CNameU3Ek__BackingField_23)); }
inline String_t* get_U3CNameU3Ek__BackingField_23() const { return ___U3CNameU3Ek__BackingField_23; }
inline String_t** get_address_of_U3CNameU3Ek__BackingField_23() { return &___U3CNameU3Ek__BackingField_23; }
inline void set_U3CNameU3Ek__BackingField_23(String_t* value)
{
___U3CNameU3Ek__BackingField_23 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CNameU3Ek__BackingField_23), (void*)value);
}
inline static int32_t get_offset_of_teleportDuration_25() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4, ___teleportDuration_25)); }
inline float get_teleportDuration_25() const { return ___teleportDuration_25; }
inline float* get_address_of_teleportDuration_25() { return &___teleportDuration_25; }
inline void set_teleportDuration_25(float value)
{
___teleportDuration_25 = value;
}
};
struct MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields
{
public:
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::HandleEventPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___HandleEventPerfMarker_24;
// UnityEngine.EventSystems.ExecuteEvents/EventFunction`1<Microsoft.MixedReality.Toolkit.Teleport.IMixedRealityTeleportHandler> Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::OnTeleportRequestHandler
EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * ___OnTeleportRequestHandler_26;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::RaiseTeleportRequestPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___RaiseTeleportRequestPerfMarker_27;
// UnityEngine.EventSystems.ExecuteEvents/EventFunction`1<Microsoft.MixedReality.Toolkit.Teleport.IMixedRealityTeleportHandler> Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::OnTeleportStartedHandler
EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * ___OnTeleportStartedHandler_28;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::RaiseTeleportStartedPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___RaiseTeleportStartedPerfMarker_29;
// UnityEngine.EventSystems.ExecuteEvents/EventFunction`1<Microsoft.MixedReality.Toolkit.Teleport.IMixedRealityTeleportHandler> Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::OnTeleportCompletedHandler
EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * ___OnTeleportCompletedHandler_30;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::RaiseTeleportCompletePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___RaiseTeleportCompletePerfMarker_31;
// UnityEngine.EventSystems.ExecuteEvents/EventFunction`1<Microsoft.MixedReality.Toolkit.Teleport.IMixedRealityTeleportHandler> Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::OnTeleportCanceledHandler
EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * ___OnTeleportCanceledHandler_32;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::RaiseTeleportCanceledPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___RaiseTeleportCanceledPerfMarker_33;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem::ProcessTeleportationRequestPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___ProcessTeleportationRequestPerfMarker_34;
public:
inline static int32_t get_offset_of_HandleEventPerfMarker_24() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___HandleEventPerfMarker_24)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_HandleEventPerfMarker_24() const { return ___HandleEventPerfMarker_24; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_HandleEventPerfMarker_24() { return &___HandleEventPerfMarker_24; }
inline void set_HandleEventPerfMarker_24(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___HandleEventPerfMarker_24 = value;
}
inline static int32_t get_offset_of_OnTeleportRequestHandler_26() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___OnTeleportRequestHandler_26)); }
inline EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * get_OnTeleportRequestHandler_26() const { return ___OnTeleportRequestHandler_26; }
inline EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 ** get_address_of_OnTeleportRequestHandler_26() { return &___OnTeleportRequestHandler_26; }
inline void set_OnTeleportRequestHandler_26(EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * value)
{
___OnTeleportRequestHandler_26 = value;
Il2CppCodeGenWriteBarrier((void**)(&___OnTeleportRequestHandler_26), (void*)value);
}
inline static int32_t get_offset_of_RaiseTeleportRequestPerfMarker_27() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___RaiseTeleportRequestPerfMarker_27)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_RaiseTeleportRequestPerfMarker_27() const { return ___RaiseTeleportRequestPerfMarker_27; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_RaiseTeleportRequestPerfMarker_27() { return &___RaiseTeleportRequestPerfMarker_27; }
inline void set_RaiseTeleportRequestPerfMarker_27(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___RaiseTeleportRequestPerfMarker_27 = value;
}
inline static int32_t get_offset_of_OnTeleportStartedHandler_28() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___OnTeleportStartedHandler_28)); }
inline EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * get_OnTeleportStartedHandler_28() const { return ___OnTeleportStartedHandler_28; }
inline EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 ** get_address_of_OnTeleportStartedHandler_28() { return &___OnTeleportStartedHandler_28; }
inline void set_OnTeleportStartedHandler_28(EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * value)
{
___OnTeleportStartedHandler_28 = value;
Il2CppCodeGenWriteBarrier((void**)(&___OnTeleportStartedHandler_28), (void*)value);
}
inline static int32_t get_offset_of_RaiseTeleportStartedPerfMarker_29() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___RaiseTeleportStartedPerfMarker_29)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_RaiseTeleportStartedPerfMarker_29() const { return ___RaiseTeleportStartedPerfMarker_29; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_RaiseTeleportStartedPerfMarker_29() { return &___RaiseTeleportStartedPerfMarker_29; }
inline void set_RaiseTeleportStartedPerfMarker_29(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___RaiseTeleportStartedPerfMarker_29 = value;
}
inline static int32_t get_offset_of_OnTeleportCompletedHandler_30() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___OnTeleportCompletedHandler_30)); }
inline EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * get_OnTeleportCompletedHandler_30() const { return ___OnTeleportCompletedHandler_30; }
inline EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 ** get_address_of_OnTeleportCompletedHandler_30() { return &___OnTeleportCompletedHandler_30; }
inline void set_OnTeleportCompletedHandler_30(EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * value)
{
___OnTeleportCompletedHandler_30 = value;
Il2CppCodeGenWriteBarrier((void**)(&___OnTeleportCompletedHandler_30), (void*)value);
}
inline static int32_t get_offset_of_RaiseTeleportCompletePerfMarker_31() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___RaiseTeleportCompletePerfMarker_31)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_RaiseTeleportCompletePerfMarker_31() const { return ___RaiseTeleportCompletePerfMarker_31; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_RaiseTeleportCompletePerfMarker_31() { return &___RaiseTeleportCompletePerfMarker_31; }
inline void set_RaiseTeleportCompletePerfMarker_31(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___RaiseTeleportCompletePerfMarker_31 = value;
}
inline static int32_t get_offset_of_OnTeleportCanceledHandler_32() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___OnTeleportCanceledHandler_32)); }
inline EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * get_OnTeleportCanceledHandler_32() const { return ___OnTeleportCanceledHandler_32; }
inline EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 ** get_address_of_OnTeleportCanceledHandler_32() { return &___OnTeleportCanceledHandler_32; }
inline void set_OnTeleportCanceledHandler_32(EventFunction_1_t2079745996CCF03481820B14D7A046C05D966246 * value)
{
___OnTeleportCanceledHandler_32 = value;
Il2CppCodeGenWriteBarrier((void**)(&___OnTeleportCanceledHandler_32), (void*)value);
}
inline static int32_t get_offset_of_RaiseTeleportCanceledPerfMarker_33() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___RaiseTeleportCanceledPerfMarker_33)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_RaiseTeleportCanceledPerfMarker_33() const { return ___RaiseTeleportCanceledPerfMarker_33; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_RaiseTeleportCanceledPerfMarker_33() { return &___RaiseTeleportCanceledPerfMarker_33; }
inline void set_RaiseTeleportCanceledPerfMarker_33(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___RaiseTeleportCanceledPerfMarker_33 = value;
}
inline static int32_t get_offset_of_ProcessTeleportationRequestPerfMarker_34() { return static_cast<int32_t>(offsetof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_StaticFields, ___ProcessTeleportationRequestPerfMarker_34)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_ProcessTeleportationRequestPerfMarker_34() const { return ___ProcessTeleportationRequestPerfMarker_34; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_ProcessTeleportationRequestPerfMarker_34() { return &___ProcessTeleportationRequestPerfMarker_34; }
inline void set_ProcessTeleportationRequestPerfMarker_34(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___ProcessTeleportationRequestPerfMarker_34 = value;
}
};
// Microsoft.MixedReality.Toolkit.Input.UnityInput.MouseDeviceManager
struct MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C : public BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB
{
public:
// System.Single Microsoft.MixedReality.Toolkit.Input.UnityInput.MouseDeviceManager::cursorSpeed
float ___cursorSpeed_19;
// System.Single Microsoft.MixedReality.Toolkit.Input.UnityInput.MouseDeviceManager::wheelSpeed
float ___wheelSpeed_20;
// Microsoft.MixedReality.Toolkit.Input.UnityInput.MouseController Microsoft.MixedReality.Toolkit.Input.UnityInput.MouseDeviceManager::<Controller>k__BackingField
MouseController_t3A7451F1C270293BDDED7C6012F92C6023F21E0C * ___U3CControllerU3Ek__BackingField_21;
public:
inline static int32_t get_offset_of_cursorSpeed_19() { return static_cast<int32_t>(offsetof(MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C, ___cursorSpeed_19)); }
inline float get_cursorSpeed_19() const { return ___cursorSpeed_19; }
inline float* get_address_of_cursorSpeed_19() { return &___cursorSpeed_19; }
inline void set_cursorSpeed_19(float value)
{
___cursorSpeed_19 = value;
}
inline static int32_t get_offset_of_wheelSpeed_20() { return static_cast<int32_t>(offsetof(MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C, ___wheelSpeed_20)); }
inline float get_wheelSpeed_20() const { return ___wheelSpeed_20; }
inline float* get_address_of_wheelSpeed_20() { return &___wheelSpeed_20; }
inline void set_wheelSpeed_20(float value)
{
___wheelSpeed_20 = value;
}
inline static int32_t get_offset_of_U3CControllerU3Ek__BackingField_21() { return static_cast<int32_t>(offsetof(MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C, ___U3CControllerU3Ek__BackingField_21)); }
inline MouseController_t3A7451F1C270293BDDED7C6012F92C6023F21E0C * get_U3CControllerU3Ek__BackingField_21() const { return ___U3CControllerU3Ek__BackingField_21; }
inline MouseController_t3A7451F1C270293BDDED7C6012F92C6023F21E0C ** get_address_of_U3CControllerU3Ek__BackingField_21() { return &___U3CControllerU3Ek__BackingField_21; }
inline void set_U3CControllerU3Ek__BackingField_21(MouseController_t3A7451F1C270293BDDED7C6012F92C6023F21E0C * value)
{
___U3CControllerU3Ek__BackingField_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CControllerU3Ek__BackingField_21), (void*)value);
}
};
struct MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C_StaticFields
{
public:
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.Input.UnityInput.MouseDeviceManager::UpdatePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___UpdatePerfMarker_22;
public:
inline static int32_t get_offset_of_UpdatePerfMarker_22() { return static_cast<int32_t>(offsetof(MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C_StaticFields, ___UpdatePerfMarker_22)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_UpdatePerfMarker_22() const { return ___UpdatePerfMarker_22; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_UpdatePerfMarker_22() { return &___UpdatePerfMarker_22; }
inline void set_UpdatePerfMarker_22(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___UpdatePerfMarker_22 = value;
}
};
// Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider
struct OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85 : public BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB
{
public:
// System.Boolean Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::<SmoothEyeTracking>k__BackingField
bool ___U3CSmoothEyeTrackingU3Ek__BackingField_17;
// System.Action Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::OnSaccade
Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 * ___OnSaccade_18;
// System.Action Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::OnSaccadeX
Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 * ___OnSaccadeX_19;
// System.Action Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::OnSaccadeY
Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 * ___OnSaccadeY_20;
// System.Single Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::smoothFactorNormalized
float ___smoothFactorNormalized_21;
// System.Single Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::saccadeThreshInDegree
float ___saccadeThreshInDegree_22;
// System.Nullable`1<UnityEngine.Ray> Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::oldGaze
Nullable_1_tCE70D5232DA58B57AD93CA774181BD1FAA49A963 ___oldGaze_23;
// System.Int32 Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::confidenceOfSaccade
int32_t ___confidenceOfSaccade_24;
// System.Int32 Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::confidenceOfSaccadeThreshold
int32_t ___confidenceOfSaccadeThreshold_25;
// UnityEngine.Ray Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::saccade_initialGazePoint
Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 ___saccade_initialGazePoint_26;
// System.Collections.Generic.List`1<UnityEngine.Ray> Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::saccade_newGazeCluster
List_1_tDBBF8003D7BAC756EE5262C1DF03096EB730DF2B * ___saccade_newGazeCluster_27;
// UnityEngine.XR.InputDevice Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::eyeTrackingDevice
InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E ___eyeTrackingDevice_29;
public:
inline static int32_t get_offset_of_U3CSmoothEyeTrackingU3Ek__BackingField_17() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___U3CSmoothEyeTrackingU3Ek__BackingField_17)); }
inline bool get_U3CSmoothEyeTrackingU3Ek__BackingField_17() const { return ___U3CSmoothEyeTrackingU3Ek__BackingField_17; }
inline bool* get_address_of_U3CSmoothEyeTrackingU3Ek__BackingField_17() { return &___U3CSmoothEyeTrackingU3Ek__BackingField_17; }
inline void set_U3CSmoothEyeTrackingU3Ek__BackingField_17(bool value)
{
___U3CSmoothEyeTrackingU3Ek__BackingField_17 = value;
}
inline static int32_t get_offset_of_OnSaccade_18() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___OnSaccade_18)); }
inline Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 * get_OnSaccade_18() const { return ___OnSaccade_18; }
inline Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 ** get_address_of_OnSaccade_18() { return &___OnSaccade_18; }
inline void set_OnSaccade_18(Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 * value)
{
___OnSaccade_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___OnSaccade_18), (void*)value);
}
inline static int32_t get_offset_of_OnSaccadeX_19() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___OnSaccadeX_19)); }
inline Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 * get_OnSaccadeX_19() const { return ___OnSaccadeX_19; }
inline Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 ** get_address_of_OnSaccadeX_19() { return &___OnSaccadeX_19; }
inline void set_OnSaccadeX_19(Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 * value)
{
___OnSaccadeX_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___OnSaccadeX_19), (void*)value);
}
inline static int32_t get_offset_of_OnSaccadeY_20() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___OnSaccadeY_20)); }
inline Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 * get_OnSaccadeY_20() const { return ___OnSaccadeY_20; }
inline Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 ** get_address_of_OnSaccadeY_20() { return &___OnSaccadeY_20; }
inline void set_OnSaccadeY_20(Action_tAF41423D285AE0862865348CF6CE51CD085ABBA6 * value)
{
___OnSaccadeY_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___OnSaccadeY_20), (void*)value);
}
inline static int32_t get_offset_of_smoothFactorNormalized_21() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___smoothFactorNormalized_21)); }
inline float get_smoothFactorNormalized_21() const { return ___smoothFactorNormalized_21; }
inline float* get_address_of_smoothFactorNormalized_21() { return &___smoothFactorNormalized_21; }
inline void set_smoothFactorNormalized_21(float value)
{
___smoothFactorNormalized_21 = value;
}
inline static int32_t get_offset_of_saccadeThreshInDegree_22() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___saccadeThreshInDegree_22)); }
inline float get_saccadeThreshInDegree_22() const { return ___saccadeThreshInDegree_22; }
inline float* get_address_of_saccadeThreshInDegree_22() { return &___saccadeThreshInDegree_22; }
inline void set_saccadeThreshInDegree_22(float value)
{
___saccadeThreshInDegree_22 = value;
}
inline static int32_t get_offset_of_oldGaze_23() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___oldGaze_23)); }
inline Nullable_1_tCE70D5232DA58B57AD93CA774181BD1FAA49A963 get_oldGaze_23() const { return ___oldGaze_23; }
inline Nullable_1_tCE70D5232DA58B57AD93CA774181BD1FAA49A963 * get_address_of_oldGaze_23() { return &___oldGaze_23; }
inline void set_oldGaze_23(Nullable_1_tCE70D5232DA58B57AD93CA774181BD1FAA49A963 value)
{
___oldGaze_23 = value;
}
inline static int32_t get_offset_of_confidenceOfSaccade_24() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___confidenceOfSaccade_24)); }
inline int32_t get_confidenceOfSaccade_24() const { return ___confidenceOfSaccade_24; }
inline int32_t* get_address_of_confidenceOfSaccade_24() { return &___confidenceOfSaccade_24; }
inline void set_confidenceOfSaccade_24(int32_t value)
{
___confidenceOfSaccade_24 = value;
}
inline static int32_t get_offset_of_confidenceOfSaccadeThreshold_25() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___confidenceOfSaccadeThreshold_25)); }
inline int32_t get_confidenceOfSaccadeThreshold_25() const { return ___confidenceOfSaccadeThreshold_25; }
inline int32_t* get_address_of_confidenceOfSaccadeThreshold_25() { return &___confidenceOfSaccadeThreshold_25; }
inline void set_confidenceOfSaccadeThreshold_25(int32_t value)
{
___confidenceOfSaccadeThreshold_25 = value;
}
inline static int32_t get_offset_of_saccade_initialGazePoint_26() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___saccade_initialGazePoint_26)); }
inline Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 get_saccade_initialGazePoint_26() const { return ___saccade_initialGazePoint_26; }
inline Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 * get_address_of_saccade_initialGazePoint_26() { return &___saccade_initialGazePoint_26; }
inline void set_saccade_initialGazePoint_26(Ray_t2E9E67CC8B03EE6ED2BBF3D2C9C96DDF70E1D5E6 value)
{
___saccade_initialGazePoint_26 = value;
}
inline static int32_t get_offset_of_saccade_newGazeCluster_27() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___saccade_newGazeCluster_27)); }
inline List_1_tDBBF8003D7BAC756EE5262C1DF03096EB730DF2B * get_saccade_newGazeCluster_27() const { return ___saccade_newGazeCluster_27; }
inline List_1_tDBBF8003D7BAC756EE5262C1DF03096EB730DF2B ** get_address_of_saccade_newGazeCluster_27() { return &___saccade_newGazeCluster_27; }
inline void set_saccade_newGazeCluster_27(List_1_tDBBF8003D7BAC756EE5262C1DF03096EB730DF2B * value)
{
___saccade_newGazeCluster_27 = value;
Il2CppCodeGenWriteBarrier((void**)(&___saccade_newGazeCluster_27), (void*)value);
}
inline static int32_t get_offset_of_eyeTrackingDevice_29() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85, ___eyeTrackingDevice_29)); }
inline InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E get_eyeTrackingDevice_29() const { return ___eyeTrackingDevice_29; }
inline InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E * get_address_of_eyeTrackingDevice_29() { return &___eyeTrackingDevice_29; }
inline void set_eyeTrackingDevice_29(InputDevice_t69B790C68145C769BA3819DE33AA94155C77207E value)
{
___eyeTrackingDevice_29 = value;
}
};
struct OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_StaticFields
{
public:
// System.Collections.Generic.List`1<UnityEngine.XR.InputDevice> Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::InputDeviceList
List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * ___InputDeviceList_28;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::UpdatePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___UpdatePerfMarker_30;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::SmoothGazePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___SmoothGazePerfMarker_31;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider::IsSaccadingPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___IsSaccadingPerfMarker_32;
public:
inline static int32_t get_offset_of_InputDeviceList_28() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_StaticFields, ___InputDeviceList_28)); }
inline List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * get_InputDeviceList_28() const { return ___InputDeviceList_28; }
inline List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F ** get_address_of_InputDeviceList_28() { return &___InputDeviceList_28; }
inline void set_InputDeviceList_28(List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * value)
{
___InputDeviceList_28 = value;
Il2CppCodeGenWriteBarrier((void**)(&___InputDeviceList_28), (void*)value);
}
inline static int32_t get_offset_of_UpdatePerfMarker_30() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_StaticFields, ___UpdatePerfMarker_30)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_UpdatePerfMarker_30() const { return ___UpdatePerfMarker_30; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_UpdatePerfMarker_30() { return &___UpdatePerfMarker_30; }
inline void set_UpdatePerfMarker_30(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___UpdatePerfMarker_30 = value;
}
inline static int32_t get_offset_of_SmoothGazePerfMarker_31() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_StaticFields, ___SmoothGazePerfMarker_31)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_SmoothGazePerfMarker_31() const { return ___SmoothGazePerfMarker_31; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_SmoothGazePerfMarker_31() { return &___SmoothGazePerfMarker_31; }
inline void set_SmoothGazePerfMarker_31(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___SmoothGazePerfMarker_31 = value;
}
inline static int32_t get_offset_of_IsSaccadingPerfMarker_32() { return static_cast<int32_t>(offsetof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_StaticFields, ___IsSaccadingPerfMarker_32)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_IsSaccadingPerfMarker_32() const { return ___IsSaccadingPerfMarker_32; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_IsSaccadingPerfMarker_32() { return &___IsSaccadingPerfMarker_32; }
inline void set_IsSaccadingPerfMarker_32(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___IsSaccadingPerfMarker_32 = value;
}
};
// UnityEngine.RectTransform
struct RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 : public Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1
{
public:
public:
};
struct RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_StaticFields
{
public:
// UnityEngine.RectTransform/ReapplyDrivenProperties UnityEngine.RectTransform::reapplyDrivenProperties
ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * ___reapplyDrivenProperties_4;
public:
inline static int32_t get_offset_of_reapplyDrivenProperties_4() { return static_cast<int32_t>(offsetof(RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_StaticFields, ___reapplyDrivenProperties_4)); }
inline ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * get_reapplyDrivenProperties_4() const { return ___reapplyDrivenProperties_4; }
inline ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE ** get_address_of_reapplyDrivenProperties_4() { return &___reapplyDrivenProperties_4; }
inline void set_reapplyDrivenProperties_4(ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * value)
{
___reapplyDrivenProperties_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___reapplyDrivenProperties_4), (void*)value);
}
};
// Microsoft.MixedReality.Toolkit.XRSDK.Input.XRSDKDeviceManager
struct XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719 : public BaseInputDeviceManager_t6A4D499FDBD693F4F9D789864B32292DB36568FB
{
public:
// System.Collections.Generic.List`1<UnityEngine.XR.InputDevice> Microsoft.MixedReality.Toolkit.XRSDK.Input.XRSDKDeviceManager::inputDevices
List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * ___inputDevices_18;
// System.Collections.Generic.List`1<UnityEngine.XR.InputDevice> Microsoft.MixedReality.Toolkit.XRSDK.Input.XRSDKDeviceManager::inputDevicesSubset
List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * ___inputDevicesSubset_19;
// System.Collections.Generic.List`1<UnityEngine.XR.InputDevice> Microsoft.MixedReality.Toolkit.XRSDK.Input.XRSDKDeviceManager::lastInputDevices
List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * ___lastInputDevices_20;
// System.Collections.Generic.List`1<UnityEngine.XR.InputDeviceCharacteristics> Microsoft.MixedReality.Toolkit.XRSDK.Input.XRSDKDeviceManager::<DesiredInputCharacteristics>k__BackingField
List_1_tD812850D83CCFFD34E9A310E2AE62B198E513F2C * ___U3CDesiredInputCharacteristicsU3Ek__BackingField_21;
public:
inline static int32_t get_offset_of_inputDevices_18() { return static_cast<int32_t>(offsetof(XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719, ___inputDevices_18)); }
inline List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * get_inputDevices_18() const { return ___inputDevices_18; }
inline List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F ** get_address_of_inputDevices_18() { return &___inputDevices_18; }
inline void set_inputDevices_18(List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * value)
{
___inputDevices_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___inputDevices_18), (void*)value);
}
inline static int32_t get_offset_of_inputDevicesSubset_19() { return static_cast<int32_t>(offsetof(XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719, ___inputDevicesSubset_19)); }
inline List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * get_inputDevicesSubset_19() const { return ___inputDevicesSubset_19; }
inline List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F ** get_address_of_inputDevicesSubset_19() { return &___inputDevicesSubset_19; }
inline void set_inputDevicesSubset_19(List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * value)
{
___inputDevicesSubset_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___inputDevicesSubset_19), (void*)value);
}
inline static int32_t get_offset_of_lastInputDevices_20() { return static_cast<int32_t>(offsetof(XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719, ___lastInputDevices_20)); }
inline List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * get_lastInputDevices_20() const { return ___lastInputDevices_20; }
inline List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F ** get_address_of_lastInputDevices_20() { return &___lastInputDevices_20; }
inline void set_lastInputDevices_20(List_1_t476C8CC2E74FC5F7DE5B5CFE6830822665402F1F * value)
{
___lastInputDevices_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___lastInputDevices_20), (void*)value);
}
inline static int32_t get_offset_of_U3CDesiredInputCharacteristicsU3Ek__BackingField_21() { return static_cast<int32_t>(offsetof(XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719, ___U3CDesiredInputCharacteristicsU3Ek__BackingField_21)); }
inline List_1_tD812850D83CCFFD34E9A310E2AE62B198E513F2C * get_U3CDesiredInputCharacteristicsU3Ek__BackingField_21() const { return ___U3CDesiredInputCharacteristicsU3Ek__BackingField_21; }
inline List_1_tD812850D83CCFFD34E9A310E2AE62B198E513F2C ** get_address_of_U3CDesiredInputCharacteristicsU3Ek__BackingField_21() { return &___U3CDesiredInputCharacteristicsU3Ek__BackingField_21; }
inline void set_U3CDesiredInputCharacteristicsU3Ek__BackingField_21(List_1_tD812850D83CCFFD34E9A310E2AE62B198E513F2C * value)
{
___U3CDesiredInputCharacteristicsU3Ek__BackingField_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CDesiredInputCharacteristicsU3Ek__BackingField_21), (void*)value);
}
};
struct XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719_StaticFields
{
public:
// System.Collections.Generic.Dictionary`2<UnityEngine.XR.InputDevice,Microsoft.MixedReality.Toolkit.XRSDK.Input.GenericXRSDKController> Microsoft.MixedReality.Toolkit.XRSDK.Input.XRSDKDeviceManager::ActiveControllers
Dictionary_2_t2FB6B87AE845471F5ACC7900099F9B8BFE071E0E * ___ActiveControllers_17;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.XRSDK.Input.XRSDKDeviceManager::UpdatePerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___UpdatePerfMarker_22;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.XRSDK.Input.XRSDKDeviceManager::GetOrAddControllerPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetOrAddControllerPerfMarker_23;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.XRSDK.Input.XRSDKDeviceManager::RemoveControllerPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___RemoveControllerPerfMarker_24;
public:
inline static int32_t get_offset_of_ActiveControllers_17() { return static_cast<int32_t>(offsetof(XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719_StaticFields, ___ActiveControllers_17)); }
inline Dictionary_2_t2FB6B87AE845471F5ACC7900099F9B8BFE071E0E * get_ActiveControllers_17() const { return ___ActiveControllers_17; }
inline Dictionary_2_t2FB6B87AE845471F5ACC7900099F9B8BFE071E0E ** get_address_of_ActiveControllers_17() { return &___ActiveControllers_17; }
inline void set_ActiveControllers_17(Dictionary_2_t2FB6B87AE845471F5ACC7900099F9B8BFE071E0E * value)
{
___ActiveControllers_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___ActiveControllers_17), (void*)value);
}
inline static int32_t get_offset_of_UpdatePerfMarker_22() { return static_cast<int32_t>(offsetof(XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719_StaticFields, ___UpdatePerfMarker_22)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_UpdatePerfMarker_22() const { return ___UpdatePerfMarker_22; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_UpdatePerfMarker_22() { return &___UpdatePerfMarker_22; }
inline void set_UpdatePerfMarker_22(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___UpdatePerfMarker_22 = value;
}
inline static int32_t get_offset_of_GetOrAddControllerPerfMarker_23() { return static_cast<int32_t>(offsetof(XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719_StaticFields, ___GetOrAddControllerPerfMarker_23)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetOrAddControllerPerfMarker_23() const { return ___GetOrAddControllerPerfMarker_23; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetOrAddControllerPerfMarker_23() { return &___GetOrAddControllerPerfMarker_23; }
inline void set_GetOrAddControllerPerfMarker_23(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetOrAddControllerPerfMarker_23 = value;
}
inline static int32_t get_offset_of_RemoveControllerPerfMarker_24() { return static_cast<int32_t>(offsetof(XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719_StaticFields, ___RemoveControllerPerfMarker_24)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_RemoveControllerPerfMarker_24() const { return ___RemoveControllerPerfMarker_24; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_RemoveControllerPerfMarker_24() { return &___RemoveControllerPerfMarker_24; }
inline void set_RemoveControllerPerfMarker_24(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___RemoveControllerPerfMarker_24 = value;
}
};
// Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem
struct MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90 : public BaseDataProviderAccessCoreSystem_t7A7B0A8F1AA8A4A6F16E2590B1A5125C9D6B6B47
{
public:
// System.String Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::<Name>k__BackingField
String_t* ___U3CNameU3Ek__BackingField_20;
// Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessEventData`1<Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject> Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::meshEventData
MixedRealitySpatialAwarenessEventData_1_t7ED8A8C4F13DE7DA0CDB49A53184152431B8337F * ___meshEventData_21;
// UnityEngine.GameObject Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::spatialAwarenessObjectParent
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___spatialAwarenessObjectParent_22;
// System.UInt32 Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::nextSourceId
uint32_t ___nextSourceId_23;
// Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystemProfile Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::spatialAwarenessSystemProfile
MixedRealitySpatialAwarenessSystemProfile_tFA00D9B0001845CDB1DEB2D3E3BB08CB3A553891 * ___spatialAwarenessSystemProfile_24;
public:
inline static int32_t get_offset_of_U3CNameU3Ek__BackingField_20() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90, ___U3CNameU3Ek__BackingField_20)); }
inline String_t* get_U3CNameU3Ek__BackingField_20() const { return ___U3CNameU3Ek__BackingField_20; }
inline String_t** get_address_of_U3CNameU3Ek__BackingField_20() { return &___U3CNameU3Ek__BackingField_20; }
inline void set_U3CNameU3Ek__BackingField_20(String_t* value)
{
___U3CNameU3Ek__BackingField_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CNameU3Ek__BackingField_20), (void*)value);
}
inline static int32_t get_offset_of_meshEventData_21() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90, ___meshEventData_21)); }
inline MixedRealitySpatialAwarenessEventData_1_t7ED8A8C4F13DE7DA0CDB49A53184152431B8337F * get_meshEventData_21() const { return ___meshEventData_21; }
inline MixedRealitySpatialAwarenessEventData_1_t7ED8A8C4F13DE7DA0CDB49A53184152431B8337F ** get_address_of_meshEventData_21() { return &___meshEventData_21; }
inline void set_meshEventData_21(MixedRealitySpatialAwarenessEventData_1_t7ED8A8C4F13DE7DA0CDB49A53184152431B8337F * value)
{
___meshEventData_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___meshEventData_21), (void*)value);
}
inline static int32_t get_offset_of_spatialAwarenessObjectParent_22() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90, ___spatialAwarenessObjectParent_22)); }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * get_spatialAwarenessObjectParent_22() const { return ___spatialAwarenessObjectParent_22; }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 ** get_address_of_spatialAwarenessObjectParent_22() { return &___spatialAwarenessObjectParent_22; }
inline void set_spatialAwarenessObjectParent_22(GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * value)
{
___spatialAwarenessObjectParent_22 = value;
Il2CppCodeGenWriteBarrier((void**)(&___spatialAwarenessObjectParent_22), (void*)value);
}
inline static int32_t get_offset_of_nextSourceId_23() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90, ___nextSourceId_23)); }
inline uint32_t get_nextSourceId_23() const { return ___nextSourceId_23; }
inline uint32_t* get_address_of_nextSourceId_23() { return &___nextSourceId_23; }
inline void set_nextSourceId_23(uint32_t value)
{
___nextSourceId_23 = value;
}
inline static int32_t get_offset_of_spatialAwarenessSystemProfile_24() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90, ___spatialAwarenessSystemProfile_24)); }
inline MixedRealitySpatialAwarenessSystemProfile_tFA00D9B0001845CDB1DEB2D3E3BB08CB3A553891 * get_spatialAwarenessSystemProfile_24() const { return ___spatialAwarenessSystemProfile_24; }
inline MixedRealitySpatialAwarenessSystemProfile_tFA00D9B0001845CDB1DEB2D3E3BB08CB3A553891 ** get_address_of_spatialAwarenessSystemProfile_24() { return &___spatialAwarenessSystemProfile_24; }
inline void set_spatialAwarenessSystemProfile_24(MixedRealitySpatialAwarenessSystemProfile_tFA00D9B0001845CDB1DEB2D3E3BB08CB3A553891 * value)
{
___spatialAwarenessSystemProfile_24 = value;
Il2CppCodeGenWriteBarrier((void**)(&___spatialAwarenessSystemProfile_24), (void*)value);
}
};
struct MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields
{
public:
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::GetObserversPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetObserversPerfMarker_25;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::GetObserversTPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetObserversTPerfMarker_26;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::GetObserverPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetObserverPerfMarker_27;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::GetObserverTPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetObserverTPerfMarker_28;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::GetDataProvidersPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetDataProvidersPerfMarker_29;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::GetDataProviderPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetDataProviderPerfMarker_30;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::ResumeObserversPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___ResumeObserversPerfMarker_31;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::ResumeObserversTPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___ResumeObserversTPerfMarker_32;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::ResumeObserverPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___ResumeObserverPerfMarker_33;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::SuspendObserversPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___SuspendObserversPerfMarker_34;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::SuspendObserversTPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___SuspendObserversTPerfMarker_35;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::SuspendObserverPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___SuspendObserverPerfMarker_36;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::ClearObservationsPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___ClearObservationsPerfMarker_37;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem::ClearObservationsTPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___ClearObservationsTPerfMarker_38;
public:
inline static int32_t get_offset_of_GetObserversPerfMarker_25() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___GetObserversPerfMarker_25)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetObserversPerfMarker_25() const { return ___GetObserversPerfMarker_25; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetObserversPerfMarker_25() { return &___GetObserversPerfMarker_25; }
inline void set_GetObserversPerfMarker_25(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetObserversPerfMarker_25 = value;
}
inline static int32_t get_offset_of_GetObserversTPerfMarker_26() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___GetObserversTPerfMarker_26)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetObserversTPerfMarker_26() const { return ___GetObserversTPerfMarker_26; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetObserversTPerfMarker_26() { return &___GetObserversTPerfMarker_26; }
inline void set_GetObserversTPerfMarker_26(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetObserversTPerfMarker_26 = value;
}
inline static int32_t get_offset_of_GetObserverPerfMarker_27() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___GetObserverPerfMarker_27)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetObserverPerfMarker_27() const { return ___GetObserverPerfMarker_27; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetObserverPerfMarker_27() { return &___GetObserverPerfMarker_27; }
inline void set_GetObserverPerfMarker_27(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetObserverPerfMarker_27 = value;
}
inline static int32_t get_offset_of_GetObserverTPerfMarker_28() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___GetObserverTPerfMarker_28)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetObserverTPerfMarker_28() const { return ___GetObserverTPerfMarker_28; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetObserverTPerfMarker_28() { return &___GetObserverTPerfMarker_28; }
inline void set_GetObserverTPerfMarker_28(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetObserverTPerfMarker_28 = value;
}
inline static int32_t get_offset_of_GetDataProvidersPerfMarker_29() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___GetDataProvidersPerfMarker_29)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetDataProvidersPerfMarker_29() const { return ___GetDataProvidersPerfMarker_29; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetDataProvidersPerfMarker_29() { return &___GetDataProvidersPerfMarker_29; }
inline void set_GetDataProvidersPerfMarker_29(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetDataProvidersPerfMarker_29 = value;
}
inline static int32_t get_offset_of_GetDataProviderPerfMarker_30() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___GetDataProviderPerfMarker_30)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetDataProviderPerfMarker_30() const { return ___GetDataProviderPerfMarker_30; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetDataProviderPerfMarker_30() { return &___GetDataProviderPerfMarker_30; }
inline void set_GetDataProviderPerfMarker_30(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetDataProviderPerfMarker_30 = value;
}
inline static int32_t get_offset_of_ResumeObserversPerfMarker_31() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___ResumeObserversPerfMarker_31)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_ResumeObserversPerfMarker_31() const { return ___ResumeObserversPerfMarker_31; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_ResumeObserversPerfMarker_31() { return &___ResumeObserversPerfMarker_31; }
inline void set_ResumeObserversPerfMarker_31(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___ResumeObserversPerfMarker_31 = value;
}
inline static int32_t get_offset_of_ResumeObserversTPerfMarker_32() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___ResumeObserversTPerfMarker_32)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_ResumeObserversTPerfMarker_32() const { return ___ResumeObserversTPerfMarker_32; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_ResumeObserversTPerfMarker_32() { return &___ResumeObserversTPerfMarker_32; }
inline void set_ResumeObserversTPerfMarker_32(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___ResumeObserversTPerfMarker_32 = value;
}
inline static int32_t get_offset_of_ResumeObserverPerfMarker_33() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___ResumeObserverPerfMarker_33)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_ResumeObserverPerfMarker_33() const { return ___ResumeObserverPerfMarker_33; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_ResumeObserverPerfMarker_33() { return &___ResumeObserverPerfMarker_33; }
inline void set_ResumeObserverPerfMarker_33(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___ResumeObserverPerfMarker_33 = value;
}
inline static int32_t get_offset_of_SuspendObserversPerfMarker_34() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___SuspendObserversPerfMarker_34)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_SuspendObserversPerfMarker_34() const { return ___SuspendObserversPerfMarker_34; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_SuspendObserversPerfMarker_34() { return &___SuspendObserversPerfMarker_34; }
inline void set_SuspendObserversPerfMarker_34(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___SuspendObserversPerfMarker_34 = value;
}
inline static int32_t get_offset_of_SuspendObserversTPerfMarker_35() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___SuspendObserversTPerfMarker_35)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_SuspendObserversTPerfMarker_35() const { return ___SuspendObserversTPerfMarker_35; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_SuspendObserversTPerfMarker_35() { return &___SuspendObserversTPerfMarker_35; }
inline void set_SuspendObserversTPerfMarker_35(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___SuspendObserversTPerfMarker_35 = value;
}
inline static int32_t get_offset_of_SuspendObserverPerfMarker_36() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___SuspendObserverPerfMarker_36)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_SuspendObserverPerfMarker_36() const { return ___SuspendObserverPerfMarker_36; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_SuspendObserverPerfMarker_36() { return &___SuspendObserverPerfMarker_36; }
inline void set_SuspendObserverPerfMarker_36(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___SuspendObserverPerfMarker_36 = value;
}
inline static int32_t get_offset_of_ClearObservationsPerfMarker_37() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___ClearObservationsPerfMarker_37)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_ClearObservationsPerfMarker_37() const { return ___ClearObservationsPerfMarker_37; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_ClearObservationsPerfMarker_37() { return &___ClearObservationsPerfMarker_37; }
inline void set_ClearObservationsPerfMarker_37(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___ClearObservationsPerfMarker_37 = value;
}
inline static int32_t get_offset_of_ClearObservationsTPerfMarker_38() { return static_cast<int32_t>(offsetof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_StaticFields, ___ClearObservationsTPerfMarker_38)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_ClearObservationsTPerfMarker_38() const { return ___ClearObservationsTPerfMarker_38; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_ClearObservationsTPerfMarker_38() { return &___ClearObservationsTPerfMarker_38; }
inline void set_ClearObservationsTPerfMarker_38(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___ClearObservationsTPerfMarker_38 = value;
}
};
// Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXRDeviceManager
struct OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604 : public XRSDKDeviceManager_t2A4831339BEF1FB396AA5D6BECED2EFAD7620719
{
public:
// System.Nullable`1<System.Boolean> Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXRDeviceManager::isActiveLoader
Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 ___isActiveLoader_25;
public:
inline static int32_t get_offset_of_isActiveLoader_25() { return static_cast<int32_t>(offsetof(OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604, ___isActiveLoader_25)); }
inline Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 get_isActiveLoader_25() const { return ___isActiveLoader_25; }
inline Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 * get_address_of_isActiveLoader_25() { return &___isActiveLoader_25; }
inline void set_isActiveLoader_25(Nullable_1_t1D1CD146BFCBDC2E53E1F700889F8C5C21063EF3 value)
{
___isActiveLoader_25 = value;
}
};
struct OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604_StaticFields
{
public:
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXRDeviceManager::GetOrAddControllerPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___GetOrAddControllerPerfMarker_26;
// Unity.Profiling.ProfilerMarker Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXRDeviceManager::RemoveControllerPerfMarker
ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 ___RemoveControllerPerfMarker_27;
public:
inline static int32_t get_offset_of_GetOrAddControllerPerfMarker_26() { return static_cast<int32_t>(offsetof(OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604_StaticFields, ___GetOrAddControllerPerfMarker_26)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_GetOrAddControllerPerfMarker_26() const { return ___GetOrAddControllerPerfMarker_26; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_GetOrAddControllerPerfMarker_26() { return &___GetOrAddControllerPerfMarker_26; }
inline void set_GetOrAddControllerPerfMarker_26(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___GetOrAddControllerPerfMarker_26 = value;
}
inline static int32_t get_offset_of_RemoveControllerPerfMarker_27() { return static_cast<int32_t>(offsetof(OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604_StaticFields, ___RemoveControllerPerfMarker_27)); }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 get_RemoveControllerPerfMarker_27() const { return ___RemoveControllerPerfMarker_27; }
inline ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 * get_address_of_RemoveControllerPerfMarker_27() { return &___RemoveControllerPerfMarker_27; }
inline void set_RemoveControllerPerfMarker_27(ProfilerMarker_tAE86534C80C5D67768DB3B244D8D139A2E6495E1 value)
{
___RemoveControllerPerfMarker_27 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
il2cpp_hresult_t IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(RuntimeObject* __this);
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);
// System.Byte System.Int32::System.IConvertible.ToByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t Int32_System_IConvertible_ToByte_mF20DC676FA2B16FA587B48C46126FF3A510FC2FE (int32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int16 System.Int32::System.IConvertible.ToInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t Int32_System_IConvertible_ToInt16_m546AEA11867A3FB43C753862D37C5E5D903A998A (int32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt16 System.Int32::System.IConvertible.ToUInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t Int32_System_IConvertible_ToUInt16_m4F02D84F201B3DD4F14E0DB290FFDF6484186C1D (int32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt32 System.Int32::System.IConvertible.ToUInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t Int32_System_IConvertible_ToUInt32_m32F7902EB35E916E5066F4F8F2A62C9EE4625F61 (int32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int64 System.Int32::System.IConvertible.ToInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t Int32_System_IConvertible_ToInt64_m8D333A53E7A5D76D06626647D5C323E3D7DEAF7F (int32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt64 System.Int32::System.IConvertible.ToUInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t Int32_System_IConvertible_ToUInt64_m624D1F3CF0A12FE5BA34183B454C4E87C4CA92F8 (int32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Single System.Int32::System.IConvertible.ToSingle(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float Int32_System_IConvertible_ToSingle_mA4658FD9FC83A12B7A9F9D5C3663354BA768D12B (int32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Double System.Int32::System.IConvertible.ToDouble(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double Int32_System_IConvertible_ToDouble_mBE6FF400E38A132D26CA5C073F5DF78446C0FED1 (int32_t* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Byte System.Single::System.IConvertible.ToByte(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t Single_System_IConvertible_ToByte_m8FAE4E8EDDF055FF2F17C2C00D091EBAA0099D49 (float* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int16 System.Single::System.IConvertible.ToInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t Single_System_IConvertible_ToInt16_mBED24FBB9C6465ABAECDC3C894F41B7CF0E6FC6A (float* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt16 System.Single::System.IConvertible.ToUInt16(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t Single_System_IConvertible_ToUInt16_mCBB71CEDC4797B00D50B4417A96EC702076C757A (float* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int32 System.Single::System.IConvertible.ToInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Single_System_IConvertible_ToInt32_mD144638A230B62184C32B38DFFFDF955353F42AC (float* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt32 System.Single::System.IConvertible.ToUInt32(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t Single_System_IConvertible_ToUInt32_mF7B0C9FE3652F3FE2E0BDEEC4B90A316099B525E (float* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Int64 System.Single::System.IConvertible.ToInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t Single_System_IConvertible_ToInt64_mAC0D1AEA698E9A358F503A77DA9C2873465E7ADC (float* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.UInt64 System.Single::System.IConvertible.ToUInt64(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t Single_System_IConvertible_ToUInt64_m6A235CB0548A46C28B13E14D5F62DEADE7887613 (float* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// System.Double System.Single::System.IConvertible.ToDouble(System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double Single_System_IConvertible_ToDouble_m103B0F5DD6C36D37816B2524CCFAB7A60F9781E6 (float* __this, RuntimeObject* ___provider0, const RuntimeMethod* method);
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.SceneSystem.MixedRealitySceneSystem
struct MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) MixedRealitySceneSystem_t6B428DD235F4308776373BD6AE9D80A55E544E00_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.SpatialAwareness.MixedRealitySpatialAwarenessSystem
struct MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) MixedRealitySpatialAwarenessSystem_t2CFC7DDDE794CF88F7081401B99A6FCC0DA1ED90_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.Teleport.MixedRealityTeleportSystem
struct MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) MixedRealityTeleportSystem_t200DD3AC8018EBB441D4AC8ADC3A24449AA541F4_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.Input.UnityInput.MouseDeviceManager
struct MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) MouseDeviceManager_tC79AB4661ADC2FF1D98F75AC5D3BAC744EB6AF3C_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Threading.Mutex
struct Mutex_tA342933FCB3E3E679E3CD498804DE36CD81801B5_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Mutex_tA342933FCB3E3E679E3CD498804DE36CD81801B5_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline Mutex_tA342933FCB3E3E679E3CD498804DE36CD81801B5_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Mutex_tA342933FCB3E3E679E3CD498804DE36CD81801B5_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Mutex_tA342933FCB3E3E679E3CD498804DE36CD81801B5(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Mutex_tA342933FCB3E3E679E3CD498804DE36CD81801B5_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Mutex_tA342933FCB3E3E679E3CD498804DE36CD81801B5_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Security.Cryptography.OidCollection
struct OidCollection_tA091E185B8840648BE96A6C547F0C26F88E3A902_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<OidCollection_tA091E185B8840648BE96A6C547F0C26F88E3A902_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline OidCollection_tA091E185B8840648BE96A6C547F0C26F88E3A902_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<OidCollection_tA091E185B8840648BE96A6C547F0C26F88E3A902_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_OidCollection_tA091E185B8840648BE96A6C547F0C26F88E3A902(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(OidCollection_tA091E185B8840648BE96A6C547F0C26F88E3A902_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) OidCollection_tA091E185B8840648BE96A6C547F0C26F88E3A902_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXRDeviceManager
struct OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) OpenXRDeviceManager_tC8A11DBF3A4FB6A2C7EAC7A3ACB1D6C6657D7604_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.XRSDK.OpenXR.OpenXREyeGazeDataProvider
struct OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) OpenXREyeGazeDataProvider_t8ADFF3E8712105A830E76D6271AD7A721A25FC85_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Threading.Tasks.ParallelForReplicaTask
struct ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ParallelForReplicaTask_tA8EF390CFE7A34F4D940DA70CFC2925E8E10E7A6_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Threading.Tasks.ParallelForReplicatingTask
struct ParallelForReplicatingTask_t5C662CB60CF2C6AAAFD99BCE33295652B32762A9_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ParallelForReplicatingTask_t5C662CB60CF2C6AAAFD99BCE33295652B32762A9_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline ParallelForReplicatingTask_t5C662CB60CF2C6AAAFD99BCE33295652B32762A9_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ParallelForReplicatingTask_t5C662CB60CF2C6AAAFD99BCE33295652B32762A9_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ParallelForReplicatingTask_t5C662CB60CF2C6AAAFD99BCE33295652B32762A9(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ParallelForReplicatingTask_t5C662CB60CF2C6AAAFD99BCE33295652B32762A9_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ParallelForReplicatingTask_t5C662CB60CF2C6AAAFD99BCE33295652B32762A9_ComCallableWrapper(obj));
}
// COM Callable Wrapper for UnityEngine.Windows.WebCam.PhotoCapture
struct PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) PhotoCapture_t776617AFD6DE0F6CEE985719380EC3DB91C8BB74_ComCallableWrapper(obj));
}
// COM Callable Wrapper for UnityEngine.Windows.WebCam.PhotoCaptureFrame
struct PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) PhotoCaptureFrame_t70F1A58CF7A76D6B44D7CEBD65B784BB20996CD0_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.IO.PinnedBufferMemoryStream
struct PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) PinnedBufferMemoryStream_tDB1B8D639F3D8F7E60BA9E050BC48C575E573E78_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.Foundation.Point
struct Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_ComCallableWrapper>, IReference_1_t7F259CA808F8CA00C0A7F31D57D93E94ABE7FD38, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_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, &IReference_1_t7F259CA808F8CA00C0A7F31D57D93E94ABE7FD38::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_t7F259CA808F8CA00C0A7F31D57D93E94ABE7FD38*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_t7F259CA808F8CA00C0A7F31D57D93E94ABE7FD38::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m6BBE84644D81C739672BB5FE7BD65AD8AD6C044B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 returnValue;
try
{
returnValue = *static_cast<Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 *>(UnBox(GetManagedObjectInline(), Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 17;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = false;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Byte");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Single");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Double");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 returnValue;
try
{
returnValue = *static_cast<Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 *>(UnBox(GetManagedObjectInline(), Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.Foundation.Point
struct Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB_ComCallableWrapper>, IReference_1_t22FB8AE92DF2358ED21FB1C7C5B2FFCAEB97C590, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB_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, &IReference_1_t22FB8AE92DF2358ED21FB1C7C5B2FFCAEB97C590::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_t22FB8AE92DF2358ED21FB1C7C5B2FFCAEB97C590*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_t22FB8AE92DF2358ED21FB1C7C5B2FFCAEB97C590::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m0FC3B384D7E37F93935DFB33EA2D44E3FC3E8F49(Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB returnValue;
try
{
returnValue = *static_cast<Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB *>(UnBox(GetManagedObjectInline(), Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 17;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = false;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Byte");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Single");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Double");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Point", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Point_t8B0B7243DC381133E329E2DCCB319DC6F4CBF8CB_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.Foundation.PropertyType
struct PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_ComCallableWrapper>, IReference_1_tA4E67817B79498EFBA69D3B855B0D877416F6A8B, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_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, &IReference_1_tA4E67817B79498EFBA69D3B855B0D877416F6A8B::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_tA4E67817B79498EFBA69D3B855B0D877416F6A8B*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_tA4E67817B79498EFBA69D3B855B0D877416F6A8B::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_mAFDC3A521A2D5078E107CAAA4F124AFC2D25F526(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 20;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = true;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint8_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Byte");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
try
{
uint8_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToByte_mF20DC676FA2B16FA587B48C46126FF3A510FC2FE((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Byte");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int16_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
try
{
int16_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToInt16_m546AEA11867A3FB43C753862D37C5E5D903A998A((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Int16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint16_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
try
{
uint16_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToUInt16_m4F02D84F201B3DD4F14E0DB290FFDF6484186C1D((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint32_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt32");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
try
{
uint32_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToUInt32_m32F7902EB35E916E5066F4F8F2A62C9EE4625F61((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt32");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int64_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
try
{
int64_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToInt64_m8D333A53E7A5D76D06626647D5C323E3D7DEAF7F((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Int64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint64_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
try
{
uint64_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToUInt64_m624D1F3CF0A12FE5BA34183B454C4E87C4CA92F8((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
float returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
try
{
float il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToSingle_mA4658FD9FC83A12B7A9F9D5C3663354BA768D12B((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Single");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
double returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_il2cpp_TypeInfo_var));
try
{
double il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToDouble_mBE6FF400E38A132D26CA5C073F5DF78446C0FED1((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Double");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) PropertyType_tE0EA93A7BFC9AC532D4D960D9F87C6E0B5C4F808_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Numerics.Quaternion
struct Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C_ComCallableWrapper>, IReference_1_t33EFD59F5EFEE8E48055FF4CB9A75732C6EA2E31, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C_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, &IReference_1_t33EFD59F5EFEE8E48055FF4CB9A75732C6EA2E31::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_t33EFD59F5EFEE8E48055FF4CB9A75732C6EA2E31*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_t33EFD59F5EFEE8E48055FF4CB9A75732C6EA2E31::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_mC9B0A6358249758D52E8655254FFC53AB4E48D2F(Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C returnValue;
try
{
returnValue = *static_cast<Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C *>(UnBox(GetManagedObjectInline(), Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 20;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = false;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Quaternion_tE38335092171ED778CFD631B55A5C81347A93E8C_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.Foundation.Numerics.Quaternion
struct Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22_ComCallableWrapper>, IReference_1_t3A0E57B1670337C77F71EEB98E7BC1AFBB35812A, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22_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, &IReference_1_t3A0E57B1670337C77F71EEB98E7BC1AFBB35812A::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_t3A0E57B1670337C77F71EEB98E7BC1AFBB35812A*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_t3A0E57B1670337C77F71EEB98E7BC1AFBB35812A::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m223D1D22BBB08115FECD12012F70419914365276(Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22 * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22 returnValue;
try
{
returnValue = *static_cast<Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22 *>(UnBox(GetManagedObjectInline(), Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 20;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = false;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Quaternion_tEA023D1069B1229FB3B43923B6DB22090B599B22_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Queue
struct Queue_t66723C58C7422102C36F8570BE048BD0CC489E52_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Queue_t66723C58C7422102C36F8570BE048BD0CC489E52_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline Queue_t66723C58C7422102C36F8570BE048BD0CC489E52_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Queue_t66723C58C7422102C36F8570BE048BD0CC489E52_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_Queue_t66723C58C7422102C36F8570BE048BD0CC489E52(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Queue_t66723C58C7422102C36F8570BE048BD0CC489E52_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Queue_t66723C58C7422102C36F8570BE048BD0CC489E52_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Security.Cryptography.RNGCryptoServiceProvider
struct RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) RNGCryptoServiceProvider_t696D1B0DFED446BE4718F7E18ABFFBB6E5A8A5A1_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.Foundation.Rect
struct Rect_tC45F1DDF39812623644DE296D8057A4958176627_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Rect_tC45F1DDF39812623644DE296D8057A4958176627_ComCallableWrapper>, IReference_1_tBCFA9924A47B56774AFEF690310BA37E1A800808, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline Rect_tC45F1DDF39812623644DE296D8057A4958176627_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Rect_tC45F1DDF39812623644DE296D8057A4958176627_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, &IReference_1_tBCFA9924A47B56774AFEF690310BA37E1A800808::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_tBCFA9924A47B56774AFEF690310BA37E1A800808*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_tBCFA9924A47B56774AFEF690310BA37E1A800808::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m64387D2D55E86DABEC832FDADDA12CBF1C7C1D5E(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Rect_tC45F1DDF39812623644DE296D8057A4958176627_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Rect_tC45F1DDF39812623644DE296D8057A4958176627 returnValue;
try
{
returnValue = *static_cast<Rect_tC45F1DDF39812623644DE296D8057A4958176627 *>(UnBox(GetManagedObjectInline(), Rect_tC45F1DDF39812623644DE296D8057A4958176627_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 19;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = false;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Byte");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Single");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Double");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Rect_tC45F1DDF39812623644DE296D8057A4958176627_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Rect_tC45F1DDF39812623644DE296D8057A4958176627 returnValue;
try
{
returnValue = *static_cast<Rect_tC45F1DDF39812623644DE296D8057A4958176627 *>(UnBox(GetManagedObjectInline(), Rect_tC45F1DDF39812623644DE296D8057A4958176627_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Rect_tC45F1DDF39812623644DE296D8057A4958176627(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Rect_tC45F1DDF39812623644DE296D8057A4958176627_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Rect_tC45F1DDF39812623644DE296D8057A4958176627_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.Foundation.Rect
struct Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891_ComCallableWrapper>, IReference_1_t6C2C9667B4A9B53CCB0776745CBB938B87C32F2E, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891_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, &IReference_1_t6C2C9667B4A9B53CCB0776745CBB938B87C32F2E::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_t6C2C9667B4A9B53CCB0776745CBB938B87C32F2E*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_t6C2C9667B4A9B53CCB0776745CBB938B87C32F2E::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m96AACCD499BB14F3DBACD6CA120C283ABCE73263(Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891 * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891 returnValue;
try
{
returnValue = *static_cast<Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891 *>(UnBox(GetManagedObjectInline(), Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 19;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = false;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Byte");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Single");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Double");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Rect", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Rect_t612E465CB97C3834EF1EE6D46D56027E2BC19891_ComCallableWrapper(obj));
}
// COM Callable Wrapper for UnityEngine.RectTransform
struct RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_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_RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.Win32.RegistryKey
struct RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) RegistryKey_t1EF11DB6AC49AC065AF744487033109254215268_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Resources.ResourceFallbackManager
struct ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652_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_ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ResourceFallbackManager_t519E633959AC8EE890105625261272326BED6652_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Resources.ResourceReader
struct ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[1] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ResourceReader_tC8A3D1DC4FDF2CBC92782B9BD71194279D655492_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Resources.ResourceSet
struct ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
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_ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) ResourceSet_t04B4806442F31EFE5374C485BB883BBA6F75566F_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Resources.RuntimeResourceSet
struct RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
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_RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) RuntimeResourceSet_tE6CEE5AD87FD9B32ABB7C6738D4B04104FE5CE3A_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Security.Cryptography.SHA1CryptoServiceProvider
struct SHA1CryptoServiceProvider_tFCC9EF75A0DCF3E1A50E64B525EA9599E5927EF7_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SHA1CryptoServiceProvider_tFCC9EF75A0DCF3E1A50E64B525EA9599E5927EF7_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline SHA1CryptoServiceProvider_tFCC9EF75A0DCF3E1A50E64B525EA9599E5927EF7_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SHA1CryptoServiceProvider_tFCC9EF75A0DCF3E1A50E64B525EA9599E5927EF7_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SHA1CryptoServiceProvider_tFCC9EF75A0DCF3E1A50E64B525EA9599E5927EF7(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SHA1CryptoServiceProvider_tFCC9EF75A0DCF3E1A50E64B525EA9599E5927EF7_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SHA1CryptoServiceProvider_tFCC9EF75A0DCF3E1A50E64B525EA9599E5927EF7_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.Win32.SafeHandles.SafeFileHandle
struct SafeFileHandle_tC77A9860A03C31DC46AD2C08EC10EACDC3B7A662_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SafeFileHandle_tC77A9860A03C31DC46AD2C08EC10EACDC3B7A662_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline SafeFileHandle_tC77A9860A03C31DC46AD2C08EC10EACDC3B7A662_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SafeFileHandle_tC77A9860A03C31DC46AD2C08EC10EACDC3B7A662_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SafeFileHandle_tC77A9860A03C31DC46AD2C08EC10EACDC3B7A662(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SafeFileHandle_tC77A9860A03C31DC46AD2C08EC10EACDC3B7A662_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SafeFileHandle_tC77A9860A03C31DC46AD2C08EC10EACDC3B7A662_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.Win32.SafeHandles.SafeFindHandle
struct SafeFindHandle_t0E0D5349FC3144C1CAB2D20DCD3023B25833B8BD_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SafeFindHandle_t0E0D5349FC3144C1CAB2D20DCD3023B25833B8BD_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline SafeFindHandle_t0E0D5349FC3144C1CAB2D20DCD3023B25833B8BD_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SafeFindHandle_t0E0D5349FC3144C1CAB2D20DCD3023B25833B8BD_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SafeFindHandle_t0E0D5349FC3144C1CAB2D20DCD3023B25833B8BD(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SafeFindHandle_t0E0D5349FC3144C1CAB2D20DCD3023B25833B8BD_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SafeFindHandle_t0E0D5349FC3144C1CAB2D20DCD3023B25833B8BD_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Mono.SafeGPtrArrayHandle
struct SafeGPtrArrayHandle_tAEC97FDEAA1FFF2E1C1475EECB98B945EF86141A_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SafeGPtrArrayHandle_tAEC97FDEAA1FFF2E1C1475EECB98B945EF86141A_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline SafeGPtrArrayHandle_tAEC97FDEAA1FFF2E1C1475EECB98B945EF86141A_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SafeGPtrArrayHandle_tAEC97FDEAA1FFF2E1C1475EECB98B945EF86141A_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SafeGPtrArrayHandle_tAEC97FDEAA1FFF2E1C1475EECB98B945EF86141A(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SafeGPtrArrayHandle_tAEC97FDEAA1FFF2E1C1475EECB98B945EF86141A_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SafeGPtrArrayHandle_tAEC97FDEAA1FFF2E1C1475EECB98B945EF86141A_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.Win32.SafeHandles.SafeRegistryHandle
struct SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SafeRegistryHandle_tE132711AC8880C0D375E49B50419BCE4935CC545_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Mono.SafeStringMarshal
struct SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SafeStringMarshal_t3F5BD5E96CFBAF124814DED946144CF39A82F11E_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.Win32.SafeHandles.SafeWaitHandle
struct SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Threading.SemaphoreSlim
struct SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SemaphoreSlim_t3EF85FC980AE57957BEBB6B78E81DE2E3233D385_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Single
struct Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_ComCallableWrapper>, IReference_1_tD4026FABBA608F648777776BC282618C51E2AF46, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_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, &IReference_1_tD4026FABBA608F648777776BC282618C51E2AF46::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_tD4026FABBA608F648777776BC282618C51E2AF46*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_tD4026FABBA608F648777776BC282618C51E2AF46::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m82E1812FB137290B0EE35532E1008D32226FE5F3(float* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
float returnValue;
try
{
returnValue = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 8;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = true;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint8_t returnValue;
try
{
float value = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "Byte");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Byte");
}
try
{
uint8_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToByte_m8FAE4E8EDDF055FF2F17C2C00D091EBAA0099D49((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "Byte");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Byte");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Byte");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int16_t returnValue;
try
{
float value = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
try
{
int16_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToInt16_mBED24FBB9C6465ABAECDC3C894F41B7CF0E6FC6A((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "Int16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Int16");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Int16");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint16_t returnValue;
try
{
float value = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "UInt16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt16");
}
try
{
uint16_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToUInt16_mCBB71CEDC4797B00D50B4417A96EC702076C757A((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "UInt16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt16");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt16");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
float value = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
try
{
int32_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToInt32_mD144638A230B62184C32B38DFFFDF955353F42AC((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "Int32");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Int32");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Int32");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint32_t returnValue;
try
{
float value = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "UInt32");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt32");
}
try
{
uint32_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToUInt32_mF7B0C9FE3652F3FE2E0BDEEC4B90A316099B525E((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "UInt32");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt32");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt32");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int64_t returnValue;
try
{
float value = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
try
{
int64_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToInt64_mAC0D1AEA698E9A358F503A77DA9C2873465E7ADC((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "Int64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Int64");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Int64");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint64_t returnValue;
try
{
float value = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "UInt64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt64");
}
try
{
uint64_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToUInt64_m6A235CB0548A46C28B13E14D5F62DEADE7887613((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "UInt64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt64");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt64");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
float returnValue;
try
{
returnValue = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
double returnValue;
try
{
float value = *static_cast<float*>(UnBox(GetManagedObjectInline(), Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var));
try
{
double il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToDouble_m103B0F5DD6C36D37816B2524CCFAB7A60F9781E6((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Single", "Double");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Double");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Double");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Single", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.Foundation.Size
struct Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_ComCallableWrapper>, IReference_1_t6AF48AEDBAB54EEF81D7BE93983928A632CEA6B7, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_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, &IReference_1_t6AF48AEDBAB54EEF81D7BE93983928A632CEA6B7::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_t6AF48AEDBAB54EEF81D7BE93983928A632CEA6B7*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_t6AF48AEDBAB54EEF81D7BE93983928A632CEA6B7::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m4E45D3537EF0FB1FFE8AF3B2DCB63DB98A3A45AA(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 returnValue;
try
{
returnValue = *static_cast<Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 *>(UnBox(GetManagedObjectInline(), Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 18;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = false;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Byte");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Single");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Double");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 returnValue;
try
{
returnValue = *static_cast<Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 *>(UnBox(GetManagedObjectInline(), Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.Foundation.Size
struct Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5_ComCallableWrapper>, IReference_1_tF1450FE2A758CB62295758B955692AA1A5A3CCA9, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5_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, &IReference_1_tF1450FE2A758CB62295758B955692AA1A5A3CCA9::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_tF1450FE2A758CB62295758B955692AA1A5A3CCA9*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_tF1450FE2A758CB62295758B955692AA1A5A3CCA9::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m3496400E5AB203A0F7596D49F46B68601F66DD77(Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5 * comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5 returnValue;
try
{
returnValue = *static_cast<Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5 *>(UnBox(GetManagedObjectInline(), Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 18;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = false;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Byte");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Single");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Double");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Size", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Size_tD78415B1E3C5A20EBC460FCFAD9960781E926CE5_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.SortedList
struct SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165_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_SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SortedList_t52B9ACC0DAA6CD074E375215F43251DE16366165_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.UI.Input.Spatial.SpatialInteractionSourceHandedness
struct SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_ComCallableWrapper>, IReference_1_t0976D6A3C4B3A2296DE9EC238663EBCA4B18240B, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_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, &IReference_1_t0976D6A3C4B3A2296DE9EC238663EBCA4B18240B::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_t0976D6A3C4B3A2296DE9EC238663EBCA4B18240B*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_t0976D6A3C4B3A2296DE9EC238663EBCA4B18240B::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m31DA5B4095EA7D9AC3547820AEF5AC55A293E816(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 20;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = true;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint8_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Byte");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
try
{
uint8_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToByte_mF20DC676FA2B16FA587B48C46126FF3A510FC2FE((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Byte");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int16_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
try
{
int16_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToInt16_m546AEA11867A3FB43C753862D37C5E5D903A998A((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Int16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint16_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
try
{
uint16_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToUInt16_m4F02D84F201B3DD4F14E0DB290FFDF6484186C1D((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint32_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt32");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
try
{
uint32_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToUInt32_m32F7902EB35E916E5066F4F8F2A62C9EE4625F61((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt32");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int64_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
try
{
int64_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToInt64_m8D333A53E7A5D76D06626647D5C323E3D7DEAF7F((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Int64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint64_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
try
{
uint64_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToUInt64_m624D1F3CF0A12FE5BA34183B454C4E87C4CA92F8((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
float returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
try
{
float il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToSingle_mA4658FD9FC83A12B7A9F9D5C3663354BA768D12B((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Single");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
double returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_il2cpp_TypeInfo_var));
try
{
double il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToDouble_mBE6FF400E38A132D26CA5C073F5DF78446C0FED1((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Double");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SpatialInteractionSourceHandedness_tC2409F24AA1DC3E3915DE8AA3AF09913C01FCE9B_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Windows.UI.Input.Spatial.SpatialInteractionSourceKind
struct SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_ComCallableWrapper>, IReference_1_tFBF6EDC09F056C59D8EEFE81E5EA39206D2AF70C, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_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, &IReference_1_tFBF6EDC09F056C59D8EEFE81E5EA39206D2AF70C::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReference_1_tFBF6EDC09F056C59D8EEFE81E5EA39206D2AF70C*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8*>(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] = IReference_1_tFBF6EDC09F056C59D8EEFE81E5EA39206D2AF70C::IID;
interfaceIds[1] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::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 IReference_1_get_Value_m5388021AB708A278C93226BC20DDA41AD0DF74EC(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_Type_m2BC440F5119A133BE4DD895657519ADAA3B34272(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = 20;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_get_IsNumericScalar_mC8DE97926668A5F2EA3F4A9B128E966CBC7B0D60(bool* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
bool returnValue;
try
{
returnValue = true;
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8_m25D96C5F9AC133BF7B682C59FE83EE05A0075B05(uint8_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint8_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Byte");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
try
{
uint8_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToByte_mF20DC676FA2B16FA587B48C46126FF3A510FC2FE((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Byte");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int16_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
try
{
int16_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToInt16_m546AEA11867A3FB43C753862D37C5E5D903A998A((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Int16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint16_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
try
{
uint16_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToUInt16_m4F02D84F201B3DD4F14E0DB290FFDF6484186C1D((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt16");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int32_t returnValue;
try
{
returnValue = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint32_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt32");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
try
{
uint32_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToUInt32_m32F7902EB35E916E5066F4F8F2A62C9EE4625F61((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt32");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
int64_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
try
{
int64_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToInt64_m8D333A53E7A5D76D06626647D5C323E3D7DEAF7F((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Int64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
uint64_t returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
if (value < 0)
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
try
{
uint64_t il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToUInt64_m624D1F3CF0A12FE5BA34183B454C4E87C4CA92F8((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "UInt64");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
float returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
try
{
float il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToSingle_mA4658FD9FC83A12B7A9F9D5C3663354BA768D12B((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Single");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Managed method invocation
double returnValue;
try
{
int32_t value = *static_cast<int32_t*>(UnBox(GetManagedObjectInline(), SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_il2cpp_TypeInfo_var));
try
{
double il2cppRetVal;
il2cppRetVal = Int32_System_IConvertible_ToDouble_mBE6FF400E38A132D26CA5C073F5DF78446C0FED1((&value), NULL, NULL);
returnValue = il2cppRetVal;
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion(GetManagedObjectInline(), "Other", "Double");
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double");
}
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double");
}
}
catch (const Il2CppExceptionWrapper& ex)
{
memset(comReturnValue, 0, sizeof(*comReturnValue));
String_t* exceptionStr = NULL;
try
{
exceptionStr = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, ex.ex);
}
catch (const Il2CppExceptionWrapper&)
{
exceptionStr = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->get_Empty_5();
}
il2cpp_codegen_store_exception_info(ex.ex, exceptionStr);
return ex.ex->hresult;
}
*comReturnValue = returnValue;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Byte[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt32[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Int64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "UInt64[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Single[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Double[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "String[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Guid[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "DateTimeOffset[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpanArray_mEAF3CA18AA928DAF3046F0F530B9324711650167(uint32_t* ___value0ArraySize, TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "TimeSpan[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPointArray_mD4ACB0F49C7BFEC1C03A4EE4263B23B2040CECD0(uint32_t* ___value0ArraySize, Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Point[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSizeArray_m3C079B4191330FAC3B2131D308C825BC72A5F0DC(uint32_t* ___value0ArraySize, Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Size[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRectArray_m09598924D31716E1E653AE941186F8B16EA11A87(uint32_t* ___value0ArraySize, Rect_tC45F1DDF39812623644DE296D8057A4958176627 ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("Other", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SpatialInteractionSourceKind_t812D8C730AA19BAA0BDA6CA4DA60B61AF7E88CF7_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Stack
struct Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8_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_Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) Stack_tF6DD42A42C129B014D4223010F1E0FFBECBDC3B8_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.IO.StreamReader
struct StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3_ComCallableWrapper>, IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953
{
inline StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3_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, &IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953*>(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] = IClosable_t30CA7D2BE598B3BD6AA57CE9DF977DB51540B953::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 IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999() IL2CPP_OVERRIDE
{
return IClosable_Close_m7DE2119A960C4E3898E6E5D03245D047BF113999_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) StreamReader_tA857ACC7ABF9AA4638E1291E6D2539C14D2963D3_ComCallableWrapper(obj));
}
| 46.551113 | 354 | 0.83411 | leeenglestone |
36a9710bcd0a857bc3709f4ca4c09e8e4c86a0d2 | 4,818 | cpp | C++ | benchmarks/mmd_permutation_benchmark.cpp | lambday/derby | 83ba9b36f7fe29498339872f4dbafb1f4053ed19 | [
"MIT"
] | null | null | null | benchmarks/mmd_permutation_benchmark.cpp | lambday/derby | 83ba9b36f7fe29498339872f4dbafb1f4053ed19 | [
"MIT"
] | null | null | null | benchmarks/mmd_permutation_benchmark.cpp | lambday/derby | 83ba9b36f7fe29498339872f4dbafb1f4053ed19 | [
"MIT"
] | null | null | null | /*
* Copyright (c) The Shogun Machine Learning Toolbox
* Written (w) 2016 Soumyajit De
* 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 OWNER 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.
*
* The views and conclusions contained in the software and documentation are those
* of the authors and should not be interpreted as representing official policies,
* either expressed or implied, of the Shogun Development Team.
*/
#include <algorithm>
#include <memory>
#include <shogun/base/init.h>
#include <shogun/lib/SGMatrix.h>
#include <shogun/lib/SGVector.h>
#include <shogun/features/Features.h>
#include <shogun/features/DenseFeatures.h>
#include <shogun/kernel/Kernel.h>
#include <shogun/kernel/GaussianKernel.h>
#include <shogun/statistical_testing/MMD.h>
#include <shogun/statistical_testing/internals/mmd/WithinBlockPermutation.h>
#include <shogun/statistical_testing/internals/mmd/WithinBlockPermutationBatch.h>
#include <benchmark/benchmark.h>
using namespace shogun;
using namespace internal;
using namespace mmd;
/*
* $ g++ -O3 -std=c++14 mmd_permutation_benchmark.cpp -lshogun -lbenchmark -lpthread -fopenmp
* $ ./a.out
* Run on (4 X 2999.95 MHz CPU s)
* 2016-04-15 08:39:04
* ***WARNING*** CPU scaling is enabled, the benchmark real time measurements may be noisy and will incur extra overhead.
* Benchmark Time(ns) CPU(ns) Iterations
* -------------------------------------------
* BM_Batch 5176712791 15645935000 1
* BM_Serial 10088581387 31100171000 1
*/
struct Data
{
Data() : dim(2), n(1000), m(1000), num_null_samples(250)
{
init_shogun_with_defaults();
SGMatrix<float64_t> data_p(dim, n);
std::iota(data_p.matrix, data_p.matrix+dim*n, 1);
std::for_each(data_p.matrix, data_p.matrix+dim*n, [this](float64_t& val) { val/=n; });
SGMatrix<float64_t> data_q(dim, m);
std::iota(data_q.matrix, data_q.matrix+dim*m, n+1);
std::for_each(data_q.matrix, data_q.matrix+dim*m, [this](float64_t& val) { val/=2*m; });
auto feats_p=new CDenseFeatures<float64_t>(data_p);
auto feats_q=new CDenseFeatures<float64_t>(data_q);
auto feats=feats_p->create_merged_copy(feats_q);
SG_REF(feats);
SG_UNREF(feats_p);
SG_UNREF(feats_q);
auto kernel=std::make_unique<CGaussianKernel>();
kernel->set_width(2.0);
kernel->init(feats, feats);
mat=kernel->get_kernel_matrix();
}
~Data()
{
exit_shogun();
}
const index_t dim;
const index_t n;
const index_t m;
const index_t num_null_samples;
SGMatrix<float64_t> mat;
};
Data data;
SGVector<float64_t> batch_permutation()
{
const index_t& n=data.n;
const index_t& m=data.m;
const index_t& num_null_samples=data.num_null_samples;
SGMatrix<float64_t>& mat=data.mat;
WithinBlockPermutationBatch batch(n, m, num_null_samples, EStatisticType::BIASED_FULL);
sg_rand->set_seed(12345);
return batch(mat);
}
SGVector<float64_t> serial_permutation()
{
const index_t& n=data.n;
const index_t& m=data.m;
const index_t& num_null_samples=data.num_null_samples;
SGMatrix<float64_t>& mat=data.mat;
SGVector<float64_t> result(num_null_samples);
WithinBlockPermutation compute(n, m, EStatisticType::BIASED_FULL);
sg_rand->set_seed(12345);
#pragma omp parallel for
for (auto i=0; i<num_null_samples; ++i)
{
result[i]=compute(mat);
}
return result;
}
static void BM_Batch(benchmark::State& state)
{
while (state.KeepRunning())
{
auto result=batch_permutation();
}
}
BENCHMARK(BM_Batch);
static void BM_Serial(benchmark::State& state)
{
while (state.KeepRunning())
{
auto result=serial_permutation();
}
}
BENCHMARK(BM_Serial);
BENCHMARK_MAIN();
| 31.907285 | 121 | 0.740349 | lambday |
36aae615a02a1288343679bb17b4df9ab35c4f4f | 5,417 | cc | C++ | src/http/incoming/Message.cc | jdavidberger/rikitiki | 95877037eb0b9d7f090042ddec49b3b85c5ed680 | [
"MIT"
] | null | null | null | src/http/incoming/Message.cc | jdavidberger/rikitiki | 95877037eb0b9d7f090042ddec49b3b85c5ed680 | [
"MIT"
] | null | null | null | src/http/incoming/Message.cc | jdavidberger/rikitiki | 95877037eb0b9d7f090042ddec49b3b85c5ed680 | [
"MIT"
] | null | null | null | #include <rikitiki/exception.h>
#include <rikitiki/http/parsing/Utils.h>
#include <rikitiki/http/Header.h>
#include <rikitiki/http/incoming/Message.h>
#include <mxcomp/log.h>
#include <mxcomp/utf.h>
namespace rikitiki {
void IMessage::OnStartLine(const rikitiki::string& startline) {
this->SetStartline(startline);
}
void IMessage::OnHeader(const rikitiki::string& n, const rikitiki::string& v) {
*this << Header(n, v);
}
void IMessage::OnBodyData(const char* data, size_t size) {
Body().write(data, (std::streamsize)size);
}
void IMessage::UpdateBufferState() {
if (currentState.streamState == MessageState::BODY) {
currentState.bodyType = BodyType::From(this->ContentLength(), this->TransferEncoding());
if (currentState.bodyType == BodyType::KNOWN_SIZE) {
bufferMode = BufferModeT::LENGTH;
expectedSize = ContentLength();
}
if (currentState.bodyType == BodyType::CHUNKED)
bufferMode = BufferModeT::NEWLINE; // To read in the next chunk size
if (currentState.bodyType == BodyType::NONE)
currentState.streamState = MessageState::FINISHED;
}
}
bool IMessage::OnBufferedData(const char* data, std::size_t length) {
std::string buffer;
LOG(IMessage, Debug) << "Buffered IMessage: " << currentState.streamState << ", " << currentState.bodyType << ": " << data << std::endl;
const char* end = &data[length];
switch (currentState.streamState) {
case MessageState::START_LINE: {
OnStartLine(data);
SetState(MessageState::HEADERS);
return false;
}
case MessageState::HEADERS:
if (data[0] == '\r' || data[0] == '\n') {
data += 2;
currentState.bodyType = BodyType::From(ContentLength(), TransferEncoding());
SetState(ContentLength() == 0 ? MessageState::FINISHED : MessageState::BODY);
bufferMode = TransferEncoding() == Encoding::chunked ? NEWLINE : NONE;
expectedSize = ContentLength();
}
else {
std::string buffer2;
data = readHeaderName(data, end, buffer);
data = readHeaderValue(data, end, buffer2);
OnHeader(rikitiki::to_rt_string(&buffer[0]),
rikitiki::to_rt_string(&buffer2[0]));
data += 2; // Burn \r\n
}
return currentState.streamState == MessageState::FINISHED;
case MessageState::BODY: {
switch (currentState.bodyType) {
case BodyType::CHUNKED: {
if (expectedSize == (size_t)-1) {
expectedSize = (size_t)strtol(data, (char**)&data, 16) + 2;
bufferMode = LENGTH;
}
else {
auto relevantSize = (std::streamsize)(expectedSize - 2);
OnChunkedData(data, (size_t)relevantSize);
if (expectedSize - 2 == 0)
currentState.streamState = MessageState::FINISHED;
bufferMode = NEWLINE;
}
break;
}
case BodyType::KNOWN_SIZE:
if (data != end) {
bufferMode = NONE;
OnBodyData(data, (size_t)(end - data));
if ((size_t)(end - data) <= expectedSize) {
expectedSize -= (size_t)(end - data);
}
else {
expectedSize = 0;
LOG(Message, Warning) << "Data in message was longer than expected." << std::endl;
}
}
if (expectedSize == 0)
SetState(MessageState::FINISHED);
break;
case BodyType::BUFFERING:
case BodyType::UNKNOWN:
OnBodyData(data, (size_t)(end - data));
break;
}
break;
}
case MessageState::FINISHED:
throw new rikitiki::exception("Unexpected input");
}
if(currentState.streamState == MessageState::FINISHED) {
LOG(IMessage, Debug) << "Message finished" << std::endl;
}
return currentState.streamState == MessageState::FINISHED;
}
void IMessage::SetState(MessageState::type newState) {
OnStateChange(newState);
currentState.streamState = newState;
}
bool IMessage::OnData(const char* data, size_t len) {
LOG(Message, Debug) << (void*)this << " incoming: " << std::string(data, len) << std::endl;
return BufferedReader::OnData(data, len);
}
void MessageListener::OnChunkedData(const char* d, size_t len) {
OnBodyData(d, len);
}
}
| 43.685484 | 140 | 0.485509 | jdavidberger |
36ab3ce6b6635a07575063144c69512dca4eb212 | 382 | cpp | C++ | doc/examples/std_swap.cpp | cosmoscout/json | e4643d1f1b03fc7a1d7b65f17e012ca93680cad8 | [
"MIT"
] | 2 | 2021-10-10T08:29:39.000Z | 2021-11-09T10:46:52.000Z | doc/examples/std_swap.cpp | IXIIAI/json | ef556019be51ba3db32854e2a491b4ccb540a2c8 | [
"MIT"
] | 2 | 2021-10-10T08:29:31.000Z | 2021-11-18T10:59:26.000Z | doc/examples/std_swap.cpp | IXIIAI/json | ef556019be51ba3db32854e2a491b4ccb540a2c8 | [
"MIT"
] | null | null | null | #include <iostream>
#include <iomanip>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
int main()
{
// create JSON values
json j1 = {{"one", 1}, {"two", 2}};
json j2 = {1, 2, 4, 8, 16};
std::cout << "j1 = " << j1 << " | j2 = " << j2 << '\n';
// swap values
std::swap(j1, j2);
std::cout << "j1 = " << j1 << " | j2 = " << j2 << std::endl;
}
| 19.1 | 64 | 0.471204 | cosmoscout |
36ac0603d1c14b7bcc0d9f1b75f57eb9dfbfb1aa | 558 | cpp | C++ | examples/path/ex1.cpp | friko9/PathPool | 4db85f4eb0088d6b673471df31b99b03ba26ecaf | [
"MIT"
] | null | null | null | examples/path/ex1.cpp | friko9/PathPool | 4db85f4eb0088d6b673471df31b99b03ba26ecaf | [
"MIT"
] | null | null | null | examples/path/ex1.cpp | friko9/PathPool | 4db85f4eb0088d6b673471df31b99b03ba26ecaf | [
"MIT"
] | null | null | null | #include "path.h"
#include "path_pool.h"
#include <iostream>
int main()
{
using Path = Path<ListPathPool<std::string>>;
Path root;
Path p1 { root, "path1" };
Path p2 { root, "path2" };
Path p3 { root, "path1" };
Path p4 { p2, "path1" };
std::cout<< (p1 == p2) << std::endl; // false
std::cout<< (p1 == p3) << std::endl; // true
std::cout<< (p1 == p4) << std::endl; // false
std::cout<< root.get_tag() << std::endl; // ''
std::cout<< p4.get_tag() << std::endl; // path1
std::cout<< p4.get_parent().get_tag() << std::endl; // path2
}
| 26.571429 | 62 | 0.555556 | friko9 |
36afbe1b73014fd8bd7d868fee3fe035dece0c57 | 4,123 | cpp | C++ | aoc2018_day13.cpp | bluespeck/aoc_2018 | d847613516bd1e0a6c1a7a0c32cc093a3f558dd4 | [
"MIT"
] | null | null | null | aoc2018_day13.cpp | bluespeck/aoc_2018 | d847613516bd1e0a6c1a7a0c32cc093a3f558dd4 | [
"MIT"
] | null | null | null | aoc2018_day13.cpp | bluespeck/aoc_2018 | d847613516bd1e0a6c1a7a0c32cc093a3f558dd4 | [
"MIT"
] | 1 | 2018-12-15T11:50:33.000Z | 2018-12-15T11:50:33.000Z | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
struct Cart
{
int x, y;
int nextIntersectionDir = 0; // 0, 1, 2; increment % 3
int currentDir = 'v'; // v, <, >, ^
};
using Grid = std::vector<std::string>;
using CartVec = std::vector<Cart>;
std::vector<Cart> carts;
Grid ReadInput()
{
Grid grid;
while (std::cin)
{
std::string line;
std::getline(std::cin, line);
grid.emplace_back(std::move(line));
}
return grid;
}
CartVec ExtractCartsFromGrid(Grid& grid)
{
CartVec carts;
int dirMap[256];
dirMap['v'] = 0;
dirMap['<'] = 1;
dirMap['>'] = 2;
dirMap['^'] = 3;
// dirMap[0] = 'v';
// dirMap[1] = '<';
// dirMap[2] = '>';
// dirMap[3] = '^';
for (size_t i = 0; i < grid.size(); i++)
{
for (size_t j = 0; j < grid[i].size(); j++)
{
if (grid[i][j] == 'v' || grid[i][j] == '>' || grid[i][j] == '<' || grid[i][j] == '^')
{
Cart cart;
cart.x = i;
cart.y = j;
cart.nextIntersectionDir = 0;
cart.currentDir = dirMap[grid[i][j]];
carts.push_back(cart);
if (grid[i][j] == 'v' || grid[i][j] == '^')
grid[i][j] = '|';
if (grid[i][j] == '<' || grid[i][j] == '>')
grid[i][j] = '-';
}
}
}
return carts;
}
void SimulateTrains(const Grid& grid, CartVec& carts)
{
int dirSwitcher[4][3] =
{
{ 2, 0, 1 },
{ 0, 1, 3 },
{ 3, 2, 0 },
{ 1, 3, 2 }
};
int cornerSwitcher[4][256];
cornerSwitcher[0]['/'] = 1;
cornerSwitcher[1]['/'] = 0;
cornerSwitcher[2]['/'] = 3;
cornerSwitcher[3]['/'] = 2;
cornerSwitcher[0]['\\'] = 2;
cornerSwitcher[1]['\\'] = 3;
cornerSwitcher[2]['\\'] = 0;
cornerSwitcher[3]['\\'] = 1;
bool firstCrashProcessed = false;
int deltaXSwitcher[4]{ 1, 0, 0, -1 };
int deltaYSwitcher[4]{ 0, -1, 1, 0 };
while (carts.size())
{
std::sort(carts.begin(), carts.end(), [](const Cart& a, const Cart& b) { return a.x < b.x || a.x == b.x && a.y < b.y; });
for (size_t i = 0; i < carts.size(); i++)
{
auto& cart = carts[i];
int newX = cart.x + deltaXSwitcher[cart.currentDir];
int newY = cart.y + deltaYSwitcher[cart.currentDir];
auto it = std::find_if(carts.begin(), carts.end(), [newX, newY](const Cart& cart) { return cart.x == newX && cart.y == newY; });
if (it != carts.end())
{
if (static_cast<size_t>(std::distance(carts.begin(), it)) < i)
--i;
carts.erase(it);
carts.erase(carts.begin() + i);
--i;
if (firstCrashProcessed == false)
{
std::cout << newY << ',' << newX << '\n';
firstCrashProcessed = true;
}
}
else
{
int newDir = cart.currentDir;
switch (grid[newX][newY])
{
case '+':
{
newDir = dirSwitcher[cart.currentDir][cart.nextIntersectionDir];
cart.nextIntersectionDir = (cart.nextIntersectionDir + 1) % 3;
break;
}
case '/': [[fallthrough]];
case '\\':
{
newDir = cornerSwitcher[cart.currentDir][grid[newX][newY]];
break;
}
}
if (carts.size() == 1)
{
std::cout << cart.y << ',' << cart.x << '\n';
return;
}
cart.x = newX;
cart.y = newY;
cart.currentDir = newDir;
}
}
}
}
int main()
{
Grid grid = ReadInput();
CartVec carts = ExtractCartsFromGrid(grid);
SimulateTrains(grid, carts);
return 0;
}
| 25.450617 | 140 | 0.41984 | bluespeck |
36afec8649610aeb3e4512caec96cdf379a90cb2 | 9,250 | cpp | C++ | datastore/common/objects/InterfaceNetwork.test.cpp | cmwill/netmeld | bf72a2b2954609b9767575fd2a25bf2ac81338e3 | [
"MIT"
] | 27 | 2017-11-04T23:58:54.000Z | 2022-03-28T14:21:50.000Z | datastore/common/objects/InterfaceNetwork.test.cpp | cmwill/netmeld | bf72a2b2954609b9767575fd2a25bf2ac81338e3 | [
"MIT"
] | 64 | 2020-03-16T19:59:43.000Z | 2022-03-18T14:49:18.000Z | datastore/common/objects/InterfaceNetwork.test.cpp | cmwill/netmeld | bf72a2b2954609b9767575fd2a25bf2ac81338e3 | [
"MIT"
] | 13 | 2019-12-01T21:32:33.000Z | 2022-03-28T15:40:02.000Z | // =============================================================================
// Copyright 2017 National Technology & Engineering Solutions of Sandia, LLC
// (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// 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.
// =============================================================================
// Maintained by Sandia National Laboratories <Netmeld@sandia.gov>
// =============================================================================
#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MAIN
#include <boost/test/unit_test.hpp>
#include <netmeld/datastore/objects/InterfaceNetwork.hpp>
#include <netmeld/core/utils/StringUtilities.hpp>
namespace nmdo = netmeld::datastore::objects;
namespace nmcu = netmeld::core::utils;
class TestInterfaceNetwork : public nmdo::InterfaceNetwork {
public:
TestInterfaceNetwork() : InterfaceNetwork() {};
public:
std::string getDescription() const
{ return description; }
std::string getMediaType() const
{ return mediaType; }
bool getIsDiscoveryProtocolEnabled() const
{ return isDiscoveryProtocolEnabled; }
nmdo::MacAddress getMacAddr() const
{ return macAddr; }
std::string getMode()
{ return mode; }
bool getIsPortSecurityEnabled() const
{ return isPortSecurityEnabled; }
unsigned short getPortSecurityMaxMacAddrs() const
{ return portSecurityMaxMacAddrs; }
std::string getPortSecurityViolationAction() const
{ return portSecurityViolationAction; }
bool getIsPortSecurityStickyMac() const
{ return isPortSecurityStickyMac; }
std::set<nmdo::MacAddress> getLearnedMacAddrs() const
{ return learnedMacAddrs; }
bool getIsBpduGuardEnabled() const
{ return isBpduGuardEnabled; }
bool getIsBpduFilterEnabled() const
{ return isBpduFilterEnabled; }
bool getIsPortfastEnabled() const
{ return isPortfastEnabled; }
bool getIsPartial() const
{ return isPartial; }
std::set<nmdo::Vlan> getVlans() const
{ return vlans; }
};
BOOST_AUTO_TEST_CASE(testConstructors)
{
nmdo::MacAddress macAddr;
{
TestInterfaceNetwork interface;
BOOST_CHECK(interface.getName().empty());
BOOST_CHECK(interface.getDescription().empty());
BOOST_CHECK_EQUAL("ethernet", interface.getMediaType());
BOOST_CHECK(interface.getState());
BOOST_CHECK(interface.getIsDiscoveryProtocolEnabled());
BOOST_CHECK_EQUAL(macAddr, interface.getMacAddr());
BOOST_CHECK_EQUAL("l3", interface.getMode());
BOOST_CHECK(!interface.getIsPortSecurityEnabled());
BOOST_CHECK_EQUAL(1, interface.getPortSecurityMaxMacAddrs());
BOOST_CHECK_EQUAL("shutdown", interface.getPortSecurityViolationAction());
BOOST_CHECK(!interface.getIsPortSecurityStickyMac());
BOOST_CHECK(interface.getLearnedMacAddrs().empty());
BOOST_CHECK(!interface.getIsBpduGuardEnabled());
BOOST_CHECK(!interface.getIsBpduFilterEnabled());
BOOST_CHECK(!interface.getIsPortfastEnabled());
BOOST_CHECK(!interface.getIsPartial());
}
}
BOOST_AUTO_TEST_CASE(testSetters)
{
{
TestInterfaceNetwork interface;
nmdo::IpAddress ipAddr {"1.2.3.4/24"};
interface.addIpAddress(ipAddr);
auto ipAddrs = interface.getIpAddresses();
BOOST_CHECK_EQUAL(1, ipAddrs.size());
BOOST_CHECK_EQUAL(ipAddr, ipAddrs[0]);
}
{
TestInterfaceNetwork interface;
nmdo::MacAddress macAddr {"00:11:22:33:44:55"};
interface.addPortSecurityStickyMac(macAddr);
interface.addPortSecurityStickyMac(macAddr);
auto macAddrs = interface.getLearnedMacAddrs();
BOOST_CHECK_EQUAL(1, macAddrs.size());
BOOST_CHECK_EQUAL(1, macAddrs.count(macAddr));
}
{
TestInterfaceNetwork interface;
uint16_t vlanId {0};
interface.addVlan(vlanId);
interface.addVlan(vlanId);
vlanId = UINT16_MAX;
interface.addVlan(vlanId);
auto vlans {interface.getVlans()};
BOOST_CHECK_EQUAL(2, vlans.size());
BOOST_CHECK_EQUAL(1, vlans.count(nmdo::Vlan(vlanId)));
BOOST_CHECK_EQUAL(1, vlans.count(nmdo::Vlan(vlanId)));
}
{
TestInterfaceNetwork interface;
BOOST_CHECK(interface.getIsDiscoveryProtocolEnabled());
interface.setDiscoveryProtocol(false);
BOOST_CHECK(!interface.getIsDiscoveryProtocolEnabled());
interface.setDiscoveryProtocol(true);
BOOST_CHECK(interface.getIsDiscoveryProtocolEnabled());
}
{
TestInterfaceNetwork interface;
std::string text {"Some Description"};
interface.setDescription(text);
BOOST_CHECK_EQUAL(text, interface.getDescription());
}
{
TestInterfaceNetwork interface;
nmdo::MacAddress macAddr {"00:11:22:33:44:55"};
interface.setMacAddress(macAddr);
BOOST_CHECK_EQUAL(macAddr, interface.getMacAddr());
}
{
TestInterfaceNetwork interface;
std::string text {"MeDiAtYpE"};
BOOST_CHECK_EQUAL("ethernet", interface.getMediaType());
interface.setMediaType(text);
BOOST_CHECK_EQUAL(nmcu::toLower(text), interface.getMediaType());
}
{
TestInterfaceNetwork interface;
std::string text {"NaMe"};
interface.setName(text);
BOOST_CHECK_EQUAL(nmcu::toLower(text), interface.getName());
}
{
TestInterfaceNetwork interface;
BOOST_CHECK(interface.getState());
interface.setState(true);
BOOST_CHECK(interface.getState());
interface.setState(false);
BOOST_CHECK(!interface.getState());
}
{
TestInterfaceNetwork interface;
std::string text {"MoDe"};
interface.setSwitchportMode(text);
BOOST_CHECK_EQUAL(nmcu::toLower(text), interface.getMode());
}
{
TestInterfaceNetwork interface;
BOOST_CHECK(!interface.getIsPortSecurityEnabled());
interface.setPortSecurity(true);
BOOST_CHECK(interface.getIsPortSecurityEnabled());
interface.setPortSecurity(false);
BOOST_CHECK(!interface.getIsPortSecurityEnabled());
}
{
TestInterfaceNetwork interface;
BOOST_CHECK_EQUAL(1, interface.getPortSecurityMaxMacAddrs());
interface.setPortSecurityMaxMacAddrs(0);
BOOST_CHECK_EQUAL(0, interface.getPortSecurityMaxMacAddrs());
interface.setPortSecurityMaxMacAddrs(USHRT_MAX);
BOOST_CHECK_EQUAL(USHRT_MAX, interface.getPortSecurityMaxMacAddrs());
}
{
TestInterfaceNetwork interface;
std::string text {"AcTiOn"};
BOOST_CHECK_EQUAL("shutdown", interface.getPortSecurityViolationAction());
interface.setPortSecurityViolationAction(text);
BOOST_CHECK_EQUAL(nmcu::toLower(text), interface.getPortSecurityViolationAction());
}
{
TestInterfaceNetwork interface;
BOOST_CHECK(!interface.getIsPortSecurityStickyMac());
interface.setPortSecurityStickyMac(true);
BOOST_CHECK(interface.getIsPortSecurityStickyMac());
interface.setPortSecurityStickyMac(false);
BOOST_CHECK(!interface.getIsPortSecurityStickyMac());
}
{
TestInterfaceNetwork interface;
BOOST_CHECK(!interface.getIsBpduGuardEnabled());
interface.setBpduGuard(true);
BOOST_CHECK(interface.getIsBpduGuardEnabled());
interface.setBpduGuard(false);
BOOST_CHECK(!interface.getIsBpduGuardEnabled());
}
{
TestInterfaceNetwork interface;
BOOST_CHECK(!interface.getIsBpduFilterEnabled());
interface.setBpduFilter(true);
BOOST_CHECK(interface.getIsBpduFilterEnabled());
interface.setBpduFilter(false);
BOOST_CHECK(!interface.getIsBpduFilterEnabled());
}
{
TestInterfaceNetwork interface;
BOOST_CHECK(!interface.getIsPortfastEnabled());
interface.setPortfast(true);
BOOST_CHECK(interface.getIsPortfastEnabled());
interface.setPortfast(false);
BOOST_CHECK(!interface.getIsPortfastEnabled());
}
{
TestInterfaceNetwork interface;
BOOST_CHECK(!interface.getIsPartial());
interface.setPartial(true);
BOOST_CHECK(interface.getIsPartial());
interface.setPartial(false);
BOOST_CHECK(!interface.getIsPartial());
}
}
BOOST_AUTO_TEST_CASE(testValidity)
{
{
TestInterfaceNetwork interface;
BOOST_CHECK(!interface.isValid());
interface.setName("name");
BOOST_CHECK(interface.isValid());
interface.setName("");
BOOST_CHECK(!interface.isValid());
}
}
| 30.427632 | 87 | 0.717946 | cmwill |
a5e2be485ae34f75b86b7fdc6954071c9ec79997 | 1,523 | cpp | C++ | graph/createadjlist.cpp | huweihuang/data-structure-code | dacb3a036d0a4df391ce5fca9ce65f7dc2ab1b69 | [
"Apache-2.0"
] | 3 | 2019-05-17T09:09:16.000Z | 2020-11-18T08:13:00.000Z | graph/createadjlist.cpp | huweihuang/data-structure-code | dacb3a036d0a4df391ce5fca9ce65f7dc2ab1b69 | [
"Apache-2.0"
] | null | null | null | graph/createadjlist.cpp | huweihuang/data-structure-code | dacb3a036d0a4df391ce5fca9ce65f7dc2ab1b69 | [
"Apache-2.0"
] | null | null | null | #include <stdio.h>
#include <malloc.h>
#define MAXVEX 100
typedef char VertexType[3];
typedef struct edgenode
{
int adjvex; /*邻接点序号*/
int value; /*边的权值*/
struct edgenode *next; /*下一条边的顶点*/
} ArcNode; /*每个顶点建立的单链表中结点的类型*/
typedef struct vexnode
{
VertexType data; /*结点信息*/
ArcNode *firstarc; /*指向第一条边结点*/
} VHeadNode; /*单链表的头结点类型*/
typedef struct
{
int n,e; /*n为实际顶点数,e为实际边数*/
VHeadNode adjlist[MAXVEX]; /*单链表头结点数组*/
} AdjList; /*图的邻接表类型*/
int CreateAdjList(AdjList *&G) /*建立有向图的邻接表*/
{
int i,b,t,w;
ArcNode *p;
G=(AdjList *)malloc(sizeof(AdjList));
printf("顶点数(n),边数(e):");
scanf("%d%d",&G->n,&G->e);
for (i=0;i<G->n;i++)
{
printf(" 序号为%d的顶点信息:", i);
scanf("%s",G->adjlist[i].data);
G->adjlist[i].firstarc=NULL;
}
for (i=0;i<G->e;i++)
{
printf(" 序号为边=>",i);
printf(" 起点号 终点号 权值:");
scanf("%d%d%d",&b,&t,&w);
if (b<G->n && t<G->n && w>0)
{
p=(ArcNode *)malloc(sizeof(ArcNode)); /*建立*p结点*/
p->value=w;p->adjvex=t;
p->next=G->adjlist[b].firstarc; /**p插入到adjlist[b]的单链表之首*/
G->adjlist[b].firstarc=p;
}
else
{
printf("输入错误!\n");
return(0);
}
}
return(1);
}
void DispAdjList(AdjList *G)
{
int i;
ArcNode *p;
printf("图的邻接表表示如下:\n");
for (i=0;i<G->n;i++)
{
printf(" [%d,%3s]=>",i,G->adjlist[i].data);
p=G->adjlist[i].firstarc;
while (p!=NULL)
{
printf("(%d,%d)->",p->adjvex,p->value);
p=p->next;
}
printf("∧\n");
}
}
void main()
{
AdjList *G;
CreateAdjList(G);
DispAdjList(G);
}
| 18.130952 | 61 | 0.560079 | huweihuang |
a5e4920d524a32dd9fa31d7088f7b66c198a2545 | 421 | cpp | C++ | src/utils/log.cpp | Metaphysical1/gamesneeze | 59d31ee232bbcc80d29329e0f64ebdde599c37df | [
"MIT"
] | 1,056 | 2020-11-17T11:49:12.000Z | 2022-03-23T12:32:42.000Z | src/utils/log.cpp | dweee/gamesneeze | 99f574db2617263470280125ec78afa813f27099 | [
"MIT"
] | 102 | 2021-01-15T12:05:18.000Z | 2022-02-26T00:19:58.000Z | src/utils/log.cpp | dweee/gamesneeze | 99f574db2617263470280125ec78afa813f27099 | [
"MIT"
] | 121 | 2020-11-18T12:08:21.000Z | 2022-03-31T07:14:32.000Z | #include "../includes.hpp"
/* print Logs in green */
void Log::log(logLevel level, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
switch (level) {
case LOG: fputs("\e[32m[LOG] ", stdout); break;
case WARN: fputs("\e[33m[WARN] ", stdout); break;
case ERR: fputs("\e[31m[ERR] ", stdout); break;
}
vprintf(fmt, args);
fputs("\e[0m\n", stdout);
va_end(args);
} | 28.066667 | 57 | 0.562945 | Metaphysical1 |
a5ec960d008bd79eb10845b27d8f9ea6bb1b9e4f | 4,095 | cc | C++ | src/agent/map_type_evaluator.cc | KaihangXing/my-agent-demo | 764a38b93e7487305f12ac15a76e220ebda9db39 | [
"Apache-2.0"
] | 86 | 2015-11-21T12:48:04.000Z | 2022-02-03T17:22:44.000Z | src/agent/map_type_evaluator.cc | KaihangXing/my-agent-demo | 764a38b93e7487305f12ac15a76e220ebda9db39 | [
"Apache-2.0"
] | 16 | 2016-07-15T11:23:24.000Z | 2021-12-26T15:24:10.000Z | src/agent/map_type_evaluator.cc | KaihangXing/my-agent-demo | 764a38b93e7487305f12ac15a76e220ebda9db39 | [
"Apache-2.0"
] | 45 | 2016-02-02T19:58:13.000Z | 2021-10-09T02:47:29.000Z | /**
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "map_type_evaluator.h"
#include "jni_proxy_ju_map.h"
#include "messages.h"
#include "model.h"
#include "model_util.h"
#include "value_formatter.h"
namespace devtools {
namespace cdbg {
MapTypeEvaluator::MapTypeEvaluator()
: map_entry_set_(InstanceMethod(
"Ljava/util/Map;",
"entrySet",
"()Ljava/util/Set;")) {
}
bool MapTypeEvaluator::IsMap(jclass cls) const {
if (cls == nullptr) {
return false;
}
return jni()->IsAssignableFrom(cls, jniproxy::Map()->GetClass());
}
void MapTypeEvaluator::Evaluate(
MethodCaller* method_caller,
const ClassMetadataReader::Entry& class_metadata,
jobject obj,
bool is_watch_expression,
std::vector<NamedJVariant>* members) {
std::unique_ptr<FormatMessageModel> error_message;
// Set<Map.Entry<K,V>> entries = obj.entrySet();
ErrorOr<JVariant> entries = method_caller->Invoke(
map_entry_set_,
JVariant::BorrowedRef(obj),
{});
if (entries.is_error()) {
members->push_back(NamedJVariant::ErrorStatus(entries.error_message()));
return;
}
jobject entries_obj = nullptr;
entries.value().get<jobject>(&entries_obj);
if (obj == nullptr) {
// This is highly unlikely to happen. It indicates some very rudimentary
// problem with the map.
members->push_back(
NamedJVariant::ErrorStatus({ NullPointerDereference }));
return;
}
iterable_evaluator_.Evaluate(
method_caller, entries_obj, is_watch_expression, members);
TryInlineMap(method_caller, members);
}
void MapTypeEvaluator::TryInlineMap(
MethodCaller* method_caller,
std::vector<NamedJVariant>* members) {
// Do nothing if any of the members has a key that doesn't map to a value
// evaluator.
WellKnownJClass map_keys_well_known_jclass = WellKnownJClass::Unknown;
for (const NamedJVariant& member : *members) {
if (member.value.type() == JType::Void) {
continue;
}
jobject obj = nullptr;
member.value.get<jobject>(&obj);
if (obj == nullptr) {
return;
}
WellKnownJClass well_known_jclass =
map_entry_evaluator_.GetKeyWellKnownJClass(method_caller, obj);
if (!ValueFormatter::IsImmutableValueObject(well_known_jclass)) {
return;
}
if (map_keys_well_known_jclass == WellKnownJClass::Unknown) {
map_keys_well_known_jclass = well_known_jclass;
} else if (map_keys_well_known_jclass != well_known_jclass) {
return; // Non-uniform keys.
}
}
// Inline the map.
for (NamedJVariant& member : *members) {
if (member.value.type() == JType::Void) {
continue;
}
jobject obj = nullptr;
member.value.get<jobject>(&obj);
if (obj == nullptr) {
continue;
}
NamedJVariant entry_key;
NamedJVariant entry_value;
map_entry_evaluator_.Evaluate(
method_caller,
obj,
&entry_key,
&entry_value);
entry_key.well_known_jclass = map_keys_well_known_jclass;
// We don't need to include the type information as the type is only
// associated with the value, never with the key.
std::string key;
ValueFormatter::Format(entry_key, ValueFormatter::Options(), &key, nullptr);
member.name.clear();
member.name.reserve(key.size() + 2);
member.name += '[';
member.name += key;
member.name += ']';
member.status = entry_value.status;
member.value.swap(&entry_value.value);
}
}
} // namespace cdbg
} // namespace devtools
| 26.940789 | 80 | 0.682295 | KaihangXing |
a5ecad6d253b56d0832c6c424f5f3678757aed0e | 898 | cpp | C++ | src/UnitTests/src/test.cpp | Indomerun/pyHiChi | fdceb238dfed6433ee350d5c593ca5e2cd4fbd2b | [
"MIT"
] | 11 | 2019-08-22T12:47:40.000Z | 2022-01-28T16:07:29.000Z | src/UnitTests/src/test.cpp | Indomerun/pyHiChi | fdceb238dfed6433ee350d5c593ca5e2cd4fbd2b | [
"MIT"
] | 14 | 2019-09-02T08:24:55.000Z | 2022-02-14T11:40:43.000Z | src/UnitTests/src/test.cpp | Indomerun/pyHiChi | fdceb238dfed6433ee350d5c593ca5e2cd4fbd2b | [
"MIT"
] | 9 | 2019-07-31T13:25:20.000Z | 2022-01-28T16:07:45.000Z | #include "TestingUtility.h"
#include "Pml.h"
#include "Pstd.h"
#include "Fdtd.h"
#include <memory>
TEST(TEST_, test) {
Int3 gridSize(32, 1, 1);
Int3 minCoords = FP3(-1.0, 0.0, 0.0);
Int3 maxCoords = FP3(1.0, 1.0, 1.0);
FP3 steps((maxCoords.x - minCoords.x) / gridSize.x,
(maxCoords.y - minCoords.y) / gridSize.y,
(maxCoords.z - minCoords.z) / gridSize.z);
Grid<FP, GridTypes::YeeGridType>* grid = new Grid<FP, GridTypes::YeeGridType>(gridSize, 0.5, minCoords, steps, gridSize);
FDTD* pstd = new FDTD(grid);
/*std::auto_ptr<Pml<GridTypes::YeeGridType>> pml;
pml.reset(new PmlSpectral<GridTypes::YeeGridType>(&pstd, Int3(0, 0, 0)));
pml.reset(new PmlPstd(&pstd, Int3(4, 0, 0)));*/
//PmlSpectral<GridTypes::YeeGridType>* pml = new PmlSpectral<GridTypes::YeeGridType>(pstd, Int3(0, 0, 0));
//delete pml;
delete pstd;
delete grid;
} | 35.92 | 125 | 0.640312 | Indomerun |