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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9f5a92cc43c0f35a7101f046a633ed4529fe8c27
| 1,506
|
cpp
|
C++
|
src/lua/script.cpp
|
FiniteReality/SourceLua
|
41ced5fb3c80376cac012c0dab1f9f2f39400e40
|
[
"MIT"
] | 7
|
2017-08-27T08:11:48.000Z
|
2022-03-06T06:20:02.000Z
|
src/lua/script.cpp
|
FiniteReality/SourceLua
|
41ced5fb3c80376cac012c0dab1f9f2f39400e40
|
[
"MIT"
] | 7
|
2017-08-18T14:17:09.000Z
|
2018-04-17T15:26:22.000Z
|
src/lua/script.cpp
|
FiniteReality/SourceLua
|
41ced5fb3c80376cac012c0dab1f9f2f39400e40
|
[
"MIT"
] | 3
|
2017-10-04T03:35:58.000Z
|
2020-11-25T13:48:44.000Z
|
#include <stdexcept>
#include <common/logging.hpp>
#include <lua/error_handler.hpp>
#include <lua/script.hpp>
#include <thread/scheduler.hpp>
namespace SourceLua
{
namespace Lua
{
Script::Script(lua_State* L)
: _L{L}, _name{"=unknown"}
{
if (_L == nullptr)
throw new std::runtime_error("L must not be null");
// Push the table now so that we don't have to re-order the stack
lua_getfield(_L, LUA_REGISTRYINDEX, SOURCELUA_SCRIPT_CACHE_KEY);
_T = lua_newthread(_L);
if (_T == nullptr)
throw new std::runtime_error("Could not initialize Lua thread");
thread_ref = luaL_ref(L, -2);
lua_pop(_L, 1);
}
Script::Script(lua_State* L, const char* name)
: Script(L)
{
_name.replace(1, _name.size(), name);
}
Script::~Script()
{
// Remove the reference to allow GC to occur
lua_getfield(_L, LUA_REGISTRYINDEX, SOURCELUA_SCRIPT_CACHE_KEY);
luaL_unref(_L, -1, thread_ref);
lua_pop(_L, 1);
}
void Script::Run(const char* code)
{
Run(code, strlen(code));
}
void Script::Run(const char* code, size_t length)
{
int err = luaL_loadbufferx(_T, code, length, _name.c_str(), "t");
if (err == LUA_OK)
{
auto task = Threading::CreateDelayedTask(_T, 0);
Threading::Scheduler::EnqueueTask(std::move(task));
}
else
{
Errors::HandleError(_T, err);
}
}
const char* Script::name() const
{
return _name.substr(1).c_str();
}
}
}
// kate: indent-mode cstyle; indent-width 4; replace-tabs on;
| 20.351351
| 72
| 0.64741
|
FiniteReality
|
9f5d67a3ac7adb976fd04e35059068de30813ffd
| 8,526
|
cpp
|
C++
|
src/Visual/EntityComponent.cpp
|
Kanma/Athena-Graphics
|
7e531c404ee55ca8f1ca39e94b55c3d505a2901f
|
[
"MIT"
] | 1
|
2016-10-30T07:34:29.000Z
|
2016-10-30T07:34:29.000Z
|
src/Visual/EntityComponent.cpp
|
Kanma/Athena-Graphics
|
7e531c404ee55ca8f1ca39e94b55c3d505a2901f
|
[
"MIT"
] | null | null | null |
src/Visual/EntityComponent.cpp
|
Kanma/Athena-Graphics
|
7e531c404ee55ca8f1ca39e94b55c3d505a2901f
|
[
"MIT"
] | null | null | null |
/** @file EntityComponent.cpp
@author Philip Abbet
Implementation of the class 'Athena::Graphics::Visual::EntityComponent'
*/
#include <Athena-Graphics/Visual/EntityComponent.h>
#include <Athena-Graphics/Conversions.h>
#include <Athena-Entities/Transforms.h>
#include <Athena-Entities/Scene.h>
#include <Athena-Entities/Signals.h>
#include <Ogre/OgreSceneManager.h>
using namespace Athena;
using namespace Athena::Graphics;
using namespace Athena::Graphics::Visual;
using namespace Athena::Entities;
using namespace Athena::Signals;
using namespace Athena::Utils;
using namespace Ogre;
using namespace std;
/************************************** CONSTANTS **************************************/
///< Name of the type of component
const std::string EntityComponent::TYPE = "Athena/Visual/EntityComponent";
/***************************** CONSTRUCTION / DESTRUCTION ******************************/
EntityComponent::EntityComponent(const std::string& strName, ComponentsList* pList)
: VisualComponent(strName, pList), m_bVisible(true), m_bCastShadows(false), m_pSceneNode(0)
{
// Assertions
assert(getSceneManager());
assert(m_pList);
assert(m_pList->getEntity());
assert(m_pList->getEntity()->getSignalsList());
assert(m_pList->getEntity()->getTransforms());
m_id.type = COMP_VISUAL;
// Create a scene node
m_pSceneNode = getSceneManager()->createSceneNode();
// Use the transforms of the entity by default
setTransforms(0);
// Register to the 'Scene shown' and 'Scene hidden' signals
SignalsList* pSignals = m_pList->getEntity()->getScene()->getSignalsList();
pSignals->connect(SIGNAL_SCENE_SHOWN, this, &EntityComponent::onSceneShown);
pSignals->connect(SIGNAL_SCENE_HIDDEN, this, &EntityComponent::onSceneHidden);
// Register to the 'Entity enabled' and 'Entity disabled' signals
pSignals = m_pList->getEntity()->getSignalsList();
pSignals->connect(SIGNAL_ENTITY_ENABLED, this, &EntityComponent::onEntityEnabled);
pSignals->connect(SIGNAL_ENTITY_DISABLED, this, &EntityComponent::onEntityDisabled);
// If the scene is already shown, simulates a signal event
if (m_pList->getEntity()->getScene()->isShown())
onSceneShown(0);
}
//-----------------------------------------------------------------------
EntityComponent::~EntityComponent()
{
// Assertions
assert(getSceneManager());
assert(m_pSceneNode);
assert(m_pList);
assert(m_pList->getEntity());
assert(m_pList->getEntity()->getSignalsList());
// Unregister from the 'Entity attached' and 'Entity detached' signals
SignalsList* pSignals = m_pList->getEntity()->getSignalsList();
pSignals->disconnect(SIGNAL_ENTITY_ENABLED, this, &EntityComponent::onEntityEnabled);
pSignals->disconnect(SIGNAL_ENTITY_DISABLED, this, &EntityComponent::onEntityDisabled);
// Unregister from the 'Scene shown' and 'Scene hidden' signals
pSignals = m_pList->getEntity()->getScene()->getSignalsList();
pSignals->disconnect(SIGNAL_SCENE_SHOWN, this, &EntityComponent::onSceneShown);
pSignals->disconnect(SIGNAL_SCENE_HIDDEN, this, &EntityComponent::onSceneHidden);
// Destroy the scene node
getSceneManager()->destroySceneNode(m_pSceneNode->getName());
}
//-----------------------------------------------------------------------
EntityComponent* EntityComponent::create(const std::string& strName, ComponentsList* pList)
{
return new EntityComponent(strName, pList);
}
//-----------------------------------------------------------------------
EntityComponent* EntityComponent::cast(Component* pComponent)
{
return dynamic_cast<EntityComponent*>(pComponent);
}
/*************************************** METHODS ***************************************/
void EntityComponent::setCastShadows(bool bCastShadows)
{
// Assertions
assert(m_pSceneNode);
if (bCastShadows == m_bCastShadows)
return;
m_bCastShadows = bCastShadows;
SceneNode::ObjectIterator iter = m_pSceneNode->getAttachedObjectIterator();
while (iter.hasMoreElements())
iter.getNext()->setCastShadows(bCastShadows);
}
//-----------------------------------------------------------------------
void EntityComponent::attachObject(Ogre::MovableObject* pObject)
{
// Assertions
assert(m_pSceneNode);
assert(pObject);
m_pSceneNode->attachObject(pObject);
pObject->setCastShadows(m_bCastShadows);
pObject->setVisible(m_bVisible);
}
//-----------------------------------------------------------------------
void EntityComponent::onTransformsChanged()
{
// Assertions
assert(m_pSceneNode);
if (getTransforms())
{
m_pSceneNode->setPosition(toOgre(getTransforms()->getWorldPosition()));
m_pSceneNode->setOrientation(toOgre(getTransforms()->getWorldOrientation()));
m_pSceneNode->setScale(toOgre(getTransforms()->getWorldScale()));
}
else
{
m_pSceneNode->setPosition(Ogre::Vector3::ZERO);
m_pSceneNode->setOrientation(Ogre::Quaternion::IDENTITY);
m_pSceneNode->setScale(Ogre::Vector3::UNIT_SCALE);
}
VisualComponent::onTransformsChanged();
}
/**************************************** SLOTS ****************************************/
void EntityComponent::onSceneShown(Utils::Variant* pValue)
{
// Assertions
assert(m_pSceneNode);
assert(m_pList);
assert(m_pList->getEntity());
assert(m_pList->getEntity()->getScene());
assert(m_pList->getEntity()->getScene()->isShown());
if (m_pList->getEntity()->isEnabled())
onEntityEnabled(0);
}
//-----------------------------------------------------------------------
void EntityComponent::onSceneHidden(Utils::Variant* pValue)
{
// Assertions
assert(m_pSceneNode);
assert(m_pList);
assert(m_pList->getEntity());
assert(m_pList->getEntity()->getScene());
assert(!m_pList->getEntity()->getScene()->isShown());
if (m_pList->getEntity()->isEnabled())
getSceneManager()->getRootSceneNode()->removeChild(m_pSceneNode);
}
//-----------------------------------------------------------------------
void EntityComponent::onEntityEnabled(Utils::Variant* pValue)
{
// Assertions
assert(m_pSceneNode);
assert(!m_pSceneNode->getParent());
assert(m_pList);
assert(m_pList->getEntity());
assert(m_pList->getEntity()->isEnabled());
getSceneManager()->getRootSceneNode()->addChild(m_pSceneNode);
}
//-----------------------------------------------------------------------
void EntityComponent::onEntityDisabled(Utils::Variant* pValue)
{
// Assertions
assert(m_pSceneNode);
assert(m_pSceneNode->getParent());
assert(m_pList);
assert(m_pList->getEntity());
assert(!m_pList->getEntity()->isEnabled());
getSceneManager()->getRootSceneNode()->removeChild(m_pSceneNode);
}
/***************************** MANAGEMENT OF THE PROPERTIES ****************************/
Utils::PropertiesList* EntityComponent::getProperties() const
{
// Call the base class implementation
PropertiesList* pProperties = Component::getProperties();
// Create the category belonging to this type
pProperties->selectCategory(TYPE, false);
// Visibility
pProperties->set("visible", new Variant(isVisible()));
// Shadows casting
pProperties->set("castShadows", new Variant(mustCastShadows()));
// Returns the list
return pProperties;
}
//-----------------------------------------------------------------------
bool EntityComponent::setProperty(const std::string& strCategory, const std::string& strName,
Utils::Variant* pValue)
{
assert(!strCategory.empty());
assert(!strName.empty());
assert(pValue);
if (strCategory == TYPE)
return EntityComponent::setProperty(strName, pValue);
return Component::setProperty(strCategory, strName, pValue);
}
//-----------------------------------------------------------------------
bool EntityComponent::setProperty(const std::string& strName, Utils::Variant* pValue)
{
// Assertions
assert(!strName.empty());
assert(pValue);
// Visibility
if (strName == "visible")
{
if (m_bVisible != pValue->toBool())
setVisible(!m_bVisible);
}
// Shadows casting
else if (strName == "castShadows")
{
if (m_bCastShadows != pValue->toBool())
setCastShadows(!m_bCastShadows);
}
// Destroy the value
delete pValue;
return true;
}
| 30.234043
| 93
| 0.612949
|
Kanma
|
9f5de0c64add9d5db02e91744023085e65f3f36b
| 1,956
|
cpp
|
C++
|
src/platformspecifics/u32/u32backend.cpp
|
mightybruno/KShare
|
c1124354be9c8bb5c1931e37e19391f0b6c4389f
|
[
"MIT"
] | 16
|
2020-01-22T04:52:46.000Z
|
2022-02-22T09:53:39.000Z
|
src/platformspecifics/u32/u32backend.cpp
|
mightybruno/KShare
|
c1124354be9c8bb5c1931e37e19391f0b6c4389f
|
[
"MIT"
] | 15
|
2020-02-16T01:12:42.000Z
|
2021-05-03T21:51:26.000Z
|
src/platformspecifics/u32/u32backend.cpp
|
mightybruno/KShare
|
c1124354be9c8bb5c1931e37e19391f0b6c4389f
|
[
"MIT"
] | 3
|
2020-04-03T22:20:14.000Z
|
2020-09-23T07:58:09.000Z
|
#include "u32backend.hpp"
#include <Lmcons.h>
#include <QCursor>
#include <QtWin>
#include <windows.h>
std::tuple<QPoint, QPixmap> PlatformBackend::getCursor() {
CURSORINFO cursorInfo;
cursorInfo.cbSize = sizeof(cursorInfo);
if (GetCursorInfo(&cursorInfo)) {
if (cursorInfo.flags == CURSOR_SHOWING) {
ICONINFO info; // It took me 5 hours to get to here
if (GetIconInfo(cursorInfo.hCursor, &info)) {
return std::tuple<QPoint, QPixmap>(QPoint(info.xHotspot, info.yHotspot),
QtWin::fromHBITMAP(info.hbmColor, QtWin::HBitmapAlpha));
} else
return std::tuple<QPoint, QPixmap>(QPoint(0, 0), QPixmap());
} else
return std::tuple<QPoint, QPixmap>(QPoint(0, 0), QPixmap());
} else
return std::tuple<QPoint, QPixmap>(QPoint(0, 0), QPixmap());
}
DWORD PlatformBackend::pid() {
return GetCurrentProcessId();
}
WId PlatformBackend::getActiveWID() {
return (WId)GetForegroundWindow();
}
QString illegal(QStringLiteral("<>:\"/\\|?*"));
QStringList illegalNames({ "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7",
"COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9" });
bool PlatformBackend::filenameValid(QString name) {
int periods = 0;
for (QChar c : name) {
if (c == '.') periods++;
if (illegal.contains(c)) return false;
if (c < 32) return false;
}
if (periods == name.length()) return false;
return !illegalNames.contains(name);
}
QString PlatformBackend::getCurrentUser() {
WCHAR username[UNLEN + 1];
DWORD username_len = UNLEN + 1;
QString userName;
if (GetUserName(username, &username_len)) {
userName = QString::fromWCharArray(username, username_len - 1);
}
delete[] username;
return userName;
}
| 33.724138
| 117
| 0.596115
|
mightybruno
|
9f611a6e82a27d5ad177ea13f9ba57ac4311b7de
| 1,332
|
cpp
|
C++
|
DataStructures/lg_P1827_tree.cpp
|
Yurzi/Jlu-C-OJ
|
1bbf0532ded06b31e6516f90270760f11ccb1b3c
|
[
"MIT"
] | 7
|
2020-11-02T13:15:36.000Z
|
2021-07-06T05:09:55.000Z
|
DataStructures/lg_P1827_tree.cpp
|
Yurzi/Jlu-C-OJ
|
1bbf0532ded06b31e6516f90270760f11ccb1b3c
|
[
"MIT"
] | null | null | null |
DataStructures/lg_P1827_tree.cpp
|
Yurzi/Jlu-C-OJ
|
1bbf0532ded06b31e6516f90270760f11ccb1b3c
|
[
"MIT"
] | null | null | null |
#include<iostream>
#include<vector>
using namespace std;
struct node
{
char info;
int left;
int right;
node(char _c,int _left, int _right){
info=_c;
left=_left;
right=_right;
}
};
vector<node> postOrder;
vector<node> inOrder;
int count=-1;
int createTreebyPostAndIn(int l,int r){
int root=-1;
if(l<=r){
++count;
for(int i=l;i<=r;++i){
if(inOrder[i].info==postOrder[count].info){
root=i;
break;
}
}
if(count<postOrder.size()&&root>-1){
inOrder[root].left=createTreebyPostAndIn(l,root-1);
inOrder[root].right=createTreebyPostAndIn(root+1,r);
}
}
return root;
}
void printafterOrder(int i){
if(i==-1){
return;
}
printafterOrder(inOrder[i].left);
printafterOrder(inOrder[i].right);
printf("%c",inOrder[i].info);
return;
}
int main(int argc, char const *argv[])
{
char ctemp=0;
while ((ctemp=getchar())!='\n')
{
if(ctemp!=' ')inOrder.push_back(node(ctemp,-1,-1));
}
while ((ctemp=getchar())!='\n'&&ctemp!=' ')
{
if(ctemp!=' ')postOrder.push_back(node(ctemp,-1,-1));
}
int root=createTreebyPostAndIn(0,inOrder.size()-1);
printafterOrder(root);
return 0;
}
| 18.246575
| 64
| 0.545045
|
Yurzi
|
9f6582ee72bd887fccf911c2093a149b631e3e6d
| 914
|
cpp
|
C++
|
src/ROCInterpolator.cpp
|
timosachsenberg/Fido
|
e46bb879d3405dc7a63ad5c4188f0734a2a7ef82
|
[
"MIT"
] | null | null | null |
src/ROCInterpolator.cpp
|
timosachsenberg/Fido
|
e46bb879d3405dc7a63ad5c4188f0734a2a7ef82
|
[
"MIT"
] | null | null | null |
src/ROCInterpolator.cpp
|
timosachsenberg/Fido
|
e46bb879d3405dc7a63ad5c4188f0734a2a7ef82
|
[
"MIT"
] | null | null | null |
#include "ROCInterpolator.h"
double ROCInterpolator::interpolate(const Array<double> & fps, const Array<double> & tps, double fpVal)
{
bool success = false;
int k;
for (k=0; k<fps.size(); k++)
{
if ( fps[k] > fpVal )
{
success = true;
break;
}
}
if ( ! success )
{
cerr << "Problem: no place to interpolate here (value = " << fpVal << " )" << endl;
exit(1);
}
// k is the first index that passes fpVal
if ( k!= 0 )
return tps[k-1] + (tps[k] - tps[k-1])/(fps[k]-fps[k-1])*(fpVal-fps[k-1]);
else
return tps[0];
}
double ROCInterpolator::interpolateCollection(const Array<Array<double> > & fpCollection, const Array<Array<double> > & tpCollection, double fpVal)
{
double tot = 0.0;
for (int k=0; k<fpCollection.size(); k++)
{
tot += interpolate(fpCollection[k], tpCollection[k], fpVal);
}
return tot / fpCollection.size();
}
| 21.761905
| 147
| 0.592998
|
timosachsenberg
|
9f674ff79f625a217de65b4e7b20161653915228
| 13,236
|
cpp
|
C++
|
src/org/apache/poi/poifs/crypt/cryptoapi/CryptoAPIDecryptor.cpp
|
pebble2015/cpoi
|
6dcc0c5e13e3e722b4ef9fd0baffbf62bf71ead6
|
[
"Apache-2.0"
] | null | null | null |
src/org/apache/poi/poifs/crypt/cryptoapi/CryptoAPIDecryptor.cpp
|
pebble2015/cpoi
|
6dcc0c5e13e3e722b4ef9fd0baffbf62bf71ead6
|
[
"Apache-2.0"
] | null | null | null |
src/org/apache/poi/poifs/crypt/cryptoapi/CryptoAPIDecryptor.cpp
|
pebble2015/cpoi
|
6dcc0c5e13e3e722b4ef9fd0baffbf62bf71ead6
|
[
"Apache-2.0"
] | null | null | null |
// Generated from /POI/java/org/apache/poi/poifs/crypt/cryptoapi/CryptoAPIDecryptor.java
#include <org/apache/poi/poifs/crypt/cryptoapi/CryptoAPIDecryptor.hpp>
#include <java/io/ByteArrayOutputStream.hpp>
#include <java/io/EOFException.hpp>
#include <java/io/IOException.hpp>
#include <java/io/InputStream.hpp>
#include <java/lang/ArrayStoreException.hpp>
#include <java/lang/ClassCastException.hpp>
#include <java/lang/Exception.hpp>
#include <java/lang/IllegalStateException.hpp>
#include <java/lang/NullPointerException.hpp>
#include <java/lang/String.hpp>
#include <java/lang/Throwable.hpp>
#include <java/security/GeneralSecurityException.hpp>
#include <java/security/Key.hpp>
#include <java/security/MessageDigest.hpp>
#include <java/util/Arrays.hpp>
#include <javax/crypto/Cipher.hpp>
#include <javax/crypto/SecretKey.hpp>
#include <javax/crypto/spec/SecretKeySpec.hpp>
#include <org/apache/poi/EncryptedDocumentException.hpp>
#include <org/apache/poi/poifs/crypt/CipherAlgorithm.hpp>
#include <org/apache/poi/poifs/crypt/CryptoFunctions.hpp>
#include <org/apache/poi/poifs/crypt/Decryptor.hpp>
#include <org/apache/poi/poifs/crypt/EncryptionHeader.hpp>
#include <org/apache/poi/poifs/crypt/EncryptionInfo.hpp>
#include <org/apache/poi/poifs/crypt/EncryptionVerifier.hpp>
#include <org/apache/poi/poifs/crypt/HashAlgorithm.hpp>
#include <org/apache/poi/poifs/crypt/cryptoapi/CryptoAPIDecryptor_CryptoAPICipherInputStream.hpp>
#include <org/apache/poi/poifs/crypt/cryptoapi/CryptoAPIDecryptor_StreamDescriptorEntry.hpp>
#include <org/apache/poi/poifs/crypt/cryptoapi/CryptoAPIDocumentInputStream.hpp>
#include <org/apache/poi/poifs/filesystem/DirectoryNode.hpp>
#include <org/apache/poi/poifs/filesystem/DocumentInputStream.hpp>
#include <org/apache/poi/poifs/filesystem/DocumentNode.hpp>
#include <org/apache/poi/poifs/filesystem/Entry.hpp>
#include <org/apache/poi/poifs/filesystem/POIFSFileSystem.hpp>
#include <org/apache/poi/util/BoundedInputStream.hpp>
#include <org/apache/poi/util/IOUtils.hpp>
#include <org/apache/poi/util/LittleEndian.hpp>
#include <org/apache/poi/util/LittleEndianInputStream.hpp>
#include <org/apache/poi/util/StringUtil.hpp>
#include <Array.hpp>
#include <ObjectArray.hpp>
#include <SubArray.hpp>
template<typename ComponentType, typename... Bases> struct SubArray;
namespace poi
{
namespace poifs
{
namespace crypt
{
namespace cryptoapi
{
typedef ::SubArray< ::poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor_StreamDescriptorEntry, ::java::lang::ObjectArray > CryptoAPIDecryptor_StreamDescriptorEntryArray;
} // cryptoapi
} // crypt
} // poifs
} // poi
template<typename T, typename U>
static T java_cast(U* u)
{
if(!u) return static_cast<T>(nullptr);
auto t = dynamic_cast<T>(u);
if(!t) throw new ::java::lang::ClassCastException();
return t;
}
template<typename T>
static T* npc(T* t)
{
if(!t) throw new ::java::lang::NullPointerException();
return t;
}
namespace
{
template<typename F>
struct finally_
{
finally_(F f) : f(f), moved(false) { }
finally_(finally_ &&x) : f(x.f), moved(false) { x.moved = true; }
~finally_() { if(!moved) f(); }
private:
finally_(const finally_&); finally_& operator=(const finally_&);
F f;
bool moved;
};
template<typename F> finally_<F> finally(F f) { return finally_<F>(f); }
}
poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::CryptoAPIDecryptor(const ::default_init_tag&)
: super(*static_cast< ::default_init_tag* >(0))
{
clinit();
}
poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::CryptoAPIDecryptor()
: CryptoAPIDecryptor(*static_cast< ::default_init_tag* >(0))
{
ctor();
}
void poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::init()
{
length = -int64_t(1LL);
chunkSize = -int32_t(1);
}
void poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::ctor()
{
super::ctor();
init();
}
bool poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::verifyPassword(::java::lang::String* password)
{
auto ver = npc(getEncryptionInfo())->getVerifier();
auto skey = generateSecretKey(password, ver);
try {
auto cipher = initCipherForBlock(nullptr, 0, getEncryptionInfo(), skey, ::javax::crypto::Cipher::DECRYPT_MODE);
auto encryptedVerifier = npc(ver)->getEncryptedVerifier();
auto verifier = new ::int8_tArray(npc(encryptedVerifier)->length);
npc(cipher)->update(encryptedVerifier, 0, npc(encryptedVerifier)->length, verifier);
setVerifier(verifier);
auto encryptedVerifierHash = npc(ver)->getEncryptedVerifierHash();
auto verifierHash = npc(cipher)->doFinal(encryptedVerifierHash);
auto hashAlgo = npc(ver)->getHashAlgorithm();
auto hashAlg = ::poi::poifs::crypt::CryptoFunctions::getMessageDigest(hashAlgo);
auto calcVerifierHash = npc(hashAlg)->digest(verifier);
if(::java::util::Arrays::equals(calcVerifierHash, verifierHash)) {
setSecretKey(skey);
return true;
}
} catch (::java::security::GeneralSecurityException* e) {
throw new ::poi::EncryptedDocumentException(static_cast< ::java::lang::Throwable* >(e));
}
return false;
}
javax::crypto::Cipher* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::initCipherForBlock(::javax::crypto::Cipher* cipher, int32_t block) /* throws(GeneralSecurityException) */
{
auto ei = getEncryptionInfo();
auto sk = getSecretKey();
return initCipherForBlock(cipher, block, ei, sk, ::javax::crypto::Cipher::DECRYPT_MODE);
}
javax::crypto::Cipher* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::initCipherForBlock(::javax::crypto::Cipher* cipher, int32_t block, ::poi::poifs::crypt::EncryptionInfo* encryptionInfo, ::javax::crypto::SecretKey* skey, int32_t encryptMode) /* throws(GeneralSecurityException) */
{
clinit();
auto ver = npc(encryptionInfo)->getVerifier();
auto hashAlgo = npc(ver)->getHashAlgorithm();
auto blockKey = new ::int8_tArray(int32_t(4));
::poi::util::LittleEndian::putUInt(blockKey, 0, block);
auto hashAlg = ::poi::poifs::crypt::CryptoFunctions::getMessageDigest(hashAlgo);
npc(hashAlg)->update(npc(skey)->getEncoded());
auto encKey = npc(hashAlg)->digest(blockKey);
auto header = npc(encryptionInfo)->getHeader();
auto keyBits = npc(header)->getKeySize();
encKey = ::poi::poifs::crypt::CryptoFunctions::getBlock0(encKey, keyBits / int32_t(8));
if(keyBits == 40) {
encKey = ::poi::poifs::crypt::CryptoFunctions::getBlock0(encKey, 16);
}
::javax::crypto::SecretKey* key = new ::javax::crypto::spec::SecretKeySpec(encKey, npc(skey)->getAlgorithm());
if(cipher == nullptr) {
cipher = ::poi::poifs::crypt::CryptoFunctions::getCipher(key, npc(header)->getCipherAlgorithm(), nullptr, nullptr, encryptMode);
} else {
npc(cipher)->init_(encryptMode, static_cast< ::java::security::Key* >(key));
}
return cipher;
}
javax::crypto::SecretKey* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::generateSecretKey(::java::lang::String* password, ::poi::poifs::crypt::EncryptionVerifier* ver)
{
clinit();
if(npc(password)->length() > 255) {
password = npc(password)->substring(0, 255);
}
auto hashAlgo = npc(ver)->getHashAlgorithm();
auto hashAlg = ::poi::poifs::crypt::CryptoFunctions::getMessageDigest(hashAlgo);
npc(hashAlg)->update(npc(ver)->getSalt());
auto hash = npc(hashAlg)->digest(::poi::util::StringUtil::getToUnicodeLE(password));
::javax::crypto::SecretKey* skey = new ::javax::crypto::spec::SecretKeySpec(hash, npc(npc(ver)->getCipherAlgorithm())->jceId);
return skey;
}
poi::poifs::crypt::ChunkedCipherInputStream* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::getDataStream(::poi::poifs::filesystem::DirectoryNode* dir) /* throws(IOException, GeneralSecurityException) */
{
throw new ::java::io::IOException(u"not supported"_j);
}
poi::poifs::crypt::ChunkedCipherInputStream* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::getDataStream(::java::io::InputStream* stream, int32_t size, int32_t initialPos) /* throws(IOException, GeneralSecurityException) */
{
return new CryptoAPIDecryptor_CryptoAPICipherInputStream(this, stream, size, initialPos);
}
poi::poifs::filesystem::POIFSFileSystem* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::getSummaryEntries(::poi::poifs::filesystem::DirectoryNode* root, ::java::lang::String* encryptedStream) /* throws(IOException, GeneralSecurityException) */
{
auto es = java_cast< ::poi::poifs::filesystem::DocumentNode* >(npc(root)->getEntry(encryptedStream));
auto dis = npc(root)->createDocumentInputStream(static_cast< ::poi::poifs::filesystem::Entry* >(es));
auto bos = new ::java::io::ByteArrayOutputStream();
::poi::util::IOUtils::copy(dis, bos);
npc(dis)->close();
auto sbis = new CryptoAPIDocumentInputStream(this, npc(bos)->toByteArray_());
auto leis = new ::poi::util::LittleEndianInputStream(sbis);
::poi::poifs::filesystem::POIFSFileSystem* fsOut = nullptr;
{
auto finally0 = finally([&] {
::poi::util::IOUtils::closeQuietly(leis);
::poi::util::IOUtils::closeQuietly(sbis);
});
try {
auto streamDescriptorArrayOffset = static_cast< int32_t >(npc(leis)->readUInt());
npc(leis)->readUInt();
auto skipN = streamDescriptorArrayOffset - int64_t(8LL);
if(npc(sbis)->skip(skipN) < skipN) {
throw new ::java::io::EOFException(u"buffer underrun"_j);
}
npc(sbis)->setBlock(0);
auto encryptedStreamDescriptorCount = static_cast< int32_t >(npc(leis)->readUInt());
auto entries = new CryptoAPIDecryptor_StreamDescriptorEntryArray(encryptedStreamDescriptorCount);
for (auto i = int32_t(0); i < encryptedStreamDescriptorCount; i++) {
auto entry = new CryptoAPIDecryptor_StreamDescriptorEntry();
entries->set(i, entry);
npc(entry)->streamOffset = static_cast< int32_t >(npc(leis)->readUInt());
npc(entry)->streamSize = static_cast< int32_t >(npc(leis)->readUInt());
npc(entry)->block = npc(leis)->readUShort();
auto nameSize = npc(leis)->readUByte();
npc(entry)->flags = npc(leis)->readUByte();
npc(entry)->reserved2 = npc(leis)->readInt();
npc(entry)->streamName = ::poi::util::StringUtil::readUnicodeLE(leis, nameSize);
npc(leis)->readShort();
/* assert((npc(npc(entry)->streamName)->length() == nameSize)) */ ;
}
fsOut = new ::poi::poifs::filesystem::POIFSFileSystem();
for(auto entry : *npc(entries)) {
npc(sbis)->seek(npc(entry)->streamOffset);
npc(sbis)->setBlock(npc(entry)->block);
::java::io::InputStream* is = new ::poi::util::BoundedInputStream(sbis, npc(entry)->streamSize);
npc(fsOut)->createDocument(is, npc(entry)->streamName);
npc(is)->close();
}
} catch (::java::lang::Exception* e) {
::poi::util::IOUtils::closeQuietly(fsOut);
if(dynamic_cast< ::java::security::GeneralSecurityException* >(e) != nullptr) {
throw java_cast< ::java::security::GeneralSecurityException* >(e);
} else if(dynamic_cast< ::java::io::IOException* >(e) != nullptr) {
throw java_cast< ::java::io::IOException* >(e);
} else {
throw new ::java::io::IOException(u"summary entries can't be read"_j, e);
}
}
}
return fsOut;
}
int64_t poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::getLength()
{
if(length == -int64_t(1LL)) {
throw new ::java::lang::IllegalStateException(u"Decryptor.getDataStream() was not called"_j);
}
return length;
}
void poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::setChunkSize(int32_t chunkSize)
{
this->chunkSize = chunkSize;
}
poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::clone() /* throws(CloneNotSupportedException) */
{
return java_cast< CryptoAPIDecryptor* >(super::clone());
}
extern java::lang::Class *class_(const char16_t *c, int n);
java::lang::Class* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::class_()
{
static ::java::lang::Class* c = ::class_(u"org.apache.poi.poifs.crypt.cryptoapi.CryptoAPIDecryptor", 55);
return c;
}
java::io::InputStream* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::getDataStream(::poi::poifs::filesystem::NPOIFSFileSystem* fs)
{
return super::getDataStream(fs);
}
java::io::InputStream* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::getDataStream(::poi::poifs::filesystem::OPOIFSFileSystem* fs)
{
return super::getDataStream(fs);
}
java::io::InputStream* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::getDataStream(::poi::poifs::filesystem::POIFSFileSystem* fs)
{
return super::getDataStream(fs);
}
java::lang::Class* poi::poifs::crypt::cryptoapi::CryptoAPIDecryptor::getClass0()
{
return class_();
}
| 43.396721
| 286
| 0.681399
|
pebble2015
|
9f68aa95585aa41d77e0ed106d383dd597cbf049
| 247
|
cpp
|
C++
|
matu379.cpp
|
NewtonVan/Fxxk_Y0u_m47u
|
d303c7f13c074b5462ac8390a9ff94e546099fac
|
[
"MIT"
] | 1
|
2020-09-26T16:47:16.000Z
|
2020-09-26T16:47:16.000Z
|
matu379.cpp
|
NewtonVan/Fxxk_Y0u_m47u
|
d303c7f13c074b5462ac8390a9ff94e546099fac
|
[
"MIT"
] | null | null | null |
matu379.cpp
|
NewtonVan/Fxxk_Y0u_m47u
|
d303c7f13c074b5462ac8390a9ff94e546099fac
|
[
"MIT"
] | 1
|
2020-09-26T16:47:40.000Z
|
2020-09-26T16:47:40.000Z
|
class CNumber
: public CNumberFactory
{
int num;
public:
CNumber(){}
void Add(int number)
{
num+= number;
}
void Sub(int number)
{
num-= number;
}
int GetValue()
{
return num;
}
void SetValue(int number)
{
num= number;
}
};
| 9.88
| 26
| 0.611336
|
NewtonVan
|
9f68f9c4a02e34a149a3938ce62b0ad322608fc9
| 1,526
|
cpp
|
C++
|
libs/numeric/mtl/test/forms_test.cpp
|
lit-uriy/mtl4-mirror
|
37cf7c2847165d3537cbc3400cb5fde6f80e3d8b
|
[
"MTLL"
] | 24
|
2019-03-26T15:25:45.000Z
|
2022-03-26T10:00:45.000Z
|
libs/numeric/mtl/test/forms_test.cpp
|
lit-uriy/mtl4-mirror
|
37cf7c2847165d3537cbc3400cb5fde6f80e3d8b
|
[
"MTLL"
] | 2
|
2020-04-17T12:35:32.000Z
|
2021-03-03T15:46:25.000Z
|
libs/numeric/mtl/test/forms_test.cpp
|
lit-uriy/mtl4-mirror
|
37cf7c2847165d3537cbc3400cb5fde6f80e3d8b
|
[
"MTLL"
] | 10
|
2019-12-01T13:40:30.000Z
|
2022-01-14T08:39:54.000Z
|
// Software License for MTL
//
// Copyright (c) 2007 The Trustees of Indiana University.
// 2008 Dresden University of Technology and the Trustees of Indiana University.
// 2010 SimuNova UG (haftungsbeschränkt), www.simunova.com.
// All rights reserved.
// Authors: Peter Gottschling and Andrew Lumsdaine
//
// This file is part of the Matrix Template Library
//
// See also license.mtl.txt in the distribution.
#include <iostream>
#include <cmath>
#include <boost/numeric/mtl/mtl.hpp>
template <typename ResMatrix, typename ArgMatrix>
void test(const ResMatrix&, const ArgMatrix& B)
{
ResMatrix C(B * B);
C+= trans(B) * B;
C+= trans(B) * B * B;
#if 0
std::cout << typeid(typename mtl::traits::category<mtl::mat::mat_mat_times_expr<ArgMatrix, ArgMatrix> >::type).name() << '\n';
std::cout << typeid(typename mtl::traits::category<mtl::mat::rscaled_view<ArgMatrix, double> >::type).name() << '\n';
char c; std::cin >> c;
#endif
C+= B * 3.5 * B * B;
C+= trans(B) * 3.5 * B * B;
C+= 3.5 * ArgMatrix(B * B);
C= 3.5 * ArgMatrix(B * B);
//C+= 3.5 * (B * B);
//C= 3.5 * (B * B);
}
int main(int, char**)
{
using namespace mtl;
typedef mat::parameters<tag::row_major, mtl::index::c_index, mtl::fixed::dimensions<2, 2>, true> fmat_para;
float ma[2][2]= {{2., 3.}, {4., 5.}};
dense2D<float> A_dyn(ma);
dense2D<float, fmat_para> A_stat(ma);
test(A_dyn, A_dyn);
//test(A_dyn, A_stat);
return 0;
}
| 26.77193
| 127
| 0.607471
|
lit-uriy
|
9f69caee1f05d4fe28323644c0d7adb9982389e5
| 33,406
|
cpp
|
C++
|
sources/unittests/HJIPDE_solve/UTest_HJIPDE_solve.cpp
|
mdoshi96/beacls
|
860426ed1336d9539dea195987efcdd8a8276a1c
|
[
"BSD-2-Clause",
"BSD-2-Clause-FreeBSD"
] | 30
|
2017-12-17T22:57:50.000Z
|
2022-01-30T17:06:34.000Z
|
sources/unittests/HJIPDE_solve/UTest_HJIPDE_solve.cpp
|
codingblazes/beacls
|
6c1d685ee00e3b39d8100c4a170a850682679abc
|
[
"BSD-2-Clause",
"BSD-2-Clause-FreeBSD"
] | 2
|
2017-03-24T06:18:16.000Z
|
2017-04-04T16:16:06.000Z
|
sources/unittests/HJIPDE_solve/UTest_HJIPDE_solve.cpp
|
codingblazes/beacls
|
6c1d685ee00e3b39d8100c4a170a850682679abc
|
[
"BSD-2-Clause",
"BSD-2-Clause-FreeBSD"
] | 8
|
2018-07-06T01:47:21.000Z
|
2021-07-23T15:50:34.000Z
|
#define _USE_MATH_DEFINES
#include <levelset/levelset.hpp>
#include <helperOC/helperOC.hpp>
#include <helperOC/DynSys/DynSys/DynSysSchemeData.hpp>
#include <helperOC/DynSys/DubinsCar/DubinsCar.hpp>
#include <helperOC/DynSys/DubinsCarCAvoid/DubinsCarCAvoid.hpp>
#include <helperOC/DynSys/Air3D/Air3D.hpp>
#include <sstream>
#include <iomanip>
#include "UTest_HJIPDE_solve.hpp"
#ifdef _OPENMP
#include <omp.h>
#endif
bool check_and_make_message(
std::string& message,
const std::vector<beacls::FloatVec>& expected_datas,
const std::vector<beacls::FloatVec>& result_datas,
const FLOAT_TYPE small
) {
FLOAT_TYPE min_diff = std::numeric_limits<FLOAT_TYPE>::max();
FLOAT_TYPE max_diff = 0;
FLOAT_TYPE first_diff = 0;
FLOAT_TYPE sum_of_square = 0;
size_t min_diff_t = 0;
size_t max_diff_t = 0;
size_t first_diff_t = 0;
size_t min_diff_index = 0;
size_t max_diff_index = 0;
size_t first_diff_index = 0;
size_t num_of_diffs = 0;
size_t num_of_datas = 0;
bool allSucceed = true;
for (size_t t = 0; t < result_datas.size(); ++t) {
const beacls::FloatVec& expected_data = expected_datas[t];
const beacls::FloatVec& result_data = result_datas[t];
for (size_t index = 0; index < result_data.size(); ++index) {
FLOAT_TYPE expected_result = expected_data[index];
FLOAT_TYPE result = result_data[index];
++num_of_datas;
const FLOAT_TYPE diff = std::abs(expected_result - result);
if (diff > small) {
allSucceed = false;
if (min_diff > diff) {
min_diff = diff;
min_diff_t = t;
min_diff_index = index;
}
if (max_diff < diff) {
max_diff = diff;
max_diff_t = t;
max_diff_index = index;
}
if (first_diff == 0) {
first_diff = diff;
first_diff_t = t;
first_diff_index = index;
}
sum_of_square += diff * diff;
++num_of_diffs;
}
}
}
if (!allSucceed) {
const FLOAT_TYPE rms = std::sqrt(sum_of_square / num_of_datas);
std::stringstream ss;
ss << "Error: # of Diffs = " << num_of_diffs << ", RMS = " << std::setprecision(16) << rms << std::resetiosflags(std::ios_base::floatfield)
<< ", First Diff " << std::setprecision(16) << first_diff << std::resetiosflags(std::ios_base::floatfield) << "@(" << first_diff_t << "," << first_diff_index
<< "), Max Diff " << std::setprecision(16) << max_diff << std::resetiosflags(std::ios_base::floatfield) << "@(" << max_diff_t << "," << max_diff_index
<< "), Min Diff " << std::setprecision(16) << min_diff << std::resetiosflags(std::ios_base::floatfield) << "@(" << min_diff_t << "," << min_diff_index
<< ")" << std::endl;
message.append(ss.str());
}
return allSucceed;
}
bool run_UTest_HJIPDE_solve_minWith(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& tau,
beacls::FloatVec& data0,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
/*!< selecting 'zero' computes reachable tube(usually, choose this option)
selecting 'none' computes reachable set
selecting 'data0' computes reachable tube, but only use this if there are
obstacles_ptrs(constraint / avoid sets) in the state space
*/
std::vector<helperOC::HJIPDE::MinWithType> minWiths{helperOC::HJIPDE::MinWithType_None, helperOC::HJIPDE::MinWithType_Zero};
bool result = true;
for (size_t i = 0; i < minWiths.size(); ++i) {
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_i = expected_datas[i];
hjipde->solve(datas, stoptau, extraOuts, data0, tau, schemeData, minWiths[i], extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty: " << i << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_i.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << i << " : " << datas.size() << "!= " << expected_datas_i.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_i,
datas,
small
);
if(hjipde) delete hjipde;
}
return result;
}
/*
@brief Test using time-varying targets
*/
bool run_UTest_HJIPDE_solve_tvTarget(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& tau,
beacls::FloatVec& data0,
const FLOAT_TYPE radius,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
const levelset::HJI_Grid *g = schemeData->get_grid();
std::vector<beacls::FloatVec> targets(tau.size());
beacls::FloatVec center{ 1.5,1.5,0. };
beacls::IntegerVec pdDims{ 2 }; //!< 2nd diemension is periodic
for (size_t i = 0; i < targets.size(); ++i) {
levelset::BasicShape* shape = new levelset::ShapeCylinder(pdDims, center, ((FLOAT_TYPE)i+1)/tau.size()*radius);
shape->execute(g, targets[i]);
delete shape;
}
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_None;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.targets = targets;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas, stoptau, extraOuts, data0, tau, schemeData, minWith, extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_0,
datas,
small
);
if (hjipde) delete hjipde;
return result;
}
/*
@brief Test using single obstacle
*/
bool run_UTest_HJIPDE_solve_singleObs(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& tau,
beacls::FloatVec& data0,
const FLOAT_TYPE radius,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
const levelset::HJI_Grid *g = schemeData->get_grid();
std::vector<beacls::FloatVec> obstacles(1);
beacls::FloatVec center{ 1.5,1.5,0. };
beacls::IntegerVec pdDims{ 2 }; //!< 2nd diemension is periodic
std::vector<beacls::FloatVec> targets(1);
targets[0] = data0;
levelset::BasicShape* shape = new levelset::ShapeCylinder(pdDims, center, (FLOAT_TYPE)(0.75*radius));
shape->execute(g, obstacles[0]);
delete shape;
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_None;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.targets = targets;
extraArgs.obstacles = obstacles;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas, stoptau, extraOuts, data0, tau, schemeData, minWith, extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_0,
datas,
small
);
if (hjipde) delete hjipde;
return result;
}
/*
@brief Test using time-varying obstacle
*/
bool run_UTest_HJIPDE_solve_tvObs(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& tau,
beacls::FloatVec& data0,
const FLOAT_TYPE radius,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
const levelset::HJI_Grid *g = schemeData->get_grid();
std::vector<beacls::FloatVec> obstacles(tau.size());
beacls::FloatVec center{ 1.5,1.5,0. };
beacls::IntegerVec pdDims{ 2 }; //!< 2nd diemension is periodic
std::vector<beacls::FloatVec> targets(1);
targets[0] = data0;
for (size_t i = 0; i < obstacles.size(); ++i) {
levelset::BasicShape* shape = new levelset::ShapeCylinder(pdDims, center, ((FLOAT_TYPE)i+1) / obstacles.size()*radius);
shape->execute(g, obstacles[i]);
delete shape;
}
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_None;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.targets = targets;
extraArgs.obstacles = obstacles;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas, stoptau, extraOuts, data0, tau, schemeData, minWith, extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_0,
datas,
small
);
if (hjipde) delete hjipde;
return result;
}
/*
@brief Test using single obstacle but few time steps
*/
bool run_UTest_HJIPDE_solve_obs_stau(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& data0,
const FLOAT_TYPE radius,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
const levelset::HJI_Grid *g = schemeData->get_grid();
std::vector<beacls::FloatVec> obstacles(1);
beacls::FloatVec center{ 1.5,1.5,0. };
beacls::IntegerVec pdDims{ 2 }; //!< 2nd diemension is periodic
std::vector<beacls::FloatVec> targets(1);
targets[0] = data0;
levelset::BasicShape* shape = new levelset::ShapeCylinder(pdDims, center, (FLOAT_TYPE)(0.75*radius));
shape->execute(g, obstacles[0]);
delete shape;
FLOAT_TYPE local_tau_bottom = 0.;
FLOAT_TYPE local_tau_top = 2.;
size_t local_tau_num = 5;
beacls::FloatVec local_tau(local_tau_num);
for (size_t i = 0; i < local_tau_num; ++i) {
local_tau[i] = local_tau_bottom + i * (local_tau_top - local_tau_bottom) / (local_tau_num - 1);
}
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_None;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.targets = targets;
extraArgs.obstacles = obstacles;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas, stoptau, extraOuts, data0, local_tau, schemeData, minWith, extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_0,
datas,
small
);
if (hjipde) delete hjipde;
return result;
}
/*
@brief Test the inclusion of initial state
*/
bool run_UTest_HJIPDE_solve_stopInit(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& data0,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
FLOAT_TYPE local_tau_bottom = 0.;
FLOAT_TYPE local_tau_top = 2.;
size_t local_tau_num = 50;
beacls::FloatVec local_tau(local_tau_num);
for (size_t i = 0; i < local_tau_num; ++i) {
local_tau[i] = local_tau_bottom + i * (local_tau_top - local_tau_bottom) / (local_tau_num - 1);
}
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_None;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.stopInit = beacls::FloatVec{ (FLOAT_TYPE)-1.1, (FLOAT_TYPE)-1.1,(FLOAT_TYPE)0 };
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas, stoptau, extraOuts, data0, local_tau, schemeData, minWith, extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_0,
datas,
small
);
if (hjipde) delete hjipde;
return result;
}
/*
@brief Test the inclusion of initial state
*/
bool run_UTest_HJIPDE_solve_stopSetInclude(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& data0,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
const levelset::HJI_Grid *g = schemeData->get_grid();
beacls::FloatVec stopSetInclude;
levelset::BasicShape* shape = new levelset::ShapeSphere(beacls::FloatVec{(FLOAT_TYPE)-1.1, (FLOAT_TYPE)1.1, (FLOAT_TYPE)0}, (FLOAT_TYPE)0.5);
shape->execute(g, stopSetInclude);
delete shape;
FLOAT_TYPE local_tau_bottom = 0.;
FLOAT_TYPE local_tau_top = 2.;
size_t local_tau_num = 5;
beacls::FloatVec local_tau(local_tau_num);
for (size_t i = 0; i < local_tau_num; ++i) {
local_tau[i] = local_tau_bottom + i * (local_tau_top - local_tau_bottom) / (local_tau_num - 1);
}
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_None;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.stopSetInclude = stopSetInclude;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas, stoptau, extraOuts, data0, local_tau, schemeData, minWith, extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_0,
datas,
small
);
if (hjipde) delete hjipde;
return result;
}
/*
@brief Test intersection of some set
*/
bool run_UTest_HJIPDE_solve_stopSetIntersect(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& data0,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
const levelset::HJI_Grid *g = schemeData->get_grid();
beacls::FloatVec stopSetIntersect;
levelset::BasicShape* shape = new levelset::ShapeSphere(beacls::FloatVec{-1.25, 1.25, 0}, 0.5);
shape->execute(g, stopSetIntersect);
delete shape;
FLOAT_TYPE local_tau_bottom = 0.;
FLOAT_TYPE local_tau_top = 1.;
size_t local_tau_num = 11;
beacls::FloatVec local_tau(local_tau_num);
for (size_t i = 0; i < local_tau_num; ++i) {
local_tau[i] = local_tau_bottom + i * (local_tau_top - local_tau_bottom) / (local_tau_num - 1);
}
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_None;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.stopSetIntersect = stopSetIntersect;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas, stoptau, extraOuts, data0, local_tau, schemeData, minWith, extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_0,
datas,
small
);
if (hjipde) delete hjipde;
return result;
}
/*
@brief Test the intermediate plotting
*/
bool run_UTest_HJIPDE_solve_plotData(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& data0,
const FLOAT_TYPE radius,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
const levelset::HJI_Grid *g = schemeData->get_grid();
FLOAT_TYPE local_tau_bottom = 0.;
FLOAT_TYPE local_tau_top = 2.;
size_t local_tau_num = 51;
beacls::FloatVec local_tau(local_tau_num);
for (size_t i = 0; i < local_tau_num; ++i) {
local_tau[i] = local_tau_bottom + i * (local_tau_top - local_tau_bottom) / (local_tau_num - 1);
}
std::vector<beacls::FloatVec> obstacles(local_tau.size());
beacls::FloatVec center{ 1.5,1.5,0. };
beacls::IntegerVec pdDims{ 2 }; //!< 2nd diemension is periodic
for (size_t i = 0; i < obstacles.size(); ++i) {
levelset::BasicShape* shape = new levelset::ShapeCylinder(pdDims, center, ((FLOAT_TYPE)i + 1) / obstacles.size()*radius);
shape->execute(g, obstacles[i]);
delete shape;
}
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_None;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.obstacles = obstacles;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas, stoptau, extraOuts, data0, local_tau, schemeData, minWith, extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_0,
datas,
small
);
if (hjipde) delete hjipde;
return result;
}
/*
@brief Test starting from saved data (where data0 has dimension g.dim + 1)
*/
bool run_UTest_HJIPDE_solve_savedData(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
helperOC::DynSysSchemeData* schemeData,
beacls::FloatVec& tau,
beacls::FloatVec& data0,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_Zero;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas1;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas1, stoptau, extraOuts, data0, tau, schemeData, minWith, extraArgs);
if (datas1.empty()) {
std::stringstream ss;
ss << "Error result1 is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas1.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas1.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
//!< Cut off data 1
FLOAT_TYPE tcutoff = 0.5;
size_t istart = 1;
for (size_t i = 0; i < tau.size(); ++i) {
if (tau[i] > tcutoff) {
istart = i+1;
break;
}
}
extraArgs.istart = istart;
std::vector<beacls::FloatVec > dataSaved(tau.size());
std::copy(datas1.cbegin(), datas1.cbegin() + istart, dataSaved.begin());
std::vector<beacls::FloatVec > datas2;
hjipde->solve(datas2, stoptau, extraOuts, dataSaved, tau, schemeData, minWith, extraArgs);
if (datas2.empty()) {
std::stringstream ss;
ss << "Error result2 is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas2.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas2.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
std::string tmp_message;
result &= check_and_make_message(
tmp_message,
expected_datas_0,
datas1,
small
);
if (!tmp_message.empty()) {
message = std::string("Data1: ") + tmp_message;
tmp_message.clear();
}
result &= check_and_make_message(
tmp_message,
expected_datas_0,
datas2,
small
);
if (!tmp_message.empty()) {
message = std::string("Data2: ") + tmp_message;
tmp_message.clear();
}
result &= check_and_make_message(
tmp_message,
datas1,
datas2,
small
);
if (!tmp_message.empty()) {
message = std::string("Data1-Data2: ") + tmp_message;
tmp_message.clear();
}
if (hjipde) delete hjipde;
return result;
}
/*
@brief Test the intermediate plotting
*/
bool run_UTest_HJIPDE_solve_stopConverge(
std::string &message,
const std::vector<std::vector<beacls::FloatVec > >& expected_datas,
const bool isMiddleModel,
const bool isDubinsCarCAvoidModel,
const FLOAT_TYPE small,
const helperOC::ExecParameters& execParameters
) {
// Grid
beacls::IntegerVec Ns;
beacls::FloatVec grid_min;
beacls::FloatVec grid_max;
FLOAT_TYPE captureRadius;
if(!isMiddleModel){
Ns = beacls::IntegerVec{ 41, 41, 41 }; //!< Number of grid points per dimension
grid_min = beacls::FloatVec{ -5, -5, (FLOAT_TYPE)-M_PI }; //!< Lower corner of computation domain
grid_max = beacls::FloatVec{ 5, 5, (FLOAT_TYPE)M_PI }; //!< Upper corner of computation domain
captureRadius = 1;
}else{
Ns = beacls::IntegerVec{ 61, 61, 61 }; //!< Number of grid points per dimension
grid_min = beacls::FloatVec{ -25, -20, 0 }; //!< Lower corner of computation domain
grid_max = beacls::FloatVec{ 25, 20, (FLOAT_TYPE)(2*M_PI) }; //!< Upper corner of computation domain
captureRadius = 5;
}
beacls::IntegerVec pdDims{ 2 }; //!< 2nd diemension is periodic
FLOAT_TYPE va = 5;
FLOAT_TYPE vb = 5;
FLOAT_TYPE uMax = 1;
FLOAT_TYPE dMax = 1;
//!< problem parameters
FLOAT_TYPE speed = 1;
FLOAT_TYPE wMax = 1;
levelset::HJI_Grid* g = helperOC::createGrid(grid_min, grid_max, Ns, pdDims);
levelset::BasicShape* shape;
beacls::FloatVec center{ 0.,0.,0. }; //!< Center coordinate
shape = new levelset::ShapeCylinder(pdDims, center, captureRadius);
beacls::FloatVec data0;
shape->execute(g, data0);
if (shape) delete shape;
helperOC::DynSys* dynSys;
if(isDubinsCarCAvoidModel)
dynSys = new helperOC::DubinsCarCAvoid(beacls::FloatVec{(FLOAT_TYPE)0, (FLOAT_TYPE)0, (FLOAT_TYPE)0}, uMax, dMax, va, vb);
else
dynSys = new helperOC::DubinsCar(beacls::FloatVec{(FLOAT_TYPE)0, (FLOAT_TYPE)0, (FLOAT_TYPE)0}, wMax, speed);
//!< time vector
FLOAT_TYPE t0 = 0;
FLOAT_TYPE tMax = 5;
FLOAT_TYPE dt = (FLOAT_TYPE)0.01;
beacls::FloatVec tau = generateArithmeticSequence<FLOAT_TYPE>(t0, dt, tMax);
helperOC::DynSysSchemeData* schemeData = new helperOC::DynSysSchemeData;
schemeData->set_grid(g); //!< Grid MUST be specified!
//!<Dynamical system parameters
schemeData->dynSys = dynSys;
schemeData->uMode = helperOC::DynSys_UMode_Max;
schemeData->dMode = helperOC::DynSys_DMode_Min;
helperOC::HJIPDE::MinWithType minWith = helperOC::HJIPDE::MinWithType_Zero;
bool result = true;
helperOC::HJIPDE_extraArgs extraArgs;
helperOC::HJIPDE_extraOuts extraOuts;
extraArgs.keepLast = false;
extraArgs.execParameters = execParameters;
extraArgs.stopConverge = true;
extraArgs.convergeThreshold = (FLOAT_TYPE)1e-3;
helperOC::HJIPDE* hjipde = new helperOC::HJIPDE();
beacls::FloatVec stoptau;
std::vector<beacls::FloatVec > datas;
const std::vector<beacls::FloatVec >& expected_datas_0 = expected_datas[0];
hjipde->solve(datas, stoptau, extraOuts, data0, tau, schemeData, minWith, extraArgs);
if (datas.empty()) {
std::stringstream ss;
ss << "Error result is empty" << std::endl;
message.append(ss.str());
return false;
}
if (datas.size() != expected_datas_0.size()) {
std::stringstream ss;
ss << "Error time length of results is different: " << datas.size() << "!= " << expected_datas_0.size() << std::endl;
message.append(ss.str());
return false;
}
result &= check_and_make_message(
message,
expected_datas_0,
datas,
small
);
if (hjipde) delete hjipde;
if (dynSys) delete dynSys;
if (schemeData) delete schemeData;
return result;
}
bool run_UTest_HJIPDE_solve(
std::string &message,
const std::vector<std::string>& expects_filenames,
const HJIPDE_solve_WhatTest whatTest,
const HJIPDE_solve_Shape shapeType,
const beacls::UVecType type,
const FLOAT_TYPE small_diff,
const size_t chunk_size,
const int num_of_threads,
const int num_of_gpus,
const levelset::DelayedDerivMinMax_Type delayedDerivMinMax,
const bool enable_user_defined_dynamics_on_gpu
) {
helperOC::ExecParameters execParameters;
execParameters.useCuda = (type == beacls::UVecType_Cuda) ? true : false;
execParameters.line_length_of_chunk = chunk_size;
execParameters.num_of_threads = num_of_threads;
execParameters.num_of_gpus = num_of_gpus;
execParameters.delayedDerivMinMax = delayedDerivMinMax;
execParameters.enable_user_defined_dynamics_on_gpu = enable_user_defined_dynamics_on_gpu;
const size_t line_length_of_chunk = chunk_size;
const FLOAT_TYPE small = small_diff;
std::vector<std::vector<beacls::FloatVec > > expected_datas(expects_filenames.size());
std::transform(expects_filenames.cbegin(), expects_filenames.cend(), expected_datas.begin(), ([&message](const auto& rhs) {
std::vector<beacls::FloatVec > datas;
beacls::FloatVec data;
beacls::MatFStream* rhs_fs = beacls::openMatFStream(rhs, beacls::MatOpenMode_Read);
beacls::IntegerVec read_Ns;
if (!load_vector(data, std::string("data"), read_Ns, false, rhs_fs)) {
std::stringstream ss;
ss << "Cannot open expected result file: " << rhs.c_str() << std::endl;
message.append(ss.str());
beacls::closeMatFStream(rhs_fs);
return std::vector<beacls::FloatVec >();
}
datas.resize(read_Ns[read_Ns.size() - 1]);
size_t num_of_elements = std::accumulate(read_Ns.cbegin(), read_Ns.cbegin() + read_Ns.size() - 1, (size_t)1, [](const auto& lhs, const auto& rhs) { return lhs * rhs; });
for (size_t t = 0; t < datas.size(); ++t){
datas[t].resize(num_of_elements);
std::copy(data.cbegin() + t*num_of_elements, data.cbegin() + (t + 1)*num_of_elements, datas[t].begin());
}
beacls::closeMatFStream(rhs_fs);
return datas;
}));
if (std::any_of(expected_datas.cbegin(), expected_datas.cend(), [](const auto& rhs) { return rhs.empty(); })) {
return false;
}
// Grid
beacls::FloatVec grid_min{ -5, -5, (FLOAT_TYPE)-M_PI }; //!< Lower corner of computation domain
beacls::FloatVec grid_max{ 5, 5, (FLOAT_TYPE)M_PI }; //!< Upper corner of computation domain
beacls::IntegerVec Ns = beacls::IntegerVec{ 41, 41, 41 }; //!< Number of grid points per dimension
beacls::IntegerVec pdDims{ 2 }; //!< 2nd diemension is periodic
levelset::HJI_Grid* g = helperOC::createGrid(grid_min, grid_max, Ns, pdDims);
// state space dimensions
// target set
levelset::BasicShape* shape;
FLOAT_TYPE radius = 1;
beacls::FloatVec center{ 0.,0.,0.}; //!< Center coordinate
switch (shapeType) {
default:
case HJIPDE_solve_Shape_Invalid:
{
std::stringstream ss;
ss << "Error Invalid Shape type: " << shapeType << std::endl;
message.append(ss.str());
}
return false;
case HJIPDE_solve_Shape_Cylinder:
shape = new levelset::ShapeCylinder(pdDims, center, radius);
break;
case HJIPDE_solve_Shape_Sphere:
shape = new levelset::ShapeSphere(center, radius);
break;
case HJIPDE_solve_Shape_RectangleByCorner:
shape = new levelset::ShapeRectangleByCorner(beacls::FloatVec{-radius, -radius, -radius}, beacls::FloatVec{radius, radius, radius});
break;
case HJIPDE_solve_Shape_RectangleByCenter:
shape = new levelset::ShapeRectangleByCenter(center, beacls::FloatVec{radius,radius,radius});
break;
}
beacls::FloatVec data0;
shape->execute(g, data0);
//!< time vector
FLOAT_TYPE t0 = 0;
FLOAT_TYPE tMax = 2;
FLOAT_TYPE dt = (FLOAT_TYPE)0.025;
beacls::FloatVec tau = generateArithmeticSequence<FLOAT_TYPE>(t0, dt, tMax);
// If intermediate results are not needed, use
// beacls::FloatVec tau = generateArithmeticSequence(t0, tMax, tMax);
//!< problem parameters
FLOAT_TYPE speed = 1;
FLOAT_TYPE wMax = 1;
//!< Pack problem parameters
helperOC::DynSysSchemeData* schemeData = new helperOC::DynSysSchemeData;
schemeData->set_grid(g); //!< Grid MUST be specified!
//!<Dynamical system parameters
helperOC::DubinsCar* dCar = new helperOC::DubinsCar(beacls::FloatVec{(FLOAT_TYPE)0, (FLOAT_TYPE)0, (FLOAT_TYPE)0}, wMax, speed);
schemeData->dynSys = dCar;
bool result = true;
switch (whatTest) {
default:
case HJIPDE_solve_WhatTest_Invalid:
{
std::stringstream ss;
ss << "Error Invalid test type: " << whatTest << std::endl;
message.append(ss.str());
}
result = false;
break;
case HJIPDE_solve_WhatTest_minWith:
result = run_UTest_HJIPDE_solve_minWith(message, expected_datas, schemeData, tau, data0,small, execParameters);
break;
case HJIPDE_solve_WhatTest_tvTargets:
result = run_UTest_HJIPDE_solve_tvTarget(message, expected_datas, schemeData, tau, data0, radius,small, execParameters);
break;
case HJIPDE_solve_WhatTest_singleObs:
result = run_UTest_HJIPDE_solve_singleObs(message, expected_datas, schemeData, tau, data0, radius,small, execParameters);
break;
case HJIPDE_solve_WhatTest_tvObs:
result = run_UTest_HJIPDE_solve_tvObs(message, expected_datas, schemeData, tau, data0, radius,small, execParameters);
break;
case HJIPDE_solve_WhatTest_obs_stau:
result = run_UTest_HJIPDE_solve_obs_stau(message, expected_datas, schemeData, data0, radius,small, execParameters);
break;
case HJIPDE_solve_WhatTest_stopInit:
result = run_UTest_HJIPDE_solve_stopInit(message, expected_datas, schemeData, data0,small, execParameters);
break;
case HJIPDE_solve_WhatTest_stopSetInclude:
result = run_UTest_HJIPDE_solve_stopSetInclude(message, expected_datas, schemeData, data0,small, execParameters);
break;
case HJIPDE_solve_WhatTest_stopSetIntersect:
result = run_UTest_HJIPDE_solve_stopSetIntersect(message, expected_datas, schemeData, data0,small, execParameters);
break;
case HJIPDE_solve_WhatTest_plotData:
result = run_UTest_HJIPDE_solve_plotData(message, expected_datas, schemeData, data0, radius,small, execParameters);
break;
case HJIPDE_solve_WhatTest_savedData:
result = run_UTest_HJIPDE_solve_savedData(message, expected_datas, schemeData, tau, data0,small, execParameters);
break;
case HJIPDE_solve_WhatTest_stopConvergeSmallDubinsCar:
result = run_UTest_HJIPDE_solve_stopConverge(message, expected_datas, false, false,small, execParameters);
break;
case HJIPDE_solve_WhatTest_stopConvergeSmallDubinsCarCAvoid:
result = run_UTest_HJIPDE_solve_stopConverge(message, expected_datas, false, true,small, execParameters);
break;
}
if (dCar) delete dCar;
if (shape) delete shape;
if (schemeData) delete schemeData;
if (g) delete g;
return result;
}
| 32.464529
| 171
| 0.719003
|
mdoshi96
|
9f6bda2090fbcd47d68a98af00d6bad5ebee2d66
| 1,086
|
cpp
|
C++
|
SVIEngine/jni/SVI/Utils/SVITime.cpp
|
Samsung/SVIEngine
|
36964f5b296317a3b7b2825137fef921a8c94973
|
[
"Apache-2.0"
] | 27
|
2015-04-24T07:14:55.000Z
|
2020-01-24T16:16:37.000Z
|
SVIEngine/jni/SVI/Utils/SVITime.cpp
|
Lousnote5/SVIEngine
|
36964f5b296317a3b7b2825137fef921a8c94973
|
[
"Apache-2.0"
] | null | null | null |
SVIEngine/jni/SVI/Utils/SVITime.cpp
|
Lousnote5/SVIEngine
|
36964f5b296317a3b7b2825137fef921a8c94973
|
[
"Apache-2.0"
] | 15
|
2015-12-08T14:46:19.000Z
|
2020-01-21T19:26:41.000Z
|
#include "SVITime.h"
#include "../SVICores.h"
#include <time.h>
#include <stdarg.h>
#define SEC_A_DAY 86400
SVIUInt SVITime::currentTimeMillis() {
struct timeval t;
gettimeofday(&t, NULL);
//time is measured as millisecond.
SVIUInt currentTime = (SVIUInt)((t.tv_sec % SEC_A_DAY)*1000 + (t.tv_usec / 1000));
return currentTime;
}
SVICheckTime::SVICheckTime(SVIChar* name, SVIBool reportTime) {
mReportTime = reportTime;
if( mReportTime ) {
mStartTime = SVITime::currentTimeMillis();
if( name != NULL )
snprintf(mName, 128, "%s", name);
}
}
SVICheckTime::~SVICheckTime() {
if( mReportTime ) {
SVIUInt endTime = SVITime::currentTimeMillis();
SVIUInt elapsedTime = endTime - mStartTime;
LOGI("%s : %d", mName, elapsedTime);
}
}
void SVICheckTime::setName(SVIChar* fmt, ...) {
va_list ap;
va_start(ap, fmt);
vsprintf(mName, fmt, ap);
va_end(ap);
}
void SVICheckTime::setName(SVIChar* name, SVIChar* fmt, ...) {
SVIChar temp[128];
va_list ap;
va_start(ap, fmt);
vsprintf(temp, fmt, ap);
va_end(ap);
snprintf(mName, 128, "%s %s", name, temp);
}
| 19.392857
| 83
| 0.676796
|
Samsung
|
9f6e094119dce5e24805e7862a497143e0b0f38e
| 35
|
cpp
|
C++
|
library/text_processing/dictionary/serialization_helpers.cpp
|
ibr11/catboost
|
842a25b4fb856a61564b163b16a3f49ba35fdc14
|
[
"Apache-2.0"
] | 6,989
|
2017-07-18T06:23:18.000Z
|
2022-03-31T15:58:36.000Z
|
library/cpp/text_processing/dictionary/serialization_helpers.cpp
|
birichie/catboost
|
de75c6af12cf490700e76c22072fbdc15b35d679
|
[
"Apache-2.0"
] | 1,978
|
2017-07-18T09:17:58.000Z
|
2022-03-31T14:28:43.000Z
|
library/cpp/text_processing/dictionary/serialization_helpers.cpp
|
birichie/catboost
|
de75c6af12cf490700e76c22072fbdc15b35d679
|
[
"Apache-2.0"
] | 1,228
|
2017-07-18T09:03:13.000Z
|
2022-03-29T05:57:40.000Z
|
#include "serialization_helpers.h"
| 17.5
| 34
| 0.828571
|
ibr11
|
9f6e36adaf6b346d9611e7844be006a208a6b40d
| 5,855
|
cpp
|
C++
|
src/MainFrame.cpp
|
senfti/Kacarsonne
|
f2e3cbd7fd80bd1c9a6e41f03544b1e0718c0bd2
|
[
"MIT"
] | 4
|
2020-04-10T19:11:28.000Z
|
2020-05-01T11:25:46.000Z
|
src/MainFrame.cpp
|
senfti/Kacarsonne
|
f2e3cbd7fd80bd1c9a6e41f03544b1e0718c0bd2
|
[
"MIT"
] | 2
|
2020-05-07T17:34:40.000Z
|
2020-06-05T18:53:29.000Z
|
src/MainFrame.cpp
|
senfti/Kacarsonne
|
f2e3cbd7fd80bd1c9a6e41f03544b1e0718c0bd2
|
[
"MIT"
] | 2
|
2020-04-10T19:11:34.000Z
|
2020-12-08T19:12:31.000Z
|
//
// Created by ts on 24.03.20.
//
#include <filesystem>
#include <MainFrame.h>
#include <IdsDialog.h>
#include <PointEntryDialog.h>
#include <PointHistoryWindow.h>
#include <SettingsWindow.h>
#include "main.h"
MainFrame::MainFrame(MyApp* app) : MainFrame_B(nullptr), app_(app), timer_(this){
}
MainFrame::~MainFrame(){
}
void MainFrame::setGame(Game *game, bool restart){
{
std::lock_guard<std::mutex> lock(game->data_lock_);
game_ = game;
if(!game_->connection_->iAmHost())
restart_menu_item_->Enable(false);
table_panel_->setGame(game);
pt_history_wnd_ = new PointHistoryWindow(this, game->players_);
pt_history_wnd_id_ = pt_history_wnd_->GetId();
// pt_history_wnd_->Show();
}
std::lock_guard<std::mutex> lock(game_->data_lock_);
if(restart){
for(auto& pg : players_guis_)
pg->setPoints(0);
}
else{
int i=0;
for(const auto &p : game_->players_){
players_guis_.push_back(new PointGroup(p.name_, p.color_, game_->connection_->player_number_ == i++, this));
info_sizer_->Add(players_guis_.back());
}
if(!players_guis_.empty())
players_guis_[0]->setActive(true, false);
Connect(timer_.GetId(), wxEVT_TIMER, wxTimerEventHandler(MainFrame::OnTimer), NULL, this);
timer_.Start(100);
}
table_panel_->initOffset();
}
void MainFrame::setCurrentPlayer(int player){
for(unsigned i = 0; i < players_guis_.size(); i++){
players_guis_[i]->setActive(player == int(i), game_->current_card_);
}
}
void MainFrame::quit(wxCommandEvent &event){
takeScreenshot("");
Destroy();
}
void MainFrame::next(wxCommandEvent &event){
next();
}
void MainFrame::next(){
if(game_->next()){
next_button_->Enable(game_->isActive());
back_button_->Enable(game_->isActive());
shuffle_button_->Enable(game_->isActive() && game_->current_card_);
std::lock_guard<std::mutex> lock(game_->data_lock_);
setCurrentPlayer(game_->current_player_);
}
}
void MainFrame::back(wxCommandEvent &event){
if(game_->revert()){
next_button_->Enable(game_->isActive());
back_button_->Enable(game_->isActive());
shuffle_button_->Enable(game_->isActive() && game_->current_card_);
table_panel_->Refresh();
table_panel_->Update();
}
}
void MainFrame::shuffle( wxCommandEvent& event ){
if(game_->shuffle()){
table_panel_->Refresh();
table_panel_->Update();
}
}
void MainFrame::restart( wxCommandEvent& event ){
if(game_->connection_->iAmHost()){
takeScreenshot("");
app_->reset(false);
}
}
void MainFrame::newGame( wxCommandEvent& event ){
takeScreenshot("");
app_->reset(true);
}
void MainFrame::help( wxCommandEvent& event ){
HelpDialog_B help_dialog(this);
help_dialog.ShowModal();
}
void MainFrame::showIds( wxCommandEvent& event ){
IdsDialog d(this, game_->connection_);
d.ShowModal();
}
void MainFrame::viewSettings( wxCommandEvent& event ){
SettingsWindow wnd(this, &game_->card_count_);
wnd.ShowModal();
}
void MainFrame::OnTimer(wxTimerEvent &event){
next_button_->Enable(game_->isActive() && !game_->current_card_ && game_->stack_.getLeftCards());
back_button_->Enable(game_->isActive());
shuffle_button_->Enable(game_->isActive() && game_->current_card_ && !game_->played_cards_.empty() && game_->stack_.getLeftCards());
table_panel_->checkFlip();
setCurrentPlayer(game_->current_player_);
if(game_->update_table_){
game_->update_table_ = false;
table_panel_->Refresh();
}
int next_preview = game_->getPreviewCard();
if(next_preview != preview_image_){
if(next_preview >= 0 && next_preview < int(Card::CARD_IMAGES.size())){
wxSize size = preview_bitmap_->GetClientSize();
preview_bitmap_->SetBitmap(wxBitmap(Card::CARD_IMAGES[next_preview].image_.Scale(size.x, size.y)));
}
else{
wxSize size = preview_bitmap_->GetClientSize();
preview_bitmap_->SetBitmap(wxBitmap(wxImage(size)));
}
preview_image_ = next_preview;
}
for(unsigned i = 0; i < players_guis_.size(); i++){
std::lock_guard<std::mutex> lock(game_->data_lock_);
players_guis_[i]->setPoints(game_->players_[i].points_);
players_guis_[i]->setStones(game_->players_[i].getRemainingStones());
if(game_->update_old_pts_)
players_guis_[i]->setOldPoints(game_->players_[i].points_);
if(FindWindowById(pt_history_wnd_id_))
pt_history_wnd_->setPoints(i, game_->players_[i].points_);
}
game_->update_old_pts_ = false;
{
std::lock_guard<std::mutex> lock(game_->data_lock_);
auto flare = game_->flares_.begin();
bool refresh = !game_->flares_.empty();
while(flare != game_->flares_.end()){
if(flare->isTimeout())
flare = game_->flares_.erase(flare);
else
break;
}
if(refresh){
table_panel_->Refresh();
}
}
static unsigned long long last_curr_time = getTime();
if(game_->current_card_)
last_curr_time = getTime();
else if(getTime() - last_curr_time > 3 && !game_->isFirst())
next();
}
void MainFrame::disable(){
timer_.Stop();
}
void MainFrame::takeScreenshot(const std::string& prefix){
if(!std::filesystem::exists("screenshots")){
std::filesystem::create_directory("screenshots");
}
wxScreenDC screen_dc;
wxSize size = GetClientSize();
wxPoint pos = ClientToScreen(wxPoint(0, 0));
wxBitmap screenshot(size.GetWidth(), size.GetHeight(), -1);
wxMemoryDC mem_dc;
mem_dc.SelectObject(screenshot);
mem_dc.Blit(0, 0, size.GetWidth(), size.GetHeight(), &screen_dc, pos.x, pos.y);
mem_dc.SelectObject(wxNullBitmap);
auto now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
std::string s(30, '\0');
std::strftime(&s[0], s.size(), "%Y-%m-%d %H-%M-%S", std::localtime(&now));
s = std::string(s.c_str());
screenshot.SaveFile("screenshots/" + prefix + s + ".png", wxBITMAP_TYPE_PNG);
}
| 29.129353
| 134
| 0.680956
|
senfti
|
9f6e3ccc836d8100125140af85d9da02f09743dc
| 1,725
|
hpp
|
C++
|
inference-engine/tests/unit/inference_engine_tests/cpp_interfaces/task_tests_utils.hpp
|
zhoub/dldt
|
e42c01cf6e1d3aefa55e2c5df91f1054daddc575
|
[
"Apache-2.0"
] | 3
|
2020-02-09T23:25:37.000Z
|
2021-01-19T09:44:12.000Z
|
inference-engine/tests/unit/inference_engine_tests/cpp_interfaces/task_tests_utils.hpp
|
zhoub/dldt
|
e42c01cf6e1d3aefa55e2c5df91f1054daddc575
|
[
"Apache-2.0"
] | null | null | null |
inference-engine/tests/unit/inference_engine_tests/cpp_interfaces/task_tests_utils.hpp
|
zhoub/dldt
|
e42c01cf6e1d3aefa55e2c5df91f1054daddc575
|
[
"Apache-2.0"
] | 2
|
2020-04-18T16:24:39.000Z
|
2021-01-19T09:42:19.000Z
|
// Copyright (C) 2018-2019 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <gtest/gtest.h>
#include <gmock/gmock-spec-builders.h>
#include <thread>
#include <mutex>
#include <condition_variable>
using namespace InferenceEngine;
using namespace ::testing;
using namespace std;
class MetaThread {
bool _isThreadStarted;
std::mutex _isThreadStartedMutex;
std::condition_variable _isThreadStartedCV;
bool _isThreadFinished;
std::mutex _isThreadFinishedMutex;
std::condition_variable _isThreadFinishedCV;
std::thread _thread;
std::function<void()> _function;
public:
bool exceptionWasThrown;
MetaThread(std::function<void()> function)
: _function(function), _isThreadStarted(false), exceptionWasThrown(false), _isThreadFinished(false) {
_thread = std::thread([this]() {
_isThreadStarted = true;
_isThreadStartedCV.notify_all();
try {
_function();
} catch (...) {
exceptionWasThrown = true;
}
_isThreadFinished = true;
_isThreadFinishedCV.notify_all();
});
}
~MetaThread() {
join();
}
void waitUntilThreadStarted() {
std::unique_lock<std::mutex> lock(_isThreadStartedMutex);
_isThreadStartedCV.wait(lock, [this]() { return _isThreadStarted; });
}
void waitUntilThreadFinished() {
std::unique_lock<std::mutex> lock(_isThreadFinishedMutex);
_isThreadFinishedCV.wait(lock, [this]() { return _isThreadFinished; });
}
void join() {
if (_thread.joinable()) _thread.join();
}
typedef std::shared_ptr<MetaThread> Ptr;
};
| 26.136364
| 113
| 0.643478
|
zhoub
|
9f720605a730030172b5aaa721d170d2a2e21961
| 1,595
|
cpp
|
C++
|
December-07/cpp_aw3someone.cpp
|
Aw3someOne/A-December-of-Algorithms-2019
|
0b17b3a0360d1906babc141dd8a4b9ac67d1b609
|
[
"MIT"
] | null | null | null |
December-07/cpp_aw3someone.cpp
|
Aw3someOne/A-December-of-Algorithms-2019
|
0b17b3a0360d1906babc141dd8a4b9ac67d1b609
|
[
"MIT"
] | null | null | null |
December-07/cpp_aw3someone.cpp
|
Aw3someOne/A-December-of-Algorithms-2019
|
0b17b3a0360d1906babc141dd8a4b9ac67d1b609
|
[
"MIT"
] | null | null | null |
#include <deque>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
struct Patient {
int token;
std::string id;
Patient(int token, std::string id) : token(token), id(id) {}
};
std::ostream& operator<<(std::ostream& os, const Patient* p) {
os << '(' << p->token << ", " << p->id << ')';
return os;
}
class Queue {
std::deque<Patient*> _d;
public:
bool promote(std::string id) {
for (auto it = _d.begin(); it != _d.end(); ++it) {
if ((*it)->id == id) {
Patient* tmp = *it;
_d.erase(it, it + 1);
_d.push_front(tmp);
return true;
}
}
return false;
}
void enqueue(Patient* p) {
_d.push_back(p);
}
size_t size() const {
return _d.size();
}
friend std::ostream& operator<<(std::ostream& os, const Queue& q);
};
std::ostream& operator<<(std::ostream& os, const Queue& q) {
for (const auto p : q._d)
os << p << std::endl;
return os;
}
int main() {
int N = 0;
for (std::string line; std::cout << "Enter N: " && getline(std::cin, line);) {
std::istringstream iss(line);
if (iss >> N && N > 0) break;
}
std::cout << "Enter (token no, id):" << std::endl;
Queue queue;
for (std::string line; queue.size() < N && getline(std::cin, line);) {
std::istringstream iss(line);
char _;
int token;
std::string id;
if (!(iss >> _ >> token >> _ >> id)) continue;
if ((*id.rbegin()) != ')') continue;
id.pop_back();
queue.enqueue(new Patient(token, id));
}
std::cout << "Enter k: ";
std::string k;
std::cin >> k;
queue.promote(k);
std::cout << "The order is:" << std::endl;
std::cout << queue << std::endl;
}
| 21.849315
| 79
| 0.574295
|
Aw3someOne
|
9f7448a96bda92e791f828209cc2f66e2af10444
| 4,328
|
cxx
|
C++
|
modules/core/tests/basicStatismoTest.cxx
|
skn123/statismo-1
|
a380f33cf070d1c4ba624db8b0c6d946d2aecabf
|
[
"BSD-3-Clause"
] | 14
|
2020-04-28T17:24:01.000Z
|
2021-07-20T11:54:59.000Z
|
modules/core/tests/basicStatismoTest.cxx
|
latimagine/statismo
|
a380f33cf070d1c4ba624db8b0c6d946d2aecabf
|
[
"BSD-3-Clause"
] | 8
|
2020-01-22T09:05:00.000Z
|
2021-06-29T10:10:24.000Z
|
modules/core/tests/basicStatismoTest.cxx
|
latimagine/statismo
|
a380f33cf070d1c4ba624db8b0c6d946d2aecabf
|
[
"BSD-3-Clause"
] | 6
|
2020-03-11T19:41:06.000Z
|
2021-09-07T12:57:20.000Z
|
/*
* This file is part of the statismo library.
*
* Author: Marcel Luethi (marcel.luethi@unibas.ch)
*
* Copyright (c) 2011 University of Basel
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* Neither the name of the project's author nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS addINTERRUPTION) 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 "StatismoUnitTest.h"
#include "statismo/core/Exceptions.h"
#include "statismo/core/DataManager.h"
#include "statismo/core/PCAModelBuilder.h"
#include "statismo/core/StatisticalModel.h"
#include "statismo/core/IO.h"
#include "statismo/core/TrivialVectorialRepresenter.h"
#include <memory>
namespace
{
int
Test1()
{
using RepresenterType = statismo::TrivialVectorialRepresenter;
using ModelBuilderType = statismo::PCAModelBuilder<statismo::VectorType>;
using StatisticalModelType = statismo::StatisticalModel<statismo::VectorType>;
using DataManagerType = statismo::BasicDataManager<statismo::VectorType>;
const unsigned kDim = 3;
std::unique_ptr<RepresenterType> representer(RepresenterType::Create(kDim));
std::unique_ptr<DataManagerType> dataManager(DataManagerType::Create(representer.get()));
// we create three simple datasets
statismo::VectorType dataset1(kDim), dataset2(kDim), dataset3(kDim);
dataset1 << 1, 0, 0;
dataset2 << 0, 2, 0;
dataset3 << 0, 0, 4;
dataManager->AddDataset(dataset1, "dataset1");
dataManager->AddDataset(dataset2, "dataset1");
dataManager->AddDataset(dataset3, "dataset1");
statismo::UniquePtrType<ModelBuilderType> pcaModelBuilder(ModelBuilderType::Create());
statismo::UniquePtrType<StatisticalModelType> model(pcaModelBuilder->BuildNewModel(dataManager->GetData(), 0.01));
STATISMO_ASSERT_EQ(model->GetNumberOfPrincipalComponents(), 2U);
statismo::IO<statismo::VectorType>::SaveStatisticalModel(model.get(), "test.h5");
auto newRepresenter = RepresenterType::SafeCreate();
statismo::UniquePtrType<StatisticalModelType> loadedModel(
statismo::IO<statismo::VectorType>::LoadStatisticalModel(newRepresenter.get(), "test.h5"));
STATISMO_ASSERT_EQ(model->GetNumberOfPrincipalComponents(), loadedModel->GetNumberOfPrincipalComponents());
return EXIT_SUCCESS;
}
} // namespace
/**
* This basic test case covers the model creation pipeline and tests whether a model can be successfully
* saved to disk. If the test runs correctly, it merely means that statismo has been setup correclty and hdf5
* works.
*
* Real unit tests that test the functionality of statismo are provided in the statismoTests directory (these tests
* require VTK to be installed and the statismo python wrapping to be working).
*/
int basicStatismoTest([[maybe_unused]] int argc, [[maybe_unused]] char * argv[]) // NOLINT
{
auto res = statismo::Translate([]() {
return statismo::test::RunAllTests("basicStatismoTest", { { "Test1", Test1 } });
});
return !CheckResultAndAssert(res, EXIT_SUCCESS);
}
| 40.448598
| 116
| 0.753928
|
skn123
|
9f7553ebf2a7873002ca73d4855aed08e888f059
| 654
|
cpp
|
C++
|
examples/stream1.cpp
|
mjcaisse/cppnow-2017-network-ts-material
|
128bcf2a718e8f13c2991520a56ddc41b3ccb28b
|
[
"BSL-1.0"
] | 5
|
2017-05-19T23:03:26.000Z
|
2021-05-03T13:40:19.000Z
|
examples/stream1.cpp
|
mjcaisse/cppnow-2017-network-ts-material
|
128bcf2a718e8f13c2991520a56ddc41b3ccb28b
|
[
"BSL-1.0"
] | 1
|
2018-05-15T18:40:33.000Z
|
2018-05-15T18:40:33.000Z
|
examples/stream1.cpp
|
mjcaisse/cppnow-2017-network-ts-material
|
128bcf2a718e8f13c2991520a56ddc41b3ccb28b
|
[
"BSL-1.0"
] | 2
|
2017-10-03T13:23:34.000Z
|
2018-04-23T16:19:11.000Z
|
#include <experimental/net>
#include <chrono>
#include <string>
#include <iostream>
using namespace std::chrono_literals;
namespace net = std::experimental::net;
int main()
{
net::ip::tcp::iostream s;
s.expires_after(5s);
s.connect("www.boost.org", "https");
if(!s)
{
std::cout << "error: " << s.error().message() << std::endl;
return -1;
}
s << "GET / HTTP/1.0\r\n";
s << "Host: www.boost.org\r\n";
s << "Accept: */*\r\n";
s << "Connection: close\r\n\r\n";
std::string header;
while(s && std::getline(s, header) && header != "\r")
std::cout << header << "\n";
std::cout << s.rdbuf();
}
| 19.818182
| 65
| 0.553517
|
mjcaisse
|
9f76ed3dc86b8f58ae5eedad16f2b785be9667fc
| 1,436
|
cpp
|
C++
|
v1/CException.cpp
|
lanyj/mcts
|
8394acaf3e83020b0bdfaa6117553d1ad64be291
|
[
"MIT"
] | null | null | null |
v1/CException.cpp
|
lanyj/mcts
|
8394acaf3e83020b0bdfaa6117553d1ad64be291
|
[
"MIT"
] | null | null | null |
v1/CException.cpp
|
lanyj/mcts
|
8394acaf3e83020b0bdfaa6117553d1ad64be291
|
[
"MIT"
] | null | null | null |
#pragma once
#include "stdafx.h"
#include "CException.h"
CException::CException(const char* msg) {
this->name = "CException";
this->msg = msg;
}
void CException::printMsg() {
printf("%s:\n\t%s\n", name, msg);
exit(-1);
}
CIndexOutOfBoundsException::CIndexOutOfBoundsException(int index, int bounds, const char* msg) : CException(msg) {
this->index = index;
this->bounds = bounds;
this->name = "CIndexOutOfBoundsException";
}
void CIndexOutOfBoundsException::printMsg() {
printf("%s: Index: %d, Size: %d\n\t%s\n", name, index, bounds, msg);
exit(-1);
}
CKeyNotFoundException::CKeyNotFoundException(const char* msg) : CException(msg) {
this->name = "CKeyNotFoundException";
}
CEmptyStackException::CEmptyStackException(const char* msg) : CException(msg) {
this->name = "CEmptyStackException";
}
CEmptyQueueException::CEmptyQueueException(const char* msg) : CException(msg) {
this->name = "CEmptyQueueException";
}
CRootOfTreeException::CRootOfTreeException(const char* msg) : CException(msg) {
this->name = "CRootOfTreeException";
}
CNoSuchChildException::CNoSuchChildException(const char* msg) : CException(msg) {
this->name = "CNoSuchChildException";
}
CBoundsOfChildException::CBoundsOfChildException(const char* msg) : CException(msg) {
this->name = "CBoundsOfChildException";
}
CIllegalStateException::CIllegalStateException(const char* msg) : CException(msg) {
this->name = "CIllegalStateException";
};
| 27.09434
| 114
| 0.738162
|
lanyj
|
9f7901d59f0ddbf3055760fc61e3e2286a327708
| 405
|
cpp
|
C++
|
bazaar/Scatter/PopUpText.cpp
|
dreamsxin/ultimatepp
|
41d295d999f9ff1339b34b43c99ce279b9b3991c
|
[
"BSD-2-Clause"
] | 2
|
2016-04-07T07:54:26.000Z
|
2020-04-14T12:37:34.000Z
|
bazaar/Scatter/PopUpText.cpp
|
dreamsxin/ultimatepp
|
41d295d999f9ff1339b34b43c99ce279b9b3991c
|
[
"BSD-2-Clause"
] | null | null | null |
bazaar/Scatter/PopUpText.cpp
|
dreamsxin/ultimatepp
|
41d295d999f9ff1339b34b43c99ce279b9b3991c
|
[
"BSD-2-Clause"
] | null | null | null |
#include "PopUpText.h"
void PopUpInfo::Paint(Draw& w)
{
Size sz = GetSize();
if(!IsTransparent())
w.DrawRect(0, 0, sz.cx, sz.cy, color);
PaintLabel(w, 0, 0, sz.cx, sz.cy, !IsShowEnabled(), false, false, VisibleAccessKeys());
}
PopUpInfo::PopUpInfo(): color(SColorInfo())
{
Transparent(false);
NoWantFocus();
IgnoreMouse();
SetAlign(ALIGN_CENTER);
SetFrame(BlackFrame());
opened = false;
}
| 17.608696
| 88
| 0.674074
|
dreamsxin
|
9f8051bad0fe0c00f7db199c573544ea0e8626da
| 5,058
|
cc
|
C++
|
components/password_manager/ios/test_helpers.cc
|
mghgroup/Glide-Browser
|
6a4c1eaa6632ec55014fee87781c6bbbb92a2af5
|
[
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null |
components/password_manager/ios/test_helpers.cc
|
mghgroup/Glide-Browser
|
6a4c1eaa6632ec55014fee87781c6bbbb92a2af5
|
[
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null |
components/password_manager/ios/test_helpers.cc
|
mghgroup/Glide-Browser
|
6a4c1eaa6632ec55014fee87781c6bbbb92a2af5
|
[
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 2
|
2021-01-05T23:43:46.000Z
|
2021-01-07T23:36:34.000Z
|
// Copyright (c) 2018 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 "components/password_manager/ios/test_helpers.h"
#include "base/strings/utf_string_conversions.h"
#include "components/autofill/core/common/form_data.h"
#include "components/autofill/core/common/password_form_fill_data.h"
#include "components/password_manager/ios/account_select_fill_data.h"
#include "url/gurl.h"
using autofill::FieldRendererId;
using autofill::FormData;
using autofill::FormFieldData;
using autofill::FormRendererId;
using autofill::PasswordFormFillData;
using password_manager::FillData;
namespace test_helpers {
void SetPasswordFormFillData(const std::string& url,
const char* form_name,
uint32_t unique_renderer_id,
const char* username_field,
uint32_t username_unique_id,
const char* username_value,
const char* password_field,
uint32_t password_unique_id,
const char* password_value,
const char* additional_username,
const char* additional_password,
bool wait_for_username,
PasswordFormFillData* form_data) {
form_data->url = GURL(url);
form_data->name = base::UTF8ToUTF16(form_name);
form_data->form_renderer_id = FormRendererId(unique_renderer_id);
autofill::FormFieldData username;
username.name = base::UTF8ToUTF16(username_field);
username.unique_renderer_id = FieldRendererId(username_unique_id);
username.unique_id = base::UTF8ToUTF16(username_field);
username.value = base::UTF8ToUTF16(username_value);
form_data->username_field = username;
autofill::FormFieldData password;
password.name = base::UTF8ToUTF16(password_field);
password.unique_renderer_id = FieldRendererId(password_unique_id);
password.unique_id = base::UTF8ToUTF16(password_field);
password.value = base::UTF8ToUTF16(password_value);
form_data->password_field = password;
if (additional_username) {
autofill::PasswordAndMetadata additional_password_data;
additional_password_data.username = base::UTF8ToUTF16(additional_username);
additional_password_data.password = base::UTF8ToUTF16(additional_password);
additional_password_data.realm.clear();
form_data->additional_logins.push_back(additional_password_data);
}
form_data->wait_for_username = wait_for_username;
}
void SetFillData(const std::string& origin,
uint32_t form_id,
uint32_t username_field_id,
const char* username_value,
uint32_t password_field_id,
const char* password_value,
FillData* fill_data) {
DCHECK(fill_data);
fill_data->origin = GURL(origin);
fill_data->form_id = FormRendererId(form_id);
fill_data->username_element_id = FieldRendererId(username_field_id);
fill_data->username_value = base::UTF8ToUTF16(username_value);
fill_data->password_element_id = FieldRendererId(password_field_id);
fill_data->password_value = base::UTF8ToUTF16(password_value);
}
void SetFormData(const std::string& origin,
uint32_t form_id,
uint32_t username_field_id,
const char* username_value,
uint32_t password_field_id,
const char* password_value,
FormData* form_data) {
DCHECK(form_data);
form_data->url = GURL(origin);
form_data->unique_renderer_id = FormRendererId(form_id);
FormFieldData field;
field.value = base::UTF8ToUTF16(username_value);
field.form_control_type = "text";
field.unique_renderer_id = FieldRendererId(username_field_id);
form_data->fields.push_back(field);
field.value = base::UTF8ToUTF16(password_value);
field.form_control_type = "password";
field.unique_renderer_id = FieldRendererId(password_field_id);
form_data->fields.push_back(field);
}
autofill::FormData MakeSimpleFormData() {
autofill::FormData form_data;
form_data.url = GURL("http://www.google.com/a/LoginAuth");
form_data.action = GURL("http://www.google.com/a/Login");
form_data.name = base::ASCIIToUTF16("login_form");
autofill::FormFieldData field;
field.name = base::ASCIIToUTF16("Username");
field.id_attribute = field.name;
field.name_attribute = field.name;
field.value = base::ASCIIToUTF16("googleuser");
field.form_control_type = "text";
field.unique_id = field.id_attribute;
form_data.fields.push_back(field);
field.name = base::ASCIIToUTF16("Passwd");
field.id_attribute = field.name;
field.name_attribute = field.name;
field.value = base::ASCIIToUTF16("p4ssword");
field.form_control_type = "password";
field.unique_id = field.id_attribute;
form_data.fields.push_back(field);
return form_data;
}
} // namespace test_helpers
| 40.142857
| 79
| 0.704033
|
mghgroup
|
9f80bd6eeaad3f9add9d3e97470aba3629a4297a
| 11,605
|
cpp
|
C++
|
editor/renderer/src/Material.cpp
|
lizardkinger/blacksun
|
0119948726d2a057c13d208044c7664a8348a1ea
|
[
"Linux-OpenIB"
] | null | null | null |
editor/renderer/src/Material.cpp
|
lizardkinger/blacksun
|
0119948726d2a057c13d208044c7664a8348a1ea
|
[
"Linux-OpenIB"
] | null | null | null |
editor/renderer/src/Material.cpp
|
lizardkinger/blacksun
|
0119948726d2a057c13d208044c7664a8348a1ea
|
[
"Linux-OpenIB"
] | null | null | null |
/***************************************************************************
* Copyright (C) 2006-07 by Reinhard Jeschull
* rjeschu@fh-landshut.de
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
* (See COPYING for details.)
***************************************************************************
*
* Module: Renderer (BlackSun)
* File: Material.cpp
* Created: 28.11.2006
* Author: Reinhard Jeschull (rjeschu)
*
**************************************************************************/
#include "../include/Material.h"
#include "../include/Renderer.h"
namespace BSRenderer
{
int Material::nMagicNumber = 24022007;
Material::Material(const string& sName)
: QObject(), m_sName(sName)
{
setToDefault();
}
Material::Material(const Material& otherMaterial)
: QObject()
{
m_dSpecularFactor = otherMaterial.m_dSpecularFactor;
m_sName = otherMaterial.m_sName;
m_cColor = otherMaterial.m_cColor;
m_cAmbient = otherMaterial.m_cAmbient;
m_cDiffuse = otherMaterial.m_cDiffuse;
m_cSpecular = otherMaterial.m_cSpecular;
m_cEmissive = otherMaterial.m_cEmissive;
m_dSpecularFactor = otherMaterial.m_dSpecularFactor;
for(int i = 0 ; i < MAXTEXTURES ; i++)
{
m_tex[i] = otherMaterial.m_tex[i];
m_texState[i] = otherMaterial.m_texState[i];
}
}
void Material::set()
{
int nTexStage = 0;
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_TEXTURE_2D);
//First deactive all textures
for(int t=0; t<MAXTEXTURES; t++)
{
glActiveTextureARB(GL_TEXTURE0_ARB+t);
glDisable(GL_TEXTURE_2D);
}
for(int t=0; t<MAXTEXTURES; t++)
{
//Texture is not valid
if(m_tex[t] == -1)
{
//Disable the stage
glActiveTextureARB(GL_TEXTURE0_ARB+t);
glDisable(GL_TEXTURE_2D);
continue;
}
//Set the texture and the texture-state
m_texState[t].set(nTexStage);
TextureManager::getInstance()->getTexture(m_tex[t])->set(nTexStage);
nTexStage++;
}
//No textures are set, so the texturing can be disabled
if(nTexStage==0)
glDisable(GL_TEXTURE_2D);
//glMaterial does not support double-values. So it must be
//converted into a float-array
float fAmbient[4], fDiffuse[4], fSpecular[4], fEmissive[4];
m_cAmbient.getFloatArray(&fAmbient[0]);
m_cDiffuse.getFloatArray(&fDiffuse[0]);
m_cSpecular.getFloatArray(&fSpecular[0]);
m_cEmissive.getFloatArray(&fEmissive[0]);
//Set the material
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, fAmbient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, fDiffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, fSpecular);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, fEmissive);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, m_dSpecularFactor);
}
bool Material::save(const string& sFileName)
{
ofstream f(sFileName.c_str(), ios::binary);
//File can't be opened
if(f.rdstate())
{
stringstream msg;
msg << "Can't open file: \"" << sFileName << "\"";
LOG_Error(msg.str());
return false;
}
if(appendToFile(f)==false)
return false;
f.close();
stringstream msg;
msg << "Material saved: \"" << sFileName << "\"";
LOG_Ok(msg.str());
return true;
}
bool Material::load(const string& sFileName)
{
ifstream f(sFileName.c_str(), ios::binary);
//File can't be opened
if(f.rdstate())
{
stringstream msg;
msg << "Can't open file: \"" << sFileName << "\"";
LOG_Error(msg.str());
return false;
}
loadFromFilePos(f, 0);
f.close();
stringstream msg;
msg << "Material loaded: \"" << sFileName << "\"";
LOG_Ok(msg.str());
emit changed();
return true;
}
bool Material::appendToFile(ofstream& f)
{
//Write magic number of material file
f.write(reinterpret_cast<char*>(&nMagicNumber), sizeof(nMagicNumber));
//Write the material name
UINT nLength = m_sName.length();
f.write(reinterpret_cast<char*>(&nLength), sizeof(nLength));
for(UINT i=0; i<nLength; i++)
f.write(reinterpret_cast<char*>(&m_sName[i]), sizeof(m_sName[i]));
//Write texture-ID with path if needed
TextureManager* pTexMgr = TextureManager::getInstance();
vector<int> texturesNeeded;
for(int t=0; t<MAXTEXTURES; t++)
{
if(m_tex[t] < 0)
continue;
for(unsigned int i=0; i<texturesNeeded.size(); i++)
{
//Texture is already in list
if(texturesNeeded[i] == m_tex[t])
break;
}
texturesNeeded.push_back(m_tex[t]);
}
int nTexNum = texturesNeeded.size();
f.write(reinterpret_cast<char*>(&nTexNum), sizeof(UINT));
for(int t=0; t<nTexNum; t++)
{
//Write ID of the texture
f.write(reinterpret_cast<char*>(&texturesNeeded[t]), sizeof(int));
//Write the texture name/path
string sTexName = pTexMgr->getTexture(texturesNeeded[t])->getTextureInfo()->sName;
UINT nLength = sTexName.length();
f.write(reinterpret_cast<char*>(&nLength), sizeof(nLength));
for(UINT i=0; i<nLength; i++)
f.write(reinterpret_cast<char*>(&sTexName[i]), sizeof(sTexName[i]));
}
//Write the pure material data
f.write(reinterpret_cast<char*>(&m_cColor), sizeof(Color));
f.write(reinterpret_cast<char*>(&m_cAmbient), sizeof(Color));
f.write(reinterpret_cast<char*>(&m_cDiffuse), sizeof(Color));
f.write(reinterpret_cast<char*>(&m_cSpecular), sizeof(Color));
f.write(reinterpret_cast<char*>(&m_cEmissive), sizeof(Color));
f.write(reinterpret_cast<char*>(&m_dSpecularFactor), sizeof(m_dSpecularFactor));
//Write the max. texture stages per material
int nMaxTex = MAXTEXTURES;
f.write(reinterpret_cast<char*>(&nMaxTex), sizeof(nMaxTex));
//Write the textur stages of the material
for(int i=0; i<MAXTEXTURES; i++)
{
f.write(reinterpret_cast<char*>(&m_tex[i]), sizeof(int));
f.write(reinterpret_cast<char*>(&m_texState[i]), sizeof(TextureState));
}
return true;
}
bool Material::loadFromFilePos(ifstream& f, int nPos)
{
//Walk to the file position
f.seekg(nPos, ios::beg);
//Read magic number of material file
int nNumber;
f.read(reinterpret_cast<char*>(&nNumber), sizeof(nNumber));
//Its no material file, so return
if(nNumber != nMagicNumber)
{
stringstream msg;
msg << "Material-version file not supported: " << nNumber;
LOG_Error(msg.str());
return false;
}
//Read the material name
UINT nLength;
f.read(reinterpret_cast<char*>(&nLength), sizeof(nLength));
m_sName.resize(nLength);
for(UINT i=0; i<nLength; i++)
f.read(reinterpret_cast<char*>(&m_sName[i]), sizeof(m_sName[i]));
vector<int> texturesNeededID;
vector<string> texturesNeededName;
UINT nNumTex = 0;
f.read(reinterpret_cast<char*>(&nNumTex), sizeof(UINT));
for(unsigned int t=0; t<nNumTex; t++)
{
//Read ID of the texture
int nID = -1;
f.read(reinterpret_cast<char*>(&nID), sizeof(int));
//Write the texture name/path
string sTexName;
UINT nLength = 0;
f.read(reinterpret_cast<char*>(&nLength), sizeof(nLength));
sTexName.resize(nLength);
for(UINT i=0; i<nLength; i++)
f.read(reinterpret_cast<char*>(&sTexName[i]), sizeof(sTexName[i]));
texturesNeededID.push_back(nID);
texturesNeededName.push_back(sTexName);
}
//Read the pure material data
f.read(reinterpret_cast<char*>(&m_cColor), sizeof(Color));
f.read(reinterpret_cast<char*>(&m_cAmbient), sizeof(Color));
f.read(reinterpret_cast<char*>(&m_cDiffuse), sizeof(Color));
f.read(reinterpret_cast<char*>(&m_cSpecular), sizeof(Color));
f.read(reinterpret_cast<char*>(&m_cEmissive), sizeof(Color));
f.read(reinterpret_cast<char*>(&m_dSpecularFactor), sizeof(m_dSpecularFactor));
//Read the max. texture stages per material
int nMaxTex;
f.read(reinterpret_cast<char*>(&nMaxTex), sizeof(nMaxTex));
//Read the textur stages of the material
for(int i=0; i<nMaxTex; i++)
{
f.read(reinterpret_cast<char*>(&m_tex[i]), sizeof(int));
f.read(reinterpret_cast<char*>(&m_texState[i]), sizeof(TextureState));
//Load texture, if needed
if(m_tex[i]>=0)
{
TextureManager* pTexMgr = TextureManager::getInstance();
//Search for the texture-Name
for(unsigned int t=0; t<texturesNeededID.size(); t++)
{
//ID found?
if(texturesNeededID[t] == m_tex[i])
{
//Load texture
m_tex[i] = pTexMgr->loadTexture(texturesNeededName[t], m_tex[t]);
break;
}
}
}
}
emit changed();
return true;
}
int Material::getNumValidTextures() const
{
int nNum = 0;
for(int i=0; i<MAXTEXTURES; i++)
{
//Its valid, if the texture-id is not -1 and the texture is available
if(m_tex[i] != -1 &&
TextureManager::getInstance()->getTexture(m_tex[i]) != NULL)
{
nNum++;
}
}
return nNum;
}
void Material::getValidTextureStages(int* nTexStages) const
{
int nNum = 0;
for(int i=0; i<MAXTEXTURES; i++)
{
//Its valid, if the texture-id is not -1 and the texture is available
if(m_tex[i] != -1 &&
TextureManager::getInstance()->getTexture(m_tex[i]) != NULL)
{
nTexStages[nNum] = i;
nNum++;
}
}
}
void Material::setTexture(int nTexStage, int nTexID)
{
if((nTexStage >= 0) && (nTexStage < MAXTEXTURES))
m_tex[nTexStage] = nTexID;
emit changed();
}
int Material::getTexture(int nTexStage) const
{
if((nTexStage >= 0) && (nTexStage < MAXTEXTURES))
return m_tex[nTexStage];
return -1;
}
TextureState* Material::getTextureState(int nTexStage)
{
if((nTexStage >= 0) && (nTexStage < MAXTEXTURES))
return &m_texState[nTexStage];
return NULL;
}
void Material::setToDefault()
{
m_cColor.set(1.0, 1.0, 1.0);
m_cAmbient.set(0.2, 0.2, 0.2, 1.0);
m_cDiffuse.set(0.8, 0.8, 0.8);
m_cSpecular.set(0.1, 0.1, 0.1);
m_cEmissive.set(0.0, 0.0, 0.0);
m_dSpecularFactor = 0.0;
//Set the used textures to NULL, so that the texture do not use
//any textures
for(int t=0; t<MAXTEXTURES; t++)
m_tex[t] = -1;
//The first version must be set with other values than the others
m_texState[0].setCombineMethode(false, TEXMET_Replace);
//m_texState[0].setSourceCombine(TEXCOMB_ColorArg1, TEXOP_Disable);
m_texState[0].setCombineOperand(TEXCOMBOP_RGB0, TEXBLEND_SrcColor);
//m_texState[0].setCombineMethode(true, TEXMET_Replace);
//m_texState[0].setCombineMethode(false, TEXMET_Disable);
//m_texState[0].setSourceCombine(TEXCOMB_ColorArg0, TEXOP_Texture);
//m_texState[0].setSourceCombine(TEXCOMB_AlphaArg0, TEXOP_Disable);
//m_texState[0].setCombineOperand(TEXCOMBOP_RGB0, TEXBLEND_SrcColor);
//m_texState[1].setSourceCombine(TEXCOMB_AlphaArg0, TEXOP_Previous);
//m_texState[1].setCombineOperand(TEXCOMBOP_Alpha0, TEXBLEND_One);
//m_texState[1].setCombineMethode(false, TEXMET_Replace);
}
}
| 27.963855
| 85
| 0.650754
|
lizardkinger
|
9f85c9364e622713b8b8b52534e5febe4b3d3d1a
| 80
|
cpp
|
C++
|
src/enum-enhanced.cpp
|
zzlc/cxx11tests
|
d471b3f8b96548c762be6b7e410abe56a57811ae
|
[
"MIT"
] | 48
|
2015-01-06T20:50:45.000Z
|
2021-02-15T02:48:32.000Z
|
src/enum-enhanced.cpp
|
zzlc/cxx11tests
|
d471b3f8b96548c762be6b7e410abe56a57811ae
|
[
"MIT"
] | 3
|
2016-01-19T15:02:19.000Z
|
2019-04-29T08:51:13.000Z
|
src/enum-enhanced.cpp
|
zzlc/cxx11tests
|
d471b3f8b96548c762be6b7e410abe56a57811ae
|
[
"MIT"
] | 24
|
2015-02-13T17:40:04.000Z
|
2019-12-03T06:59:03.000Z
|
// Check if enhanced enums are supported
enum Days: unsigned short {Odd, Even};
| 26.666667
| 40
| 0.75
|
zzlc
|
9f89f4742acbce21760b5f7c242fea151b304b5f
| 1,629
|
cpp
|
C++
|
server/modules/FileReader/FileReaderManager.cpp
|
hotgloupi/zhttpd
|
0437ac2e34dde89abab26665df9cbee1777f1d44
|
[
"BSD-3-Clause"
] | 2
|
2015-01-29T17:23:23.000Z
|
2015-09-21T17:45:22.000Z
|
server/modules/FileReader/FileReaderManager.cpp
|
hotgloupi/zhttpd
|
0437ac2e34dde89abab26665df9cbee1777f1d44
|
[
"BSD-3-Clause"
] | null | null | null |
server/modules/FileReader/FileReaderManager.cpp
|
hotgloupi/zhttpd
|
0437ac2e34dde89abab26665df9cbee1777f1d44
|
[
"BSD-3-Clause"
] | null | null | null |
#include "utils/Logger.hpp"
#include "utils/Path.hpp"
#include "FileReaderManager.hpp"
using namespace zhttpd::mod;
FileReaderManager::FileReaderManager() : StatefullManager<FileReader>("mod_filereader"), _delay(0)
{
this->_defaultMimeType = "";
}
FileReaderManager::~FileReaderManager()
{
}
unsigned int FileReaderManager::getDelay() const
{
return this->_delay;
}
std::string const& FileReaderManager::getDefaultMimeType() const
{
return this->_defaultMimeType;
}
std::string const& FileReaderManager::getMimeType(std::string const& ext) const
{
std::map<std::string, std::string>::const_iterator it = this->_types.find(ext);
if (it == this->_types.end())
return this->_defaultMimeType;
return it->second;
}
void FileReaderManager::addConfigurationEntry(std::string const& key, std::string const& value)
{
#ifdef ZHTTPD_DEBUG
LOG_DEBUG("Adding mime type " + value + " for extension " + key);
#endif
if (key.size() > 0)
{
if (key[0] == '.')
{
std::string str = key;
str.erase(str.begin());
this->_types[str] = value;
}
else if (key == "delay")
{
std::stringstream ss;
ss << value;
ss >> this->_delay;
}
else
LOG_WARN("Unknown filereader option " + key + " = " + value);
}
}
zhttpd::api::category::Type FileReaderManager::getCategory() const
{
return zhttpd::api::category::PROCESSING;
}
bool FileReaderManager::isRequired(zhttpd::api::IRequest const& req) const
{
return !zhttpd::Path::isDirectory(req.getFilePath());
}
| 23.271429
| 98
| 0.63229
|
hotgloupi
|
9f8a9bdb1a6199734132cece4919fd93acfc166f
| 1,269
|
cpp
|
C++
|
examples/complex-multiple.cpp
|
tibbetts/inside-c
|
a72f6d44f15343e81b35da8edadd0e9c63315d40
|
[
"MIT"
] | 18
|
2015-01-19T04:18:49.000Z
|
2022-03-04T06:22:44.000Z
|
examples/complex-multiple.cpp
|
tibbetts/inside-c
|
a72f6d44f15343e81b35da8edadd0e9c63315d40
|
[
"MIT"
] | null | null | null |
examples/complex-multiple.cpp
|
tibbetts/inside-c
|
a72f6d44f15343e81b35da8edadd0e9c63315d40
|
[
"MIT"
] | 4
|
2020-02-19T22:29:23.000Z
|
2021-09-22T16:45:52.000Z
|
#include <stdio.h>
class baseA2 {
int dataA;
public:
void setDataA(int a);
virtual int getDataA() const;
};
class baseB2 {
int dataB;
public:
void setDataB(int b);
virtual int getDataB() const;
};
class subBoth2 : public baseA2, public baseB2 {
public:
virtual int getSum() const;
// Overrise get data methods for fun.
virtual int getDataA() const;
virtual int getDataB() const;
};
void baseA2::setDataA(int a) {
dataA = a;
}
int baseA2::getDataA() const {
return dataA;
}
void baseB2::setDataB(int b) {
dataB = b;
}
int baseB2::getDataB() const {
return dataB;
}
int subBoth2::getSum() const {
int total = 0;
total += getDataA();
total += getDataB();
return total;
}
int subBoth2::getDataA() const {
printf("calling getDataA()\n");
return baseA2::getDataA();
}
int subBoth2::getDataB() const {
printf("calling getDataB()\n");
return baseB2::getDataB();
}
int complexMultiple(int argc, const char **argv) {
subBoth2 *sb = new subBoth2;
sb->getSum();
baseA2 *ba = sb;
ba->setDataA(12);
ba->getDataA();
baseB2 *bb = sb;
bb->setDataB(13);
bb->getDataB();
printf("sb->getSum()=%d", sb->getSum());
return 0;
}
| 16.269231
| 50
| 0.600473
|
tibbetts
|
9f906a21c2240b9698af3b573e97a36b17ec10f5
| 694
|
hpp
|
C++
|
graphics-library/include/engine/buffer.hpp
|
thetorine/opengl3-library
|
3904d857fd1085ba2c57c4289eb0e0d123f11a14
|
[
"MIT"
] | null | null | null |
graphics-library/include/engine/buffer.hpp
|
thetorine/opengl3-library
|
3904d857fd1085ba2c57c4289eb0e0d123f11a14
|
[
"MIT"
] | null | null | null |
graphics-library/include/engine/buffer.hpp
|
thetorine/opengl3-library
|
3904d857fd1085ba2c57c4289eb0e0d123f11a14
|
[
"MIT"
] | null | null | null |
#pragma once
#include <vector>
#include <GL/glew.h>
namespace gl::engine {
template <class T>
class Buffer {
public:
Buffer(GLuint mode);
Buffer(const std::vector<T> &data, GLuint mode);
~Buffer();
void transferBuffer();
void useBuffer();
void addElement(T element);
void addAll(const std::vector<T> &elements);
void resize(size_t space);
void clear();
size_t size();
size_t capacity();
private:
GLuint m_bufferIndex;
bool m_bufferCreated;
GLuint m_mode;
T *m_data;
size_t m_size;
size_t m_capacity;
};
}
| 22.387097
| 57
| 0.538905
|
thetorine
|
9f958685b1a07c29dbdb337111f211b76513a1ed
| 1,791
|
cc
|
C++
|
Code/0023-merge-k-sorted-lists.cc
|
SMartQi/Leetcode
|
9e35c65a48ba1ecd5436bbe07dd65f993588766b
|
[
"MIT"
] | 2
|
2019-12-06T14:08:57.000Z
|
2020-01-15T15:25:32.000Z
|
Code/0023-merge-k-sorted-lists.cc
|
SMartQi/Leetcode
|
9e35c65a48ba1ecd5436bbe07dd65f993588766b
|
[
"MIT"
] | 1
|
2020-01-15T16:29:16.000Z
|
2020-01-26T12:40:13.000Z
|
Code/0023-merge-k-sorted-lists.cc
|
SMartQi/Leetcode
|
9e35c65a48ba1ecd5436bbe07dd65f993588766b
|
[
"MIT"
] | null | null | null |
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
// devide and conquer
ListNode* mergeKLists(vector<ListNode*>& lists) {
if (lists.size() == 0) return NULL;
if (lists.size() == 1) return lists[0];
return mergeKListsHelper(lists, 0, lists.size() - 1);
}
ListNode* mergeKListsHelper(vector<ListNode*>& lists, int start, int end) {
if (start == end) {
return lists[start];
}
if (start + 1 == end) {
return mergeTwoLists(lists[start], lists[end]);
}
ListNode* l1 = mergeKListsHelper(lists, start, (start + end) / 2);
ListNode* l2 = mergeKListsHelper(lists, (start + end) / 2 + 1, end);
return mergeTwoLists(l1, l2);
}
// This is copied from #21 Merge Two Sorted Lists.
// Not the optimal solution.
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
// l1 == NULL -> !l1
if (!l1) {
return l2;
}
if (!l2) {
return l1;
}
ListNode *head = new ListNode(0);
ListNode *origin = head;
ListNode *nl1 = l1;
ListNode *nl2 = l2;
while (nl1 && nl2) {
if (nl1 -> val < nl2 -> val) {
head -> next = nl1;
head = head -> next;
nl1 = nl1 -> next;
} else {
head -> next = nl2;
head = head -> next;
nl2 = nl2 -> next;
}
}
if (nl1) {
head -> next = nl1;
}
if (nl2) {
head -> next = nl2;
}
return origin -> next;
}
};
| 28.428571
| 79
| 0.463987
|
SMartQi
|
7a074a79f6a0c65079215508acdd207f8326c2e3
| 6,880
|
cpp
|
C++
|
src/mongo/db/repl/repl_client_info.cpp
|
benety/mongo
|
203430ac9559f82ca01e3cbb3b0e09149fec0835
|
[
"Apache-2.0"
] | null | null | null |
src/mongo/db/repl/repl_client_info.cpp
|
benety/mongo
|
203430ac9559f82ca01e3cbb3b0e09149fec0835
|
[
"Apache-2.0"
] | null | null | null |
src/mongo/db/repl/repl_client_info.cpp
|
benety/mongo
|
203430ac9559f82ca01e3cbb3b0e09149fec0835
|
[
"Apache-2.0"
] | null | null | null |
/**
* Copyright (C) 2018-present MongoDB, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the Server Side Public License, version 1,
* as published by MongoDB, Inc.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* Server Side Public License for more details.
*
* You should have received a copy of the Server Side Public License
* along with this program. If not, see
* <http://www.mongodb.com/licensing/server-side-public-license>.
*
* As a special exception, the copyright holders give permission to link the
* code of portions of this program with the OpenSSL library under certain
* conditions as described in each individual source file and distribute
* linked combinations including the program with the OpenSSL library. You
* must comply with the Server Side Public License in all respects for
* all of the code used other than as permitted herein. If you modify file(s)
* with this exception, you may extend this exception to your version of the
* file(s), but you are not obligated to do so. If you do not wish to do so,
* delete this exception statement from your version. If you delete this
* exception statement from all source files in the program, then also delete
* it in the license file.
*/
#include "mongo/platform/basic.h"
#include "mongo/db/repl/repl_client_info.h"
#include "mongo/db/client.h"
#include "mongo/db/operation_context.h"
#include "mongo/db/repl/replication_coordinator.h"
#include "mongo/logv2/log.h"
#include "mongo/util/decorable.h"
#define MONGO_LOGV2_DEFAULT_COMPONENT ::mongo::logv2::LogComponent::kReplication
namespace mongo {
namespace repl {
const Client::Decoration<ReplClientInfo> ReplClientInfo::forClient =
Client::declareDecoration<ReplClientInfo>();
namespace {
// We use a struct to wrap lastOpSetExplicitly here in order to give the boolean a default value
// when initially constructed for the associated OperationContext.
struct LastOpInfo {
bool lastOpSetExplicitly = false;
};
static const OperationContext::Decoration<LastOpInfo> lastOpInfo =
OperationContext::declareDecoration<LastOpInfo>();
} // namespace
bool ReplClientInfo::lastOpWasSetExplicitlyByClientForCurrentOperation(
OperationContext* opCtx) const {
return lastOpInfo(opCtx).lastOpSetExplicitly;
}
void ReplClientInfo::setLastOp(OperationContext* opCtx, const OpTime& ot) {
invariant(ot >= _lastOp);
_lastOp = ot;
lastOpInfo(opCtx).lastOpSetExplicitly = true;
}
void ReplClientInfo::setLastOpToSystemLastOpTime(OperationContext* opCtx) {
auto replCoord = repl::ReplicationCoordinator::get(opCtx->getServiceContext());
if (replCoord->isReplEnabled() && opCtx->writesAreReplicated()) {
auto latestWriteOpTimeSW = replCoord->getLatestWriteOpTime(opCtx);
auto status = latestWriteOpTimeSW.getStatus();
OpTime systemOpTime;
if (status.isOK()) {
systemOpTime = latestWriteOpTimeSW.getValue();
} else {
// Fall back to use my lastAppliedOpTime if we failed to get the latest OpTime from
// storage. In most cases, it is safe to ignore errors because if
// getLatestWriteOpTime returns an error, we cannot use the same opCtx to wait for
// writeConcern anyways. But getLastError from the same client could use a different
// opCtx to wait for the lastOp. So this is a best effort attempt to set the lastOp
// to the in-memory lastAppliedOpTime (which could be lagged). And this is a known
// bug in getLastError.
systemOpTime = replCoord->getMyLastAppliedOpTime();
if (status == ErrorCodes::OplogOperationUnsupported ||
status == ErrorCodes::NamespaceNotFound ||
status == ErrorCodes::CollectionIsEmpty || ErrorCodes::isNotPrimaryError(status)) {
// It is ok if the storage engine does not support getLatestOplogTimestamp() or
// if the oplog is empty. If the node stepped down in between, it is correct to
// use lastAppliedOpTime as last OpTime.
status = Status::OK();
}
// We will continue trying to set client's lastOp to lastAppliedOpTime as a best-effort
// alternative to getLatestWriteOpTime. And we will then throw after setting client's
// lastOp if getLatestWriteOpTime has failed with a error code other than the ones
// above.
}
// If the system timestamp has gone backwards, that must mean that there was a rollback.
// If the system optime has a higher term but a lower timestamp than the client's lastOp, it
// means that this node's wallclock time was ahead of the current primary's before it rolled
// back. This is safe, but the timestamp of the last op for a Client should never go
// backwards, so just leave the last op for this Client as it was.
if (systemOpTime.getTerm() >= _lastOp.getTerm() &&
systemOpTime.getTimestamp() >= _lastOp.getTimestamp()) {
_lastOp = systemOpTime;
} else {
LOGV2(21280,
"Not setting the last OpTime for this Client from {lastOp} to the current system "
"time of {systemOpTime} as that would be moving the OpTime backwards. This "
"should only happen if there was a rollback recently",
"Not setting the last OpTime for this Client to the current system time as that "
"would be moving the OpTime backwards. This should only happen if there was a "
"rollback recently",
"lastOp"_attr = _lastOp,
"systemOpTime"_attr = systemOpTime);
}
lastOpInfo(opCtx).lastOpSetExplicitly = true;
// Throw if getLatestWriteOpTime failed.
uassertStatusOK(status);
}
}
void ReplClientInfo::setLastOpToSystemLastOpTimeIgnoringInterrupt(OperationContext* opCtx) {
try {
repl::ReplClientInfo::forClient(opCtx->getClient()).setLastOpToSystemLastOpTime(opCtx);
} catch (const ExceptionForCat<ErrorCategory::Interruption>& e) {
// In most cases, it is safe to ignore interruption errors because we cannot use the same
// OperationContext to wait for writeConcern anyways.
LOGV2_DEBUG(21281,
2,
"Ignoring set last op interruption error: {error}",
"Ignoring set last op interruption error",
"error"_attr = e.toStatus());
}
}
} // namespace repl
} // namespace mongo
| 47.448276
| 100
| 0.680814
|
benety
|
7a0c22249608e06bf74446b494022b691247e020
| 3,225
|
cpp
|
C++
|
MonoNative.Tests/mscorlib/System/Runtime/Remoting/Channels/mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture.cpp
|
brunolauze/MonoNative
|
959fb52c2c1ffe87476ab0d6e4fcce0ad9ce1e66
|
[
"BSD-2-Clause"
] | 7
|
2015-03-10T03:36:16.000Z
|
2021-11-05T01:16:58.000Z
|
MonoNative.Tests/mscorlib/System/Runtime/Remoting/Channels/mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture.cpp
|
brunolauze/MonoNative
|
959fb52c2c1ffe87476ab0d6e4fcce0ad9ce1e66
|
[
"BSD-2-Clause"
] | 1
|
2020-06-23T10:02:33.000Z
|
2020-06-24T02:05:47.000Z
|
MonoNative.Tests/mscorlib/System/Runtime/Remoting/Channels/mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture.cpp
|
brunolauze/MonoNative
|
959fb52c2c1ffe87476ab0d6e4fcce0ad9ce1e66
|
[
"BSD-2-Clause"
] | null | null | null |
// Mono Native Fixture
// Assembly: mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// Namespace: System.Runtime.Remoting.Channels
// Name: BaseChannelWithProperties
// C++ Typed Name: mscorlib::System::Runtime::Remoting::Channels::BaseChannelWithProperties
#include <gtest/gtest.h>
#include <mscorlib/System/Runtime/Remoting/Channels/mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties.h>
#include <mscorlib/System/mscorlib_System_Array.h>
#include <mscorlib/System/mscorlib_System_Type.h>
#include <mscorlib/System/mscorlib_System_String.h>
namespace mscorlib
{
namespace System
{
namespace Runtime
{
namespace Remoting
{
namespace Channels
{
//Public Methods Tests
//Public Properties Tests
// Property Properties
// Return Type: mscorlib::System::Collections::IDictionary
// Property Get Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,get_Properties_Test)
{
}
// Property Count
// Return Type: mscorlib::System::Int32
// Property Get Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,get_Count_Test)
{
}
// Property IsFixedSize
// Return Type: mscorlib::System::Boolean
// Property Get Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,get_IsFixedSize_Test)
{
}
// Property IsReadOnly
// Return Type: mscorlib::System::Boolean
// Property Get Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,get_IsReadOnly_Test)
{
}
// Property IsSynchronized
// Return Type: mscorlib::System::Boolean
// Property Get Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,get_IsSynchronized_Test)
{
}
// Property Item
// Return Type: mscorlib::System::Object
// Property Get Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,get_Item_Test)
{
}
// Property Item
// Return Type: mscorlib::System::Object
// Property Set Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,set_Item_Test)
{
}
// Property Keys
// Return Type: mscorlib::System::Collections::ICollection
// Property Get Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,get_Keys_Test)
{
}
// Property SyncRoot
// Return Type: mscorlib::System::Object
// Property Get Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,get_SyncRoot_Test)
{
}
// Property Values
// Return Type: mscorlib::System::Collections::ICollection
// Property Get Method
TEST(mscorlib_System_Runtime_Remoting_Channels_BaseChannelWithProperties_Fixture,get_Values_Test)
{
}
}
}
}
}
}
| 25.393701
| 122
| 0.694264
|
brunolauze
|
7a0c778cf62781d9395276c59eb7535998023619
| 1,655
|
cpp
|
C++
|
src/common/SettingsAPI/FileWatcher.cpp
|
tameemzabalawi/PowerToys
|
5c6f7b1aea90ecd9ebe5cb8c7ddf82f8113fcb45
|
[
"MIT"
] | 76,518
|
2019-05-06T22:50:10.000Z
|
2022-03-31T22:20:54.000Z
|
src/common/SettingsAPI/FileWatcher.cpp
|
Nakatai-0322/PowerToys
|
1f64c1cf837ca958ad14dc3eb7887f36220a1ef9
|
[
"MIT"
] | 15,530
|
2019-05-07T01:10:24.000Z
|
2022-03-31T23:48:46.000Z
|
src/common/SettingsAPI/FileWatcher.cpp
|
Nakatai-0322/PowerToys
|
1f64c1cf837ca958ad14dc3eb7887f36220a1ef9
|
[
"MIT"
] | 5,184
|
2019-05-06T23:32:32.000Z
|
2022-03-31T15:43:25.000Z
|
#include "pch.h"
#include "FileWatcher.h"
std::optional<FILETIME> FileWatcher::MyFileTime()
{
HANDLE hFile = CreateFileW(m_path.c_str(), FILE_READ_ATTRIBUTES, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
std::optional<FILETIME> result;
if (hFile != INVALID_HANDLE_VALUE)
{
FILETIME lastWrite;
if (GetFileTime(hFile, nullptr, nullptr, &lastWrite))
{
result = lastWrite;
}
CloseHandle(hFile);
}
return result;
}
void FileWatcher::Run()
{
while (1)
{
auto lastWrite = MyFileTime();
if (!m_lastWrite.has_value())
{
m_lastWrite = lastWrite;
}
else if (lastWrite.has_value())
{
if (m_lastWrite->dwHighDateTime != lastWrite->dwHighDateTime ||
m_lastWrite->dwLowDateTime != lastWrite->dwLowDateTime)
{
m_lastWrite = lastWrite;
m_callback();
}
}
if (WaitForSingleObject(m_abortEvent, m_refreshPeriod) == WAIT_OBJECT_0)
{
return;
}
}
}
FileWatcher::FileWatcher(const std::wstring& path, std::function<void()> callback, DWORD refreshPeriod) :
m_refreshPeriod(refreshPeriod),
m_path(path),
m_callback(callback)
{
m_abortEvent = CreateEventW(nullptr, TRUE, FALSE, nullptr);
if (m_abortEvent)
{
m_thread = std::thread([this]() { Run(); });
}
}
FileWatcher::~FileWatcher()
{
if (m_abortEvent)
{
SetEvent(m_abortEvent);
m_thread.join();
CloseHandle(m_abortEvent);
}
}
| 23.985507
| 161
| 0.587311
|
tameemzabalawi
|
7a0dbe3744ce2ca50f734d850a0889314ee4abe4
| 396
|
cpp
|
C++
|
C++/Introduction/functions.cpp
|
abivilion/Hackerank-Solutions-
|
e195fb1fce1588171cf12d99d38da32ca5c8276a
|
[
"MIT"
] | null | null | null |
C++/Introduction/functions.cpp
|
abivilion/Hackerank-Solutions-
|
e195fb1fce1588171cf12d99d38da32ca5c8276a
|
[
"MIT"
] | null | null | null |
C++/Introduction/functions.cpp
|
abivilion/Hackerank-Solutions-
|
e195fb1fce1588171cf12d99d38da32ca5c8276a
|
[
"MIT"
] | null | null | null |
#include <iostream>
// #include<bits/stdc++.h>
#include <algorithm>
using namespace std;
int max_of_four(int a,int b,int c,int d)
{
return((a>b?a:b)>(c>d?c:d)?(a>b?a:b):(c>d?c:d));
}
/*
Add `int max_of_four(int a, int b, int c, int d)` here.
*/
int main() {
int a, b, c, d;
cin>>a>>b>>c>>d;
int ans = max_of_four(a, b, c, d);
cout<<ans;
return 0;
}
| 18.857143
| 56
| 0.527778
|
abivilion
|
7a119a2a1f728861dc65230064dc8d0d8916cc26
| 1,053
|
hpp
|
C++
|
include/entity.hpp
|
alsymd/BreakOut
|
055befbb61b0a3080b9a7d67359c0dbaf13eb596
|
[
"WTFPL"
] | null | null | null |
include/entity.hpp
|
alsymd/BreakOut
|
055befbb61b0a3080b9a7d67359c0dbaf13eb596
|
[
"WTFPL"
] | null | null | null |
include/entity.hpp
|
alsymd/BreakOut
|
055befbb61b0a3080b9a7d67359c0dbaf13eb596
|
[
"WTFPL"
] | null | null | null |
#ifndef ALS_ENTITY_HPP
#define ALS_ENTITY_HPP
#include"rect_shape.hpp"
#include<memory>
#include<libguile.h>
namespace als
{
class texture;
class renderer;
class moving_entity;
class entity
{
public:
entity();
entity(const rect_shape &shape, const std::string &texture_path);
virtual ~entity()=default;
virtual void render(const renderer &rend)const;
void handle_collide(entity &rhs);
void register_ball_callback(SCM cb);
void register_entity_callback(SCM cb);
void set_x(float x);
void set_y(float y);
void set_texture(const std::string &texture_path);
rect_shape &collider();
const rect_shape &collider()const;
virtual void apply_scm_callback(entity &rhs);
virtual void apply_scm_callback_ball(moving_entity &rhs);
virtual void apply_scm_callback_entity(entity &rhs);
protected:
std::shared_ptr<SCM> on_collision_with_ball = nullptr;
std::shared_ptr<SCM> on_collision_with_entity = nullptr;
rect_shape collider_;
std::shared_ptr<texture>texture_;
};
}
#endif
| 28.459459
| 69
| 0.733143
|
alsymd
|
7a1254581b03595c27d4a4b5c40b45818d71b741
| 219
|
cpp
|
C++
|
most_significant_bit.cpp
|
WizArdZ3658/Data-Structures-and-Algorithms
|
4098c0680c13127473d7ce6a41ead519559ff962
|
[
"MIT"
] | 3
|
2020-09-14T04:50:13.000Z
|
2021-04-17T06:42:43.000Z
|
most_significant_bit.cpp
|
WizArdZ3658/Data-Structures-and-Algorithms
|
4098c0680c13127473d7ce6a41ead519559ff962
|
[
"MIT"
] | null | null | null |
most_significant_bit.cpp
|
WizArdZ3658/Data-Structures-and-Algorithms
|
4098c0680c13127473d7ce6a41ead519559ff962
|
[
"MIT"
] | null | null | null |
#include<iostream>
#include<cmath>
using namespace std;
int setBit(int n)
{
int k = (int)(log2(n));
return 1<<k;
}
int main()
{
int n;
cin >> n;
cout << "Most significant bits : " << setBit(n) << '\n';
return 0;
}
| 14.6
| 57
| 0.593607
|
WizArdZ3658
|
7a127378c9db1bbd9fe4acd3311449e774f65633
| 5,339
|
cpp
|
C++
|
csv/applications/csv-from-columns.cpp
|
mission-systems-pty-ltd/comma
|
3ccec0b206fb15a8c048358a7fc01be61a7e4f1e
|
[
"BSD-3-Clause"
] | 21
|
2015-05-07T06:11:09.000Z
|
2022-02-01T09:55:46.000Z
|
csv/applications/csv-from-columns.cpp
|
mission-systems-pty-ltd/comma
|
3ccec0b206fb15a8c048358a7fc01be61a7e4f1e
|
[
"BSD-3-Clause"
] | 17
|
2015-01-16T01:38:08.000Z
|
2020-03-30T09:05:01.000Z
|
csv/applications/csv-from-columns.cpp
|
mission-systems-pty-ltd/comma
|
3ccec0b206fb15a8c048358a7fc01be61a7e4f1e
|
[
"BSD-3-Clause"
] | 13
|
2016-01-13T01:29:29.000Z
|
2022-02-01T09:55:49.000Z
|
// This file is part of comma, a generic and flexible library
// Copyright (c) 2011 The University of Sydney
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. Neither the name of the University of Sydney nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
// GRANTED BY THIS LICENSE. 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.
#include <iostream>
#include <boost/lexical_cast.hpp>
#include "../../application/command_line_options.h"
static void usage()
{
std::cerr << std::endl;
std::cerr << "take fixed-column format, output csv" << std::endl;
std::cerr << "trailing whitespaces will be removed" << std::endl;
std::cerr << "(since some systems still use fixed-column files)" << std::endl;
std::cerr << std::endl;
std::cerr << "usage: cat fixed-column.txt | csv-from-columns <sizes> [<options>] > fixed-columns.csv" << std::endl;
std::cerr << std::endl;
std::cerr << "sizes: field sizes in bytes, e.g. \"8,4,4\"" << std::endl;
std::cerr << " shortcuts: \"8,3*4\" is the same as \"8,4,4,4\"" << std::endl;
std::cerr << std::endl;
std::cerr << "options" << std::endl;
std::cerr << " --delimiter,-d=<delimiter>: output delimiter; default: \",\"" << std::endl;
std::cerr << std::endl;
exit( 1 );
}
int main( int ac, char** av )
{
try
{
comma::command_line_options options( ac, av );
if( options.exists( "--help,-h" ) ) { usage(); }
char delimiter = options.value( "--delimiter,-d", ',' );
std::vector< std::string > unnamed = options.unnamed( "", "--delimiter,-d" );
if( unnamed.empty() ) { std::cerr << "csv-from-columns: expected column sizes, got none" << std::endl; return 1; }
std::vector< unsigned int > sizes;
std::vector< std::string > v = comma::split( unnamed[0], ',' );
for( std::size_t i = 0; i < v.size(); ++i )
{
std::vector< std::string > w = comma::split( v[i], '*' );
if( w[0].empty() ) { std::cerr << "csv-from-columns: invalid column size format: " << unnamed[0] << std::endl; return 1; }
switch( w.size() )
{
case 1:
sizes.push_back( boost::lexical_cast< unsigned int >( w[0] ) );
break;
case 2:
sizes.resize( sizes.size() + boost::lexical_cast< unsigned int >( w[0] ), boost::lexical_cast< unsigned int >( w[1] ) );
break;
default:
std::cerr << "csv-from-columns: invalid column size format: " << unnamed[0] << std::endl;
return 1;
}
}
while( std::cin.good() && !std::cin.eof() )
{
std::string line;
std::getline( std::cin, line );
if( line.empty() ) { break; }
std::size_t size = line.size() - 1; // eat end of line
if( line.empty() ) { continue; }
const char* it = &line[0];
const char* end = &line[0] + size;
std::string d;
for( std::size_t i = 0; i < sizes.size(); it += sizes[i], ++i )
{
std::cout << d;
if( it < end )
{
std::string s( it, ( it + sizes[i] ) > end ? end - it : sizes[i] );
std::string::size_type first = s.find_first_not_of( ' ' );
std::string::size_type last = s.find_last_not_of( ' ' );
if( last != std::string::npos ) { std::cout.write( it + first, last - first + 1 ); }
}
d = delimiter;
}
std::cout << std::endl;
}
return 0;
}
catch( std::exception& ex )
{
std::cerr << "csv-from-columns: " << ex.what() << std::endl;
}
catch( ... )
{
std::cerr << "csv-from-columns: unknown exception" << std::endl;
}
return 1;
}
| 46.025862
| 140
| 0.575763
|
mission-systems-pty-ltd
|
7a12ec057d99a8474bb33f0fa20104b8d2b0179f
| 345
|
hpp
|
C++
|
include/lexer_helpers.hpp
|
mujido/moove
|
380fd0ea2eb2ad59b62a27bb86079ecb8c5b783b
|
[
"Apache-2.0"
] | null | null | null |
include/lexer_helpers.hpp
|
mujido/moove
|
380fd0ea2eb2ad59b62a27bb86079ecb8c5b783b
|
[
"Apache-2.0"
] | null | null | null |
include/lexer_helpers.hpp
|
mujido/moove
|
380fd0ea2eb2ad59b62a27bb86079ecb8c5b783b
|
[
"Apache-2.0"
] | null | null | null |
#pragma once
#include "moove.tab.h"
namespace Moove
{
using symbol_type = BisonParser::parser::symbol_type;
symbol_type parseInteger(const char* text);
symbol_type parseReal(const char* text);
symbol_type parseObjnum(const char* text);
symbol_type parseID(const char* text);
symbol_type parseStr(const char* text);
}
| 23
| 57
| 0.727536
|
mujido
|
7a1334af9489800ebd8c62b4c5832e4b35a1dee8
| 2,220
|
cpp
|
C++
|
DBProCompiler/DBPCompiler/InstructionTableEntry.cpp
|
domydev/Dark-Basic-Pro
|
237fd8d859782cb27b9d5994f3c34bc5372b6c04
|
[
"MIT"
] | 231
|
2018-01-28T00:06:56.000Z
|
2022-03-31T21:39:56.000Z
|
DBProCompiler/DBPCompiler/InstructionTableEntry.cpp
|
domydev/Dark-Basic-Pro
|
237fd8d859782cb27b9d5994f3c34bc5372b6c04
|
[
"MIT"
] | 9
|
2016-02-10T10:46:16.000Z
|
2017-12-06T17:27:51.000Z
|
DBProCompiler/DBPCompiler/InstructionTableEntry.cpp
|
domydev/Dark-Basic-Pro
|
237fd8d859782cb27b9d5994f3c34bc5372b6c04
|
[
"MIT"
] | 66
|
2018-01-28T21:54:52.000Z
|
2022-02-16T22:50:57.000Z
|
// InstructionTableEntry.cpp: implementation of the CInstructionTableEntry class.
//
//////////////////////////////////////////////////////////////////////
// Common Includes
#include "macros.h"
// Custom Includes
#include "Declaration.h"
#include "InstructionTableEntry.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CInstructionTableEntry::CInstructionTableEntry()
{
m_dwInternalID=0;
m_dwReturnParam=0;
m_dwParamMax=0;
m_pName=NULL;
m_pDLL=NULL;
m_pDecoratedName=NULL;
m_pParamTypes=NULL;
m_pParamDesc=NULL;
m_dwHardcoreInternalValue=0;
m_dwBuildID=0;
m_pDecChain=NULL;
m_pPrev=NULL;
m_pNext=NULL;
}
CInstructionTableEntry::~CInstructionTableEntry()
{
SAFE_DELETE(m_pName);
SAFE_DELETE(m_pDLL);
SAFE_DELETE(m_pDecoratedName);
SAFE_DELETE(m_pParamTypes);
SAFE_DELETE(m_pParamDesc);
SAFE_DELETE(m_pDecChain);
}
void CInstructionTableEntry::Free(void)
{
CInstructionTableEntry* pCurrent = this;
while(pCurrent)
{
CInstructionTableEntry* pNext = pCurrent->GetNext();
delete pCurrent;
pCurrent = pNext;
}
}
void CInstructionTableEntry::Add(CInstructionTableEntry* pNew)
{
CInstructionTableEntry* pCurrent = this;
while(pCurrent->m_pNext)
pCurrent=pCurrent->m_pNext;
pCurrent->m_pNext=pNew;
pNew->m_pPrev=pCurrent;
}
void CInstructionTableEntry::Insert(CInstructionTableEntry *pNew)
{
// Get neighbors
CInstructionTableEntry* pNeighA = m_pPrev;
CInstructionTableEntry* pNeighB = this;
// Instruct neighbours to point to me
if(pNeighA) pNeighA->m_pNext = pNew;
pNeighB->m_pPrev = pNew;
// Insruct new to point to neighbors
pNew->m_pNext = pNeighB;
pNew->m_pPrev = pNeighA;
}
void CInstructionTableEntry::SetData(DWORD InternalID, CStr* pStr, CStr* pDLL, CStr* pDecoratedName, CStr* pParamTypes, DWORD returnparam, DWORD param, DWORD dwInternalId, DWORD dwBuildID)
{
// Set Instruction Data
m_dwInternalID = InternalID;
m_dwReturnParam = returnparam;
m_dwParamMax = param;
m_pName = pStr;
m_pDLL = pDLL;
m_pDecoratedName = pDecoratedName;
m_pParamTypes = pParamTypes;
m_dwHardcoreInternalValue=dwInternalId;
m_dwBuildID=dwBuildID;
}
| 24.130435
| 188
| 0.704054
|
domydev
|
7a14cd7ade6abe83b56b75484e0090df4165b121
| 6,085
|
cc
|
C++
|
arc-networkd/manager.cc
|
doitmovin/chromiumos-platform2
|
6462aaf43072307b5a40eb045a89e473381b5fda
|
[
"BSD-3-Clause"
] | null | null | null |
arc-networkd/manager.cc
|
doitmovin/chromiumos-platform2
|
6462aaf43072307b5a40eb045a89e473381b5fda
|
[
"BSD-3-Clause"
] | null | null | null |
arc-networkd/manager.cc
|
doitmovin/chromiumos-platform2
|
6462aaf43072307b5a40eb045a89e473381b5fda
|
[
"BSD-3-Clause"
] | 2
|
2021-01-26T12:37:19.000Z
|
2021-05-18T13:37:57.000Z
|
// Copyright 2016 The Chromium OS 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 "arc-networkd/manager.h"
#include <arpa/inet.h>
#include <stdint.h>
#include <utility>
#include <base/bind.h>
#include <base/logging.h>
#include <base/message_loop/message_loop.h>
#include <brillo/minijail/minijail.h>
#include "arc-networkd/ipc.pb.h"
namespace {
const char kMdnsMcastAddress[] = "224.0.0.251";
const uint16_t kMdnsPort = 5353;
const char kSsdpMcastAddress[] = "239.255.255.250";
const uint16_t kSsdpPort = 1900;
const int kMaxRandomAddressTries = 3;
const char kUnprivilegedUser[] = "arc-networkd";
const uint64_t kManagerCapMask = CAP_TO_MASK(CAP_NET_RAW);
} // namespace
namespace arc_networkd {
Manager::Manager(const Options& opt, std::unique_ptr<HelperProcess> ip_helper)
: int_ifname_(opt.int_ifname), con_ifname_(opt.con_ifname) {
ip_helper_ = std::move(ip_helper);
}
int Manager::OnInit() {
// Run with minimal privileges.
brillo::Minijail* m = brillo::Minijail::GetInstance();
struct minijail* jail = m->New();
// Most of these return void, but DropRoot() can fail if the user/group
// does not exist.
CHECK(m->DropRoot(jail, kUnprivilegedUser, kUnprivilegedUser));
m->UseCapabilities(jail, kManagerCapMask);
m->Enter(jail);
m->Destroy(jail);
// Handle subprocess lifecycle.
process_reaper_.Register(this);
process_reaper_.WatchForChild(FROM_HERE,
ip_helper_->pid(),
base::Bind(&Manager::OnSubprocessExited,
weak_factory_.GetWeakPtr(),
ip_helper_->pid()));
// This needs to execute after DBusDaemon::OnInit() creates bus_.
base::MessageLoopForIO::current()->PostTask(
FROM_HERE,
base::Bind(&Manager::InitialSetup, weak_factory_.GetWeakPtr()));
return DBusDaemon::OnInit();
}
void Manager::InitialSetup() {
shill_client_.reset(new ShillClient(std::move(bus_)));
shill_client_->RegisterDefaultInterfaceChangedHandler(
base::Bind(&Manager::OnDefaultInterfaceChanged,
weak_factory_.GetWeakPtr()));
}
void Manager::OnDefaultInterfaceChanged(const std::string& ifname) {
ClearArcIp();
neighbor_finder_.reset();
lan_ifname_ = ifname;
if (ifname.empty()) {
LOG(INFO) << "Unbinding services";
mdns_forwarder_.reset();
ssdp_forwarder_.reset();
router_finder_.reset();
} else {
LOG(INFO) << "Binding to interface " << ifname;
mdns_forwarder_.reset(new MulticastForwarder());
ssdp_forwarder_.reset(new MulticastForwarder());
router_finder_.reset(new RouterFinder());
mdns_forwarder_->Start(int_ifname_,
ifname,
kMdnsMcastAddress,
kMdnsPort,
/* allow_stateless */ true);
ssdp_forwarder_->Start(int_ifname_,
ifname,
kSsdpMcastAddress,
kSsdpPort,
/* allow_stateless */ false);
router_finder_->Start(ifname,
base::Bind(&Manager::OnRouteFound, weak_factory_.GetWeakPtr()));
}
}
void Manager::OnRouteFound(const struct in6_addr& prefix,
int prefix_len,
const struct in6_addr& router) {
if (prefix_len == 64) {
char buf[64];
LOG(INFO) << "Found IPv6 network "
<< inet_ntop(AF_INET6, &prefix, buf, sizeof(buf))
<< "/" << prefix_len
<< " route "
<< inet_ntop(AF_INET6, &router, buf, sizeof(buf));
memcpy(&random_address_, &prefix, sizeof(random_address_));
random_address_prefix_len_ = prefix_len;
random_address_tries_ = 0;
ArcIpConfig::GenerateRandom(&random_address_,
random_address_prefix_len_);
neighbor_finder_.reset(new NeighborFinder());
neighbor_finder_->Check(lan_ifname_, random_address_,
base::Bind(&Manager::OnNeighborCheckResult,
weak_factory_.GetWeakPtr()));
} else {
LOG(INFO) << "No IPv6 connectivity available";
}
}
void Manager::OnNeighborCheckResult(bool found) {
if (found) {
if (++random_address_tries_ >= kMaxRandomAddressTries) {
LOG(WARNING) << "Too many IP collisions, giving up.";
return;
}
LOG(INFO) << "Detected IP collision, retrying with a new address";
ArcIpConfig::GenerateRandom(&random_address_,
random_address_prefix_len_);
neighbor_finder_->Check(lan_ifname_, random_address_,
base::Bind(&Manager::OnNeighborCheckResult,
weak_factory_.GetWeakPtr()));
} else {
struct in6_addr router;
if (!ArcIpConfig::GetV6Address(int_ifname_, &router)) {
LOG(ERROR) << "Error reading link local address for "
<< int_ifname_;
return;
}
char buf[64];
LOG(INFO) << "Setting IPv6 address "
<< inet_ntop(AF_INET6, &random_address_, buf, sizeof(buf))
<< "/128 route "
<< inet_ntop(AF_INET6, &router, buf, sizeof(buf));
// Set up new ARC IPv6 address, NDP, and forwarding rules.
IpHelperMessage outer_msg;
SetArcIp* inner_msg = outer_msg.mutable_set_arc_ip();
inner_msg->set_prefix(&random_address_, sizeof(struct in6_addr));
inner_msg->set_prefix_len(128);
inner_msg->set_router(&router, sizeof(struct in6_addr));
inner_msg->set_lan_ifname(lan_ifname_);
ip_helper_->SendMessage(outer_msg);
}
}
void Manager::ClearArcIp() {
IpHelperMessage msg;
msg.set_clear_arc_ip(true);
ip_helper_->SendMessage(msg);
}
void Manager::OnShutdown(int* exit_code) {
ClearArcIp();
}
void Manager::OnSubprocessExited(pid_t pid, const siginfo_t& info) {
LOG(FATAL) << "Subprocess " << pid << " exited unexpectedly";
}
} // namespace arc_networkd
| 32.367021
| 78
| 0.63106
|
doitmovin
|
7a18901031429e80fb30b9c521ca5a276b2c08d3
| 21,358
|
hpp
|
C++
|
test/gemm/gemm_config.hpp
|
mkarunan/rocWMMA
|
390a2e793699a1e17c18e46d7fe51e245907f012
|
[
"MIT"
] | null | null | null |
test/gemm/gemm_config.hpp
|
mkarunan/rocWMMA
|
390a2e793699a1e17c18e46d7fe51e245907f012
|
[
"MIT"
] | null | null | null |
test/gemm/gemm_config.hpp
|
mkarunan/rocWMMA
|
390a2e793699a1e17c18e46d7fe51e245907f012
|
[
"MIT"
] | null | null | null |
/*******************************************************************************
*
* MIT License
*
* Copyright 2021-2022 Advanced Micro Devices, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*******************************************************************************/
#ifndef GEMM_CONFIG_HPP
#define GEMM_CONFIG_HPP
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include <rocwmma/rocwmma.hpp>
#include <rocwmma/rocwmma_coop.hpp>
#include <rocwmma/rocwmma_transforms.hpp>
#pragma GCC diagnostic pop
#include "gemm_coop_schedule.hpp"
#include "gemm_driver.hpp"
#include "gemm_global_mapping.hpp"
#include "gemm_local_mapping.hpp"
namespace rocwmma
{
namespace CooperativeGemm
{
namespace BlockLevel
{
struct LdsNT
{
template <uint32_t BlockM,
uint32_t BlockN,
uint32_t BlockK,
typename InputT,
typename OutputT,
typename ComputeT,
typename LayoutA,
typename LayoutB,
typename LayoutC,
typename LayoutD,
uint32_t BlocksX,
uint32_t BlocksY,
uint32_t TBlockX = 0,
uint32_t TBlockY = 0>
using GlobalMapping = GlobalMapping::BlockLevelMapping<BlockM,
BlockN,
BlockK,
InputT,
OutputT,
ComputeT,
LayoutA,
LayoutB,
LayoutC,
LayoutD,
BlocksX,
BlocksY,
TBlockX,
TBlockY>;
template <typename GlobalMapping, typename LayoutLds>
using LdsMapping = LocalMapping::LdsMappingNT<GlobalMapping, LayoutLds>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerA = typename Schedule::SameRowFwd<TBlockX, TBlockY>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerB = typename Schedule::SameColFwd<TBlockX, TBlockY>;
template <typename GlobalMapping,
typename LdsMapping,
typename CoopSchedulerA,
typename CoopSchedulerB>
using GemmDriver
= GemmDriver<GlobalMapping, LdsMapping, CoopSchedulerA, CoopSchedulerB>;
};
struct LdsTN
{
template <uint32_t BlockM,
uint32_t BlockN,
uint32_t BlockK,
typename InputT,
typename OutputT,
typename ComputeT,
typename LayoutA,
typename LayoutB,
typename LayoutC,
typename LayoutD,
uint32_t BlocksX,
uint32_t BlocksY,
uint32_t TBlockX = 0,
uint32_t TBlockY = 0>
using GlobalMapping = GlobalMapping::BlockLevelMapping<BlockM,
BlockN,
BlockK,
InputT,
OutputT,
ComputeT,
LayoutA,
LayoutB,
LayoutC,
LayoutD,
BlocksX,
BlocksY,
TBlockX,
TBlockY>;
template <typename GlobalMapping, typename LayoutLds>
using LdsMapping = LocalMapping::LdsMappingTN<GlobalMapping, LayoutLds>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerA = typename Schedule::SameRowFwd<TBlockX, TBlockY>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerB = typename Schedule::SameColFwd<TBlockX, TBlockY>;
template <typename GlobalMapping,
typename LdsMapping,
typename CoopSchedulerA,
typename CoopSchedulerB>
using GemmDriver
= GemmDriver<GlobalMapping, LdsMapping, CoopSchedulerA, CoopSchedulerB>;
};
struct LdsRF
{
template <uint32_t BlockM,
uint32_t BlockN,
uint32_t BlockK,
typename InputT,
typename OutputT,
typename ComputeT,
typename LayoutA,
typename LayoutB,
typename LayoutC,
typename LayoutD,
uint32_t BlocksX,
uint32_t BlocksY,
uint32_t TBlockX = 0,
uint32_t TBlockY = 0>
using GlobalMapping = GlobalMapping::BlockLevelMapping<BlockM,
BlockN,
BlockK,
InputT,
OutputT,
ComputeT,
LayoutA,
LayoutB,
LayoutC,
LayoutD,
BlocksX,
BlocksY,
TBlockX,
TBlockY>;
template <typename GlobalMapping, typename LayoutLds>
using LdsMapping = LocalMapping::LdsMappingRF<GlobalMapping, LayoutLds>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerA = typename Schedule::SameRowFwd<TBlockX, TBlockY>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerB = typename Schedule::SameColFwd<TBlockX, TBlockY>;
template <typename GlobalMapping,
typename LdsMapping,
typename CoopSchedulerA,
typename CoopSchedulerB>
using GemmDriver
= GemmDriver<GlobalMapping, LdsMapping, CoopSchedulerA, CoopSchedulerB>;
};
} // BlockLevel
namespace WaveLevel
{
struct LdsNT
{
template <uint32_t BlockM,
uint32_t BlockN,
uint32_t BlockK,
typename InputT,
typename OutputT,
typename ComputeT,
typename LayoutA,
typename LayoutB,
typename LayoutC,
typename LayoutD,
uint32_t BlocksX,
uint32_t BlocksY,
uint32_t TBlockX = 0,
uint32_t TBlockY = 0>
using GlobalMapping = GlobalMapping::WaveLevelMapping<BlockM,
BlockN,
BlockK,
InputT,
OutputT,
ComputeT,
LayoutA,
LayoutB,
LayoutC,
LayoutD,
BlocksX,
BlocksY,
TBlockX,
TBlockY>;
template <typename GlobalMapping, typename LayoutLds>
using LdsMapping = LocalMapping::LdsMappingNT<GlobalMapping, LayoutLds>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerA = typename Schedule::SameRowFwd<TBlockX, TBlockY>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerB = typename Schedule::SameColFwd<TBlockX, TBlockY>;
template <typename GlobalMapping,
typename LdsMapping,
typename CoopSchedulerA,
typename CoopSchedulerB>
using GemmDriver
= GemmDriver<GlobalMapping, LdsMapping, CoopSchedulerA, CoopSchedulerB>;
};
struct LdsTN
{
template <uint32_t BlockM,
uint32_t BlockN,
uint32_t BlockK,
typename InputT,
typename OutputT,
typename ComputeT,
typename LayoutA,
typename LayoutB,
typename LayoutC,
typename LayoutD,
uint32_t BlocksX,
uint32_t BlocksY,
uint32_t TBlockX = 0,
uint32_t TBlockY = 0>
using GlobalMapping = GlobalMapping::WaveLevelMapping<BlockM,
BlockN,
BlockK,
InputT,
OutputT,
ComputeT,
LayoutA,
LayoutB,
LayoutC,
LayoutD,
BlocksX,
BlocksY,
TBlockX,
TBlockY>;
template <typename GlobalMapping, typename LayoutLds>
using LdsMapping = LocalMapping::LdsMappingTN<GlobalMapping, LayoutLds>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerA = typename Schedule::SameRowFwd<TBlockX, TBlockY>;
template <uint32_t TBlockX = 0, uint32_t TBlockY = 0>
using CoopSchedulerB = typename Schedule::SameColFwd<TBlockX, TBlockY>;
template <typename GlobalMapping,
typename LdsMapping,
typename CoopSchedulerA,
typename CoopSchedulerB>
using GemmDriver
= GemmDriver<GlobalMapping, LdsMapping, CoopSchedulerA, CoopSchedulerB>;
};
} // namespace WaveLevel
namespace WorkgroupLevel
{
struct LdsNT
{
template <uint32_t BlockM,
uint32_t BlockN,
uint32_t BlockK,
typename InputT,
typename OutputT,
typename ComputeT,
typename LayoutA,
typename LayoutB,
typename LayoutC,
typename LayoutD,
uint32_t BlocksX,
uint32_t BlocksY,
uint32_t TBlockX,
uint32_t TBlockY>
using GlobalMapping = GlobalMapping::WorkgroupLevelMapping<BlockM,
BlockN,
BlockK,
InputT,
OutputT,
ComputeT,
LayoutA,
LayoutB,
LayoutC,
LayoutD,
BlocksX,
BlocksY,
TBlockX,
TBlockY>;
template <typename GlobalMapping, typename LayoutLds>
using LdsMapping = LocalMapping::LdsMappingNT<GlobalMapping, LayoutLds>;
template <uint32_t TBlockX, uint32_t TBlockY>
using CoopSchedulerA = typename Schedule::AllRowMajor<TBlockX, TBlockY>;
template <uint32_t TBlockX, uint32_t TBlockY>
using CoopSchedulerB = typename Schedule::AllRowMajor<TBlockX, TBlockY>;
template <typename GlobalMapping,
typename LdsMapping,
typename CoopSchedulerA,
typename CoopSchedulerB>
using GemmDriver
= GemmDriver<GlobalMapping, LdsMapping, CoopSchedulerA, CoopSchedulerB>;
};
struct LdsTN
{
template <uint32_t BlockM,
uint32_t BlockN,
uint32_t BlockK,
typename InputT,
typename OutputT,
typename ComputeT,
typename LayoutA,
typename LayoutB,
typename LayoutC,
typename LayoutD,
uint32_t BlocksX,
uint32_t BlocksY,
uint32_t TBlockX,
uint32_t TBlockY>
using GlobalMapping = GlobalMapping::WorkgroupLevelMapping<BlockM,
BlockN,
BlockK,
InputT,
OutputT,
ComputeT,
LayoutA,
LayoutB,
LayoutC,
LayoutD,
BlocksX,
BlocksY,
TBlockX,
TBlockY>;
template <typename GlobalMapping, typename LayoutLds>
using LdsMapping = LocalMapping::LdsMappingTN<GlobalMapping, LayoutLds>;
template <uint32_t TBlockX, uint32_t TBlockY>
using CoopSchedulerA = typename Schedule::AllRowMajor<TBlockX, TBlockY>;
template <uint32_t TBlockX, uint32_t TBlockY>
using CoopSchedulerB = typename Schedule::AllRowMajor<TBlockX, TBlockY>;
template <typename GlobalMapping,
typename LdsMapping,
typename CoopSchedulerA,
typename CoopSchedulerB>
using GemmDriver
= GemmDriver<GlobalMapping, LdsMapping, CoopSchedulerA, CoopSchedulerB>;
};
} // namespace WorkgroupLevel
} // namespace CooperativeGemm
template <>
constexpr const char* dataTypeToString<typename CooperativeGemm::BlockLevel::LdsNT>()
{
return "Block_LdsNT";
}
template <>
constexpr const char* dataTypeToString<typename CooperativeGemm::BlockLevel::LdsTN>()
{
return "Block_LdsTN";
}
template <>
constexpr const char* dataTypeToString<typename CooperativeGemm::BlockLevel::LdsRF>()
{
return "Block_LdsRF";
}
template <>
constexpr const char* dataTypeToString<typename CooperativeGemm::WaveLevel::LdsNT>()
{
return "Wave_LdsNT";
}
template <>
constexpr const char* dataTypeToString<typename CooperativeGemm::WaveLevel::LdsTN>()
{
return "Wave_LdsTN";
}
template <>
constexpr const char* dataTypeToString<typename CooperativeGemm::WorkgroupLevel::LdsNT>()
{
return "Workgroup_LdsNT";
}
template <>
constexpr const char* dataTypeToString<typename CooperativeGemm::WorkgroupLevel::LdsTN>()
{
return "Workgroup_LdsTN";
}
} // namespace rocwmma
#endif // GEMM_CONFIG_HPP
| 48.651481
| 93
| 0.374895
|
mkarunan
|
7a195c898295ad1c74cdb666dafbe6a68f74e2f2
| 3,745
|
cpp
|
C++
|
src/wrappers/win32/BHAPI_wrapper_os.cpp
|
stasinek/BHAPI
|
5d9aa61665ae2cc5c6e34415957d49a769325b2b
|
[
"BSD-3-Clause",
"MIT"
] | 3
|
2018-05-21T15:32:32.000Z
|
2019-03-21T13:34:55.000Z
|
src/wrappers/win32/BHAPI_wrapper_os.cpp
|
stasinek/BHAPI
|
5d9aa61665ae2cc5c6e34415957d49a769325b2b
|
[
"BSD-3-Clause",
"MIT"
] | null | null | null |
src/wrappers/win32/BHAPI_wrapper_os.cpp
|
stasinek/BHAPI
|
5d9aa61665ae2cc5c6e34415957d49a769325b2b
|
[
"BSD-3-Clause",
"MIT"
] | null | null | null |
/* --------------------------------------------------------------------------
*
* BHAPI++ Copyright (C) 2017, Stanislaw Stasiak, based on Haiku & ETK++, The Easy Toolkit for C++ programing
* Copyright (C) 2004-2006, Anthony Lee, All Rights Reserved
*
* BHAPI++ library is a freeware; it may be used and distributed according to
* the terms of The MIT License.
*
* 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.
*
* File: BHAPI_wrapper_os.cpp
*
* --------------------------------------------------------------------------*/
#include <os/kernel.h>
#include <kits/support/String.h>
#include <kits/private/PrivateApplication.h>
#include <winsock2.h>
#include <windows.h>
HINSTANCE b_dll_hinstance = NULL;
extern "C" {
//typedef int __stdcall WSAStartup( _In_ WORD wVersionRequested, _Out_ LPWSADATA lpWSAData);
//typedef int WSACleanup(void);
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
b_dll_hinstance = hinstDLL;
switch(fdwReason)
{
case DLL_PROCESS_ATTACH:
/* The DLL is being mapped into process's address space */
/* Do any required initialization on a per application basis, return FALSE if failed */
{
WSADATA wsaData;
WSAStartup(0x202, &wsaData);
b_system_boot_time();
BApplicationConnector::Init();
break;
}
case DLL_THREAD_ATTACH:
/* A thread is created. Do any required initialization on a per thread basis*/
{
break;
}
case DLL_PROCESS_DETACH:
/* The DLL unmapped from process's address space. Do necessary cleanup */
{
BApplicationConnector::Quit();
WSACleanup();
break;
}
case DLL_THREAD_DETACH:
/* Thread exits with cleanup */
{
break;
}
}
return TRUE;
}
char* bhapi::win32_convert_active_to_utf8(const char *str, int32 length)
{
if(str == NULL || *str == 0 || length == 0) return NULL;
int32 nChars = (int32)strlen(str);
if(length < 0 || length > nChars) length = nChars;
WCHAR *wStr = (WCHAR*)malloc(sizeof(WCHAR) * (size_t)(length + 1));
if(wStr == NULL) return NULL;
bzero(wStr, sizeof(WCHAR) * (size_t)(length + 1));
MultiByteToWideChar(CP_ACP, 0, str, length, wStr, length);
char *uStr = bhapi::unicode_convert_to_utf8((const unichar16*)wStr, -1);
free(wStr);
return uStr;
}
char* bhapi::win32_convert_utf8_to_active(const char *str, int32 length)
{
unichar16*wStr = bhapi::utf8_convert_to_unicode(str, length);
if(wStr == NULL) return NULL;
int32 len = bhapi::unicode_strlen(wStr);
char *aStr = (char*)malloc((size_t)len * 3 + 1);
if(aStr == NULL)
{
free(wStr);
return NULL;
}
bzero(aStr, (size_t)len * 3 + 1);
WideCharToMultiByte(CP_ACP, 0, (WCHAR*)wStr, -1, aStr, len * 3, NULL, NULL);
free(wStr);
return aStr;
}
} // extern "C"
| 29.031008
| 109
| 0.683311
|
stasinek
|
7a19ab9e1a905b3159798b8bbdf07c38900fe58b
| 4,128
|
hpp
|
C++
|
src/game/asteroid.hpp
|
Abergard/PMC_Asteroids
|
0df023381430a1fd5ec2675a9b1882da63a85bc5
|
[
"MIT"
] | 1
|
2019-08-29T15:07:50.000Z
|
2019-08-29T15:07:50.000Z
|
src/game/asteroid.hpp
|
Abergard/PMC_Asteroids
|
0df023381430a1fd5ec2675a9b1882da63a85bc5
|
[
"MIT"
] | null | null | null |
src/game/asteroid.hpp
|
Abergard/PMC_Asteroids
|
0df023381430a1fd5ec2675a9b1882da63a85bc5
|
[
"MIT"
] | 1
|
2017-09-29T14:41:37.000Z
|
2017-09-29T14:41:37.000Z
|
#pragma once
#include <cassert>
#include "game/game_entity.hpp"
static bool is_object_inside_screen(const component::transform& transform)
{
if (transform.position.x > 400 + 50 || transform.position.x < -400 - 50 ||
transform.position.y > 300 + 50 || transform.position.y < -300 - 50)
{
return false;
}
return true;
}
class Actor
{
public:
virtual ~Actor() = default;
virtual void update(double delta) = 0;
};
struct Asteroid : public Actor
{
game_entity* game_object;
// TODO: replace by movement component
float current_speed{1};
static const int base_speed{30};
// ...
float asteroidBuffer = 0;
Asteroid() = default;
Asteroid(std::vector<game_entity>& game_objects,
component::transform& asteroid_transform,
component::direction& asteroid_direction,
component::rendering_target& asteroid_renderer)
{
asteroid_direction.is_forward = component::direction::forward{true};
asteroid_direction.direction_x = 1;
asteroid_direction.direction_y = -1;
asteroid_renderer.is_visible = true;
asteroid_renderer.color.r = 1.0f;
asteroid_renderer.color.g = 1.0f;
asteroid_renderer.color.b = 1.0f;
asteroid_renderer.lines = {{+50.0f, -10.0f},
{+20.0f, -50.0f},
{-5.0f, -50.0f},
{-5.0f, -25.0f},
{-30.0f, -50.0f},
{-50.0f, -10.0f},
{-25.0f, 0.0f},
{-50.0f, +10.0f},
{-15.0f, +45.0f},
{+20.0f, +45.0f}};
asteroid_renderer.points = {{0.0f, 0.0f}};
game_objects.push_back(game_entity{
asteroid_transform, asteroid_renderer, asteroid_direction});
game_object = &game_objects.back();
move_to_new_position();
}
void update(const double delta) override
{
// if asteroid go on out of screen wait some time before show up in the
// new position
if (!is_object_inside_screen(
*game_object->get<component::transform>()))
{
asteroidBuffer += delta;
if (asteroidBuffer >= 2)
{
asteroidBuffer = 0;
move_to_new_position();
}
}
}
void move_to_new_position()
{
int site = rand() % 2800;
int alfa = 0;
assert(game_object->get<component::transform>() != nullptr);
assert(game_object->get<component::direction>() !=
nullptr); // FIXME: better way to be sure
// that is not null
auto& t = *game_object->get<component::transform>();
auto& d = *game_object->get<component::direction>();
if (site < 800)
{
t.position.x = static_cast<float>(site - 400);
t.position.y = 300 + 50;
t.rotation = static_cast<float>(rand() % 180 + 180);
alfa = rand() % 180 + 180;
}
else if (site < 1400)
{
t.position.x = 400 + 50;
t.position.y = static_cast<float>(site - 1100);
t.rotation = static_cast<float>(rand() % 180 + 90);
alfa = rand() % 180 + 90;
}
else if (site < 2200)
{
t.position.x = static_cast<float>(site - 1800);
t.position.y = -300 - 50;
t.rotation = static_cast<float>(rand() % 180);
alfa = rand() % 180;
}
else
{
t.position.x = -400 - 50;
t.position.y = static_cast<float>(site - 2500);
t.rotation = static_cast<float>(rand() % 180 - 90);
alfa = rand() % 180 - 90;
}
d.direction_x = cos(alfa * M_PI / 180.0f);
d.direction_y = sin(alfa * M_PI / 180.0f);
current_speed =
static_cast<float>(Asteroid::base_speed * (rand() % 3 + 1));
}
};
| 30.80597
| 79
| 0.507267
|
Abergard
|
7a19cdddd4a92e0c135cc4a773994d3cf8b3bef8
| 2,801
|
cpp
|
C++
|
project/drivers/iOSAudioDriver.cpp
|
MattTuttle/Audaxe
|
fa327e4ac959f5bd528bff626ccb005f395ad2f3
|
[
"Unlicense"
] | 2
|
2015-02-25T14:31:40.000Z
|
2016-04-05T16:59:01.000Z
|
project/drivers/iOSAudioDriver.cpp
|
MattTuttle/Audaxe
|
fa327e4ac959f5bd528bff626ccb005f395ad2f3
|
[
"Unlicense"
] | null | null | null |
project/drivers/iOSAudioDriver.cpp
|
MattTuttle/Audaxe
|
fa327e4ac959f5bd528bff626ccb005f395ad2f3
|
[
"Unlicense"
] | null | null | null |
//
// iOSAudioDriver.cpp
//
// Created by Matt Tuttle on 5/31/13.
// Copyright (c) 2013 Matt Tuttle. All rights reserved.
//
#include <iostream>
#include "iOSAudioDriver.h"
#include "AudioEngine.h"
namespace Audaxe
{
// passes buffer callback to driver
void tick(void *userData, AudioQueueRef inAQ, AudioQueueBufferRef outBuffer)
{
AudioDriver *pDriver = reinterpret_cast<AudioDriver *>(userData);
pDriver->bufferCallback(inAQ, outBuffer);
}
AudioDriver::AudioDriver()
{
mActive = false;
for (int i = 0; i < kGlobalAudioBuffers; i++)
{
mBuffers[i] = NULL;
}
}
AudioDriver::~AudioDriver()
{
}
void AudioDriver::bufferCallback(AudioQueueRef inAQ, AudioQueueBufferRef outBuffer)
{
outBuffer->mAudioDataByteSize = mBufferByteSize;
mEngine->processChannels(outBuffer->mAudioData, mBufferByteSize);
OSStatus result = AudioQueueEnqueueBuffer(mQueue, outBuffer, 0, NULL);
if (result) std::cout << "ERROR: " << result << std::endl;
}
int AudioDriver::terminate()
{
//AudioQueueStop(queue, 0);
mEngine = 0;
return 0;
}
int AudioDriver::init(AudioEngine *engine)
{
if (mActive) return 1;
mDataFormat.mSampleRate = kGlobalAudioSampleRate;
mDataFormat.mFormatID = kAudioFormatLinearPCM;
mDataFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
mDataFormat.mFramesPerPacket = 1;
mDataFormat.mChannelsPerFrame = kGlobalAudioChannels; // usually 2 for stereo
mDataFormat.mBitsPerChannel = kAudioBits;
mDataFormat.mBytesPerPacket = mDataFormat.mBytesPerFrame = (mDataFormat.mBitsPerChannel / 8) * mDataFormat.mChannelsPerFrame;
mDataFormat.mReserved = 0;
OSStatus result = AudioQueueNewOutput(&mDataFormat, tick, this, NULL, NULL, 0, &mQueue);
if (result) std::cout << "AudioQueueNewOutput: " << result << std::endl;
mBufferByteSize = kGlobalAudioBufferFrames * mDataFormat.mBytesPerFrame;
mEngine = engine;
// prime data before running
for (int i = 0; i < kGlobalAudioBuffers; ++i) {
result = AudioQueueAllocateBuffer(mQueue, mBufferByteSize, &mBuffers[i]);
if (result) std::cout << "AudioQueueAllocateBuffer: " << result << std::endl;
bufferCallback(mQueue, mBuffers[i]);
}
result = AudioQueueSetParameter(mQueue, kAudioQueueParam_Volume, 1.0);
if (result) std::cout << "AudioQueueSetParameter: " << result << std::endl;
result = AudioQueueStart(mQueue, NULL);
if (result) std::cout << "AudioQueueStart: " << result << std::endl;
mActive = true;
return 0;
}
}
| 31.122222
| 133
| 0.645127
|
MattTuttle
|
7a1bb7096617842b43d7158d7ad2ed239ef3146a
| 2,355
|
cpp
|
C++
|
src/builtin/btrc/builtin/renderer/wavefront/soa_buffer.cpp
|
AirGuanZ/Btrc
|
8865eb1506f96fb0230fb394b9fadb1e38f2b9d8
|
[
"MIT"
] | 17
|
2022-02-03T09:35:14.000Z
|
2022-03-28T04:27:05.000Z
|
src/builtin/btrc/builtin/renderer/wavefront/soa_buffer.cpp
|
AirGuanZ/Btrc
|
8865eb1506f96fb0230fb394b9fadb1e38f2b9d8
|
[
"MIT"
] | 1
|
2022-02-09T15:11:55.000Z
|
2022-02-09T15:11:55.000Z
|
src/builtin/btrc/builtin/renderer/wavefront/soa_buffer.cpp
|
AirGuanZ/Btrc
|
8865eb1506f96fb0230fb394b9fadb1e38f2b9d8
|
[
"MIT"
] | null | null | null |
#include <random>
#include <btrc/builtin/renderer/wavefront/soa_buffer.h>
BTRC_WFPT_BEGIN
RayBuffer::RayBuffer(int state_count)
{
o_medium_id_.initialize(state_count);
d_t1_.initialize(state_count);
}
RayBuffer::operator RaySOA()
{
return RaySOA{
.o_med_id_buffer = o_medium_id_,
.d_t1_buffer = d_t1_
};
}
BSDFLeBuffer::BSDFLeBuffer(int state_count)
{
beta_le_bsdf_pdf_.initialize(state_count);
}
BSDFLeBuffer::operator BSDFLeSOA()
{
return BSDFLeSOA{
.beta_le_bsdf_pdf_buffer = beta_le_bsdf_pdf_
};
}
PathBuffer::PathBuffer(int state_count)
{
pixel_coord_.initialize(state_count);
beta_depth_.initialize(state_count);
path_radiance_.initialize(state_count);
sampler_state_.initialize(state_count);
}
PathBuffer::operator PathSOA()
{
return PathSOA{
.pixel_coord_buffer = pixel_coord_,
.beta_depth_buffer = beta_depth_,
.path_radiance_buffer = path_radiance_,
.sampler_state_buffer = sampler_state_
};
}
IntersectionBuffer::IntersectionBuffer(int state_count)
{
path_flag_.initialize(state_count);
t_prim_uv_.initialize(state_count);
}
IntersectionBuffer::operator IntersectionSOA()
{
return IntersectionSOA{
.path_flag_buffer = path_flag_,
.t_prim_id_buffer = t_prim_uv_
};
}
ShadowRayBuffer::ShadowRayBuffer(int state_count)
{
pixel_coord_.initialize(state_count);
beta_li_.initialize(state_count);
ray_ = newRC<RayBuffer>(state_count);
}
ShadowRayBuffer::operator ShadowRaySOA()
{
return ShadowRaySOA{
.pixel_coord_buffer = pixel_coord_,
.beta_li_buffer = beta_li_,
.ray = *ray_
};
}
ShadowSamplerBuffer::ShadowSamplerBuffer(int state_count)
{
buffer_.initialize(state_count);
}
void ShadowSamplerBuffer::clear()
{
const int state_count = static_cast<int>(buffer_.get_size());
std::vector<IndependentSampler::State> rng_init_data(state_count);
for(int i = 0; i < state_count; ++i)
rng_init_data[i].rng = cstd::PCG::Data(static_cast<uint32_t>(i));
std::default_random_engine random_engine{ 42 };
std::shuffle(rng_init_data.begin(), rng_init_data.end(), random_engine);
buffer_.from_cpu(rng_init_data.data());
}
ShadowSamplerBuffer::operator independent_sampler_detail::State*()
{
return buffer_;
}
BTRC_WFPT_END
| 22.644231
| 76
| 0.722718
|
AirGuanZ
|
7a22d71bc92698580142f8a3b961c631c8587a82
| 871
|
cpp
|
C++
|
ACM-ICPC/5014.cpp
|
KimBoWoon/ACM-ICPC
|
146c36999488af9234d73f7b4b0c10d78486604f
|
[
"MIT"
] | null | null | null |
ACM-ICPC/5014.cpp
|
KimBoWoon/ACM-ICPC
|
146c36999488af9234d73f7b4b0c10d78486604f
|
[
"MIT"
] | null | null | null |
ACM-ICPC/5014.cpp
|
KimBoWoon/ACM-ICPC
|
146c36999488af9234d73f7b4b0c10d78486604f
|
[
"MIT"
] | null | null | null |
#include <cstdio>
#include <queue>
using namespace std;
#define MAX 1000001
int f, s, g, u, d;
int building[MAX];
queue<int> q;
void bfs() {
while (!q.empty()) {
int here = q.front();
q.pop();
// 올라간다
int next = here + u;
if (next <= f && building[next] == 0) {
building[next] = building[here] + 1;
q.push(next);
}
// 내려간다
next = here - d;
if (next > 0 && building[next] == 0) {
building[next] = building[here] + 1;
q.push(next);
}
}
}
int main() {
scanf("%d %d %d %d %d", &f, &s, &g, &u, &d);
// 현재 층 저장
building[s] = 1;
q.push(s);
bfs();
if (building[g]) {
printf("%d\n", building[g] - 1);
} else {
printf("use the stairs\n");
}
}
| 18.934783
| 49
| 0.41217
|
KimBoWoon
|
7a28f8aa3d5b9f460887a91155b581d17f9ced68
| 1,771
|
cpp
|
C++
|
1400/60/1467b.cpp
|
actium/cf
|
d7be128c3a9adb014a231a399f1c5f19e1ab2a38
|
[
"Unlicense"
] | 1
|
2020-07-03T15:55:52.000Z
|
2020-07-03T15:55:52.000Z
|
1400/60/1467b.cpp
|
actium/cf
|
d7be128c3a9adb014a231a399f1c5f19e1ab2a38
|
[
"Unlicense"
] | null | null | null |
1400/60/1467b.cpp
|
actium/cf
|
d7be128c3a9adb014a231a399f1c5f19e1ab2a38
|
[
"Unlicense"
] | 3
|
2020-10-01T14:55:28.000Z
|
2021-07-11T11:33:58.000Z
|
#include <iostream>
#include <vector>
template <typename T>
std::istream& operator >>(std::istream& input, std::vector<T>& v)
{
for (T& a : v)
input >> a;
return input;
}
void answer(unsigned v)
{
std::cout << v << '\n';
}
void solve(const std::vector<unsigned>& a)
{
const size_t n = a.size();
std::vector<size_t> x;
for (size_t i = 1; i < n-1; ++i) {
if (a[i-1] < a[i] && a[i] > a[i+1])
x.push_back(i);
if (a[i-1] > a[i] && a[i] < a[i+1])
x.push_back(i);
}
const auto check = [&](size_t i, unsigned v) {
unsigned c[2] = {};
if (i > 1) {
c[0] += (a[i-2] < a[i-1] && a[i-1] > a[i]);
c[0] += (a[i-2] > a[i-1] && a[i-1] < a[i]);
c[1] += (a[i-2] < a[i-1] && a[i-1] > v);
c[1] += (a[i-2] > a[i-1] && a[i-1] < v);
}
c[0] += (a[i-1] < a[i] && a[i] > a[i+1]);
c[0] += (a[i-1] > a[i] && a[i] < a[i+1]);
c[1] += (a[i-1] < v && v > a[i+1]);
c[1] += (a[i-1] > v && v < a[i+1]);
if (i+2 < n) {
c[0] += (a[i] < a[i+1] && a[i+1] > a[i+2]);
c[0] += (a[i] > a[i+1] && a[i+1] < a[i+2]);
c[1] += (v < a[i+1] && a[i+1] > a[i+2]);
c[1] += (v > a[i+1] && a[i+1] < a[i+2]);
}
return c[0] > c[1] ? c[0] - c[1] : 0;
};
unsigned d = 0;
for (const size_t i : x) {
d = std::max(d, check(i, a[i-1]));
d = std::max(d, check(i, a[i+1]));
}
answer(x.size() - d);
}
void test_case()
{
size_t n;
std::cin >> n;
std::vector<unsigned> a(n);
std::cin >> a;
solve(a);
}
int main()
{
size_t t;
std::cin >> t;
while (t-- > 0)
test_case();
return 0;
}
| 19.677778
| 65
| 0.36646
|
actium
|
7a2b5d78e4e25a66205637bf85cacceef9423f98
| 10,513
|
cpp
|
C++
|
Source/McRave/Resources.cpp
|
Cmccrave/CMProtoBot
|
220cddaf41724004daf5aace5b48a07e28931279
|
[
"MIT"
] | 32
|
2017-03-04T19:38:13.000Z
|
2022-03-16T02:03:01.000Z
|
Source/McRave/Resources.cpp
|
Cmccrave/CMProtoBot
|
220cddaf41724004daf5aace5b48a07e28931279
|
[
"MIT"
] | 2
|
2017-02-25T02:43:01.000Z
|
2017-02-27T00:14:55.000Z
|
Source/McRave/Resources.cpp
|
Cmccrave/CMProtoBot
|
220cddaf41724004daf5aace5b48a07e28931279
|
[
"MIT"
] | 8
|
2017-06-28T23:58:10.000Z
|
2021-04-20T16:56:08.000Z
|
#include "McRave.h"
using namespace BWAPI;
using namespace std;
using namespace UnitTypes;
namespace McRave::Resources {
namespace {
set<shared_ptr<ResourceInfo>> myMinerals;
set<shared_ptr<ResourceInfo>> myGas;
set<shared_ptr<ResourceInfo>> myBoulders;
bool mineralSat, gasSat, halfMineralSat, halfGasSat;
int miners, gassers;
int mineralCount, gasCount;
int incomeMineral, incomeGas;
int maxGas;
int maxMin;
string mapName, myRaceChar;
void updateIncome(const shared_ptr<ResourceInfo>& r)
{
auto &resource = *r;
auto cnt = resource.getGathererCount();
if (resource.getType().isMineralField())
incomeMineral += cnt == 1 ? 65 : 126;
else
incomeGas += resource.getRemainingResources() ? 103 * cnt : 26 * cnt;
}
void updateInformation(const shared_ptr<ResourceInfo>& r)
{
auto &resource = *r;
if (resource.unit()->exists())
resource.updateResource();
UnitType geyserType = Broodwar->self()->getRace().getRefinery();
// If resource is blocked from usage
if (!resource.getType().isMineralField() && resource.getTilePosition().isValid()) {
for (auto block = mapBWEM.GetTile(resource.getTilePosition()).GetNeutral(); block; block = block->NextStacked()) {
if (block && block->Unit() && block->Unit()->exists() && block->Unit()->isInvincible() && !block->IsGeyser())
resource.setResourceState(ResourceState::None);
}
}
// Update resource state
if (resource.hasStation()) {
auto base = Util::getClosestUnit(resource.getPosition(), PlayerState::Self, [&](auto &u) {
return u.getType().isResourceDepot() && u.getPosition() == resource.getStation()->getBase()->Center();
});
resource.setResourceState(ResourceState::None);
if (base) {
if (base->unit()->getRemainingBuildTime() < 300 || base->getType() == Zerg_Lair || base->getType() == Zerg_Hive || (resource.getType().isRefinery() && resource.unit()->getRemainingBuildTime() < 120))
resource.setResourceState(ResourceState::Mineable);
else
resource.setResourceState(ResourceState::Assignable);
}
}
// Update saturation
if (resource.getType().isMineralField() && resource.getResourceState() != ResourceState::None)
miners += resource.getGathererCount();
else if (resource.getType() == geyserType && resource.unit()->isCompleted() && resource.getResourceState() != ResourceState::None)
gassers += resource.getGathererCount();
if (!resource.isBoulder()) {
if (resource.getResourceState() == ResourceState::Mineable || (resource.getResourceState() == ResourceState::Assignable && Stations::getMyStations().size() >= 3 && !Players::vP())) {
resource.getType().isMineralField() ? mineralCount++ : gasCount++;
resource.getType().isMineralField() ? maxMin+=resource.getWorkerCap() : maxGas+=resource.getWorkerCap();
}
for (auto &w : resource.targetedByWhat()) {
if (auto worker = w.lock()) {
if (worker->getBuildPosition().isValid())
maxMin--, maxGas--;
}
}
}
}
void updateResources()
{
mineralCount = 0;
gasCount = 0;
miners = 0;
gassers = 0;
maxGas = 0;
maxMin = 0;
const auto update = [&](const shared_ptr<ResourceInfo>& r) {
updateInformation(r);
updateIncome(r);
};
for (auto &r : myBoulders)
update(r);
for (auto &r : myMinerals)
update(r);
for (auto &r : myGas)
update(r);
mineralSat = miners >= maxMin;
halfMineralSat = miners >= mineralCount;
gasSat = gassers >= maxGas;
halfGasSat = gassers >= gasCount;
}
}
void recheckSaturation()
{
miners = 0;
gassers = 0;
for (auto &r : myMinerals) {
auto &resource = *r;
miners += resource.getGathererCount();
}
for (auto &r : myGas) {
auto &resource = *r;
gassers += resource.getGathererCount();
}
mineralSat = miners >= maxMin;
halfMineralSat = miners >= mineralCount;
gasSat = gassers >= maxGas;
halfGasSat = gassers >= gasCount;
}
void onFrame()
{
Visuals::startPerfTest();
updateResources();
Visuals::endPerfTest("Resources");
}
void onStart()
{
// Store all resources
for (auto &resource : Broodwar->getMinerals())
storeResource(resource);
for (auto &resource : Broodwar->getGeysers())
storeResource(resource);
// Grab only the alpha characters from the map name to remove version numbers
for (auto &c : Broodwar->mapFileName()) {
if (isalpha(c))
mapName.push_back(c);
if (c == '.')
break;
}
myRaceChar = *Broodwar->self()->getRace().c_str();
ifstream readFileA("bwapi-data/AI/" + mapName + "GatherInfo" + myRaceChar + ".txt");
int x, y, cnt;
string line;
while (readFileA) {
readFileA >> x >> y >> cnt;
for (auto &mineral : myMinerals) {
if (x == mineral->getPosition().x && y == mineral->getPosition().y) {
while (cnt > 0) {
readFileA >> x >> y;
mineral->getGatherOrderPositions().insert(Position(x, y));
cnt--;
}
}
}
}
ifstream readFileB("bwapi-data/AI/" + mapName + "ReturnInfo" + myRaceChar + ".txt");
while (readFileB) {
readFileB >> x >> y >> cnt;
for (auto &mineral : myMinerals) {
if (x == mineral->getPosition().x && y == mineral->getPosition().y) {
while (cnt > 0) {
readFileB >> x >> y;
mineral->getReturnOrderPositions().insert(Position(x, y));
cnt--;
}
}
}
}
}
void onEnd()
{
ofstream readFileA("bwapi-data/AI/" + mapName + "GatherInfo" + myRaceChar + ".txt");
if (readFileA) {
for (auto &mineral : myMinerals) {
if (!mineral->getGatherOrderPositions().empty()) {
readFileA << mineral->getPosition().x << " " << mineral->getPosition().y << " " << mineral->getGatherOrderPositions().size() << "\n";
for (auto &pos : mineral->getGatherOrderPositions())
readFileA << pos.x << " " << pos.y << " ";
readFileA << "\n";
}
}
}
ofstream readFileB("bwapi-data/AI/" + mapName + "ReturnInfo" + myRaceChar + ".txt");
if (readFileB) {
for (auto &mineral : myMinerals) {
if (!mineral->getReturnOrderPositions().empty()) {
readFileB << mineral->getPosition().x << " " << mineral->getPosition().y << " " << mineral->getReturnOrderPositions().size() << "\n";
for (auto &pos : mineral->getReturnOrderPositions())
readFileB << pos.x << " " << pos.y << " ";
readFileB << "\n";
}
}
}
}
void storeResource(Unit resource)
{
auto info = ResourceInfo(resource);
auto &resourceList = (!info.isBoulder() ? (resource->getType().isMineralField() ? myMinerals : myGas) : myBoulders);
// Check if we already stored this resource
for (auto &u : resourceList) {
if (u->unit() == resource)
return;
}
// Add station
auto newStation = BWEB::Stations::getClosestStation(resource->getTilePosition());
info.setStation(newStation);
if (Stations::ownedBy(newStation) == PlayerState::Self)
info.setResourceState(ResourceState::Assignable);
resourceList.insert(make_shared<ResourceInfo>(info));
}
void removeResource(Unit unit)
{
auto &resource = getResourceInfo(unit);
if (resource) {
// Remove assignments
for (auto &u : resource->targetedByWhat()) {
if (!u.expired())
u.lock()->setResource(nullptr);
}
// Remove dead resources
if (myMinerals.find(resource) != myMinerals.end())
myMinerals.erase(resource);
else if (myBoulders.find(resource) != myBoulders.end())
myBoulders.erase(resource);
else if (myGas.find(resource) != myGas.end())
myGas.erase(resource);
}
}
shared_ptr<ResourceInfo> getResourceInfo(BWAPI::Unit unit)
{
for (auto &m : myMinerals) {
if (m->unit() == unit)
return m;
}
for (auto &b : myBoulders) {
if (b->unit() == unit)
return b;
}
for (auto &g : myGas) {
if (g->unit() == unit)
return g;
}
return nullptr;
}
int getMineralCount() { return mineralCount; }
int getGasCount() { return gasCount; }
int getIncomeMineral() { return incomeMineral; }
int getIncomeGas() { return incomeGas; }
bool isMineralSaturated() { return mineralSat; }
bool isHalfMineralSaturated() { return halfMineralSat; }
bool isGasSaturated() { return gasSat; }
bool isHalfGasSaturated() { return halfGasSat; }
set<shared_ptr<ResourceInfo>>& getMyMinerals() { return myMinerals; }
set<shared_ptr<ResourceInfo>>& getMyGas() { return myGas; }
set<shared_ptr<ResourceInfo>>& getMyBoulders() { return myBoulders; }
}
| 36.503472
| 219
| 0.512889
|
Cmccrave
|
7a2f74f47f3d04dae04872ee49ced59efeacb96e
| 1,213
|
cpp
|
C++
|
NFComm/NFNoSqlPlugin/NFNoSqlPlugin.cpp
|
sosan/NoahGameFrame
|
38c54014c5c4620b784b2c1d2cab256f42bae186
|
[
"Apache-2.0"
] | null | null | null |
NFComm/NFNoSqlPlugin/NFNoSqlPlugin.cpp
|
sosan/NoahGameFrame
|
38c54014c5c4620b784b2c1d2cab256f42bae186
|
[
"Apache-2.0"
] | null | null | null |
NFComm/NFNoSqlPlugin/NFNoSqlPlugin.cpp
|
sosan/NoahGameFrame
|
38c54014c5c4620b784b2c1d2cab256f42bae186
|
[
"Apache-2.0"
] | 1
|
2020-04-23T21:57:32.000Z
|
2020-04-23T21:57:32.000Z
|
//------------------------------------------------------------------------ -
// @FileName : NFNoSqlPlugin.cpp
// @Author : LvSheng.Huang
// @Date : 2017-02-08
// @Module : NFNoSqlPlugin
//
// -------------------------------------------------------------------------
#include "NFNoSqlPlugin.h"
#include "NFCNoSqlModule.h"
#include "NFCAsyNoSqlModule.h"
#ifdef NF_DYNAMIC_PLUGIN
NF_EXPORT void DllStartPlugin(NFIPluginManager* pm)
{
CREATE_PLUGIN(pm, NFNoSqlPlugin)
};
NF_EXPORT void DllStopPlugin(NFIPluginManager* pm)
{
DESTROY_PLUGIN(pm, NFNoSqlPlugin)
};
#endif
//////////////////////////////////////////////////////////////////////////
const int NFNoSqlPlugin::GetPluginVersion()
{
return 0;
}
const std::string NFNoSqlPlugin::GetPluginName()
{
return GET_CLASS_NAME(NFNoSqlPlugin);
}
void NFNoSqlPlugin::Install()
{
REGISTER_MODULE(pPluginManager, NFINoSqlModule, NFCNoSqlModule)
REGISTER_MODULE(pPluginManager, NFIAsyNoSqlModule, NFCAsyNoSqlModule)
}
void NFNoSqlPlugin::Uninstall()
{
UNREGISTER_MODULE(pPluginManager, NFIAsyNoSqlModule, NFCAsyNoSqlModule)
UNREGISTER_MODULE(pPluginManager, NFINoSqlModule, NFCNoSqlModule)
}
| 25.270833
| 76
| 0.597692
|
sosan
|
7a3235f7d878f261d4a83da097559338c9f3878c
| 370
|
cpp
|
C++
|
A2OJ/A/035. Lunch Rush.cpp
|
XitizVerma/Data-Structures-and-Algorithms-Advanced
|
610225eeb7e0b4ade229ec86355901ad1ca38784
|
[
"MIT"
] | 1
|
2020-08-27T06:59:52.000Z
|
2020-08-27T06:59:52.000Z
|
A2OJ/A/035. Lunch Rush.cpp
|
XitizVerma/Data-Structures-and-Algorithms-Advanced
|
610225eeb7e0b4ade229ec86355901ad1ca38784
|
[
"MIT"
] | null | null | null |
A2OJ/A/035. Lunch Rush.cpp
|
XitizVerma/Data-Structures-and-Algorithms-Advanced
|
610225eeb7e0b4ade229ec86355901ad1ca38784
|
[
"MIT"
] | null | null | null |
#include <bits/stdc++.h>
#define lli long long int
#define endl "\n"
using namespace std;
int main()
{
lli n,k,data1,data2, maxjoy = INT_MIN;
cin>>n>>k;
vector <lli> f,t;
for(int i=0; i<n; i++)
{
cin>>data1>>data2;
lli joy;
if(data2 <= k)
joy = data1;
else
joy = data1 - (data2-k);
if(joy> maxjoy)
maxjoy = joy;
}
cout<<maxjoy;
return 0;
}
| 14.230769
| 39
| 0.583784
|
XitizVerma
|
7a35846d51af6e973f4bf11d436d5eeebdc7fe25
| 471
|
cpp
|
C++
|
PDU-MonitorTest/cores/test_object.cpp
|
ChinaClever/PDU-MonitorTool
|
0ac0322d2e6ca2757fcbfdab838e6318161b1458
|
[
"Apache-2.0"
] | null | null | null |
PDU-MonitorTest/cores/test_object.cpp
|
ChinaClever/PDU-MonitorTool
|
0ac0322d2e6ca2757fcbfdab838e6318161b1458
|
[
"Apache-2.0"
] | null | null | null |
PDU-MonitorTest/cores/test_object.cpp
|
ChinaClever/PDU-MonitorTool
|
0ac0322d2e6ca2757fcbfdab838e6318161b1458
|
[
"Apache-2.0"
] | null | null | null |
/*
*
* Created on: 2021年1月1日
* Author: Lzy
*/
#include "test_object.h"
Test_Object::Test_Object(QObject *parent) : QThread(parent)
{
isRun = false;
mPacket = sDataPacket::bulid();
mItem = Cfg::bulid()->item;
mPro = mPacket->getPro();
mDev = mPacket->getDev();
mSour = mPacket->getDev(0);
mDt = &(mDev->devType);
QTimer::singleShot(500,this,SLOT(initFunSlot()));
}
Test_Object::~Test_Object()
{
isRun = false;
wait();
}
| 18.84
| 59
| 0.605096
|
ChinaClever
|
7a38ba054d4fc794e2a2e0b58610fa7013927869
| 3,253
|
cpp
|
C++
|
test/miscellaneous/style_parser.cpp
|
donpark/mapbox-gl-native
|
efa7dad89c61fe0fcc01a492e8db8e36b8f27f53
|
[
"BSD-2-Clause"
] | 1
|
2015-07-01T21:59:13.000Z
|
2015-07-01T21:59:13.000Z
|
test/miscellaneous/style_parser.cpp
|
donpark/mapbox-gl-native
|
efa7dad89c61fe0fcc01a492e8db8e36b8f27f53
|
[
"BSD-2-Clause"
] | null | null | null |
test/miscellaneous/style_parser.cpp
|
donpark/mapbox-gl-native
|
efa7dad89c61fe0fcc01a492e8db8e36b8f27f53
|
[
"BSD-2-Clause"
] | null | null | null |
#include "../fixtures/util.hpp"
#include <mbgl/style/style_parser.hpp>
#include <mbgl/util/io.hpp>
#include <rapidjson/document.h>
#include "../fixtures/fixture_log_observer.hpp"
#include <iostream>
#include <fstream>
#include <dirent.h>
using namespace mbgl;
typedef std::pair<uint32_t, std::string> Message;
typedef std::vector<Message> Messages;
class StyleParserTest : public ::testing::TestWithParam<std::string> {};
TEST_P(StyleParserTest, ParseStyle) {
const std::string &base = "test/fixtures/style_parser/" + GetParam();
rapidjson::Document infoDoc;
infoDoc.Parse<0>(util::read_file(base + ".info.json").c_str());
ASSERT_FALSE(infoDoc.HasParseError());
ASSERT_TRUE(infoDoc.IsObject());
rapidjson::Document styleDoc;
styleDoc.Parse<0>(util::read_file(base + ".style.json").c_str());
ASSERT_FALSE(styleDoc.HasParseError());
ASSERT_TRUE(styleDoc.IsObject());
FixtureLogObserver* observer = new FixtureLogObserver();
Log::setObserver(std::unique_ptr<Log::Observer>(observer));
StyleParser parser;
parser.parse(styleDoc);
for (auto it = infoDoc.MemberBegin(), end = infoDoc.MemberEnd(); it != end; it++) {
const std::string name { it->name.GetString(), it->name.GetStringLength() };
const rapidjson::Value &value = it->value;
ASSERT_EQ(true, value.IsObject());
if (value.HasMember("log")) {
const rapidjson::Value &js_log = value["log"];
ASSERT_EQ(true, js_log.IsArray());
for (rapidjson::SizeType i = 0; i < js_log.Size(); i++) {
const rapidjson::Value &js_entry = js_log[i];
ASSERT_EQ(true, js_entry.IsArray());
const uint32_t count = js_entry[rapidjson::SizeType(0)].GetUint();
const FixtureLogObserver::LogMessage message {
EventSeverityClass(js_entry[rapidjson::SizeType(1)].GetString()),
EventClass(js_entry[rapidjson::SizeType(2)].GetString()),
int64_t(-1),
js_entry[rapidjson::SizeType(3)].GetString()
};
EXPECT_EQ(count, observer->count(message)) << "Message: " << message << std::endl;
}
}
const auto &unchecked = observer->unchecked();
if (unchecked.size()) {
std::cerr << "Unchecked Log Messages (" << base << "/" << name << "): " << std::endl << unchecked;
}
ASSERT_EQ(0ul, unchecked.size());
}
}
INSTANTIATE_TEST_CASE_P(StyleParser, StyleParserTest, ::testing::ValuesIn([] {
std::vector<std::string> names;
const std::string ending = ".info.json";
const std::string style_directory = "test/fixtures/style_parser";
DIR *dir = opendir(style_directory.c_str());
if (dir != nullptr) {
for (dirent *dp = nullptr; (dp = readdir(dir)) != nullptr;) {
const std::string name = dp->d_name;
if (name.length() >= ending.length() && name.compare(name.length() - ending.length(), ending.length(), ending) == 0) {
names.push_back(name.substr(0, name.length() - ending.length()));
}
}
closedir(dir);
}
EXPECT_GT(names.size(), 0ul);
return names;
}()));
| 34.978495
| 130
| 0.608362
|
donpark
|
7a3905913bc7ab9af7618154cfda716d3ef6b1af
| 2,883
|
cpp
|
C++
|
Siv3D/src/Siv3D/Script/Bind/Script_WaveSample.cpp
|
Fuyutsubaki/OpenSiv3D
|
4370f6ebe28addd39bfdd75915c5a18e3e5e9273
|
[
"MIT"
] | null | null | null |
Siv3D/src/Siv3D/Script/Bind/Script_WaveSample.cpp
|
Fuyutsubaki/OpenSiv3D
|
4370f6ebe28addd39bfdd75915c5a18e3e5e9273
|
[
"MIT"
] | null | null | null |
Siv3D/src/Siv3D/Script/Bind/Script_WaveSample.cpp
|
Fuyutsubaki/OpenSiv3D
|
4370f6ebe28addd39bfdd75915c5a18e3e5e9273
|
[
"MIT"
] | null | null | null |
//-----------------------------------------------
//
// This file is part of the Siv3D Engine.
//
// Copyright (c) 2008-2018 Ryo Suzuki
// Copyright (c) 2016-2018 OpenSiv3D Project
//
// Licensed under the MIT License.
//
//-----------------------------------------------
# include <Siv3D/Script.hpp>
# include <Siv3D/WaveSample.hpp>
# include <Siv3D/Logger.hpp>
# include "ScriptBind.hpp"
namespace s3d
{
using namespace AngelScript;
using BindType = WaveSample;
static void CopyConstruct(const BindType& s, BindType* self)
{
new(self) BindType(s);
}
static void ConstructF(float mono, BindType* self)
{
new(self) BindType(mono);
}
static void ConstructFF(float left, float right, BindType* self)
{
new(self) BindType(left, right);
}
void RegisterWaveSample(asIScriptEngine* engine)
{
constexpr char TypeName[] = "WaveSample";
int32 r = 0;
r = engine->RegisterObjectProperty(TypeName, "float left", asOFFSET(WaveSample, left)); assert(r >= 0);
r = engine->RegisterObjectProperty(TypeName, "float right", asOFFSET(WaveSample, right)); assert(r >= 0);
r = engine->RegisterObjectBehaviour(TypeName, asBEHAVE_CONSTRUCT, "void f(const WaveSample &in)", asFUNCTION(CopyConstruct), asCALL_CDECL_OBJLAST); assert(r >= 0);
r = engine->RegisterObjectBehaviour(TypeName, asBEHAVE_CONSTRUCT, "void f(float)", asFUNCTION(ConstructF), asCALL_CDECL_OBJLAST); assert(r >= 0);
r = engine->RegisterObjectBehaviour(TypeName, asBEHAVE_CONSTRUCT, "void f(float, float)", asFUNCTION(ConstructFF), asCALL_CDECL_OBJLAST); assert(r >= 0);
r = engine->RegisterObjectMethod(TypeName, "WaveSample& opAssign(const WaveSample& in)", asMETHODPR(WaveSample, operator=, (const WaveSample&), WaveSample&), asCALL_THISCALL); assert(r >= 0);
r = engine->RegisterObjectMethod(TypeName, "WaveSample& opAssign(float)", asMETHODPR(WaveSample, operator=, (float), WaveSample&), asCALL_THISCALL); assert(r >= 0);
r = engine->RegisterObjectMethod(TypeName, "WaveSample& set(const WaveSample& in)", asMETHODPR(WaveSample, set, (const WaveSample&), WaveSample&), asCALL_THISCALL); assert(r >= 0);
r = engine->RegisterObjectMethod(TypeName, "WaveSample& set(float)", asMETHODPR(WaveSample, set, (float), WaveSample&), asCALL_THISCALL); assert(r >= 0);
r = engine->RegisterObjectMethod(TypeName, "WaveSample& set(float, float)", asMETHODPR(WaveSample, set, (float, float), WaveSample&), asCALL_THISCALL); assert(r >= 0);
r = engine->RegisterObjectMethod(TypeName, "void swapChannel()", asMETHOD(WaveSample, swapChannel), asCALL_THISCALL); assert(r >= 0);
//[[nodiscard]] constexpr WaveSampleS16 asS16() const noexcept
r = engine->SetDefaultNamespace(TypeName); assert(r >= 0);
{
r = engine->RegisterGlobalFunction("WaveSample Zero()", asFUNCTION(WaveSample::Zero), asCALL_CDECL); assert(r >= 0);
}
r = engine->SetDefaultNamespace(""); assert(r >= 0);
}
}
| 42.397059
| 193
| 0.701006
|
Fuyutsubaki
|
7a3a661eb0cb66b1614ba001791e400cabb2acd2
| 4,120
|
cpp
|
C++
|
raytracer/features/Matrix/Transform.cpp
|
Max135/Raytracer
|
4679da74d27cc2b6199f7a177ac9e08fe673c0c9
|
[
"MIT"
] | 3
|
2021-02-27T02:28:02.000Z
|
2021-03-02T13:45:11.000Z
|
raytracer/features/Matrix/Transform.cpp
|
Max135/Raytracer
|
4679da74d27cc2b6199f7a177ac9e08fe673c0c9
|
[
"MIT"
] | 1
|
2021-02-03T20:37:42.000Z
|
2021-02-04T02:46:06.000Z
|
raytracer/features/Matrix/Transform.cpp
|
Max135/Raytracer
|
4679da74d27cc2b6199f7a177ac9e08fe673c0c9
|
[
"MIT"
] | null | null | null |
//
// Created by Max on 2021-01-05.
//
#include "Transform.h"
Transform Transform::viewTransform(const Point& from, const Point& to, const Vector& up) {
Tuple forward = (to - from).normalize();
Tuple left = forward.cross(up.normalize());
Tuple trueUp = left.cross(forward);
Transform orientation;
orientation.matrix[0][0] = left.x;
orientation.matrix[0][1] = left.y;
orientation.matrix[0][2] = left.z;
orientation.matrix[1][0] = trueUp.x;
orientation.matrix[1][1] = trueUp.y;
orientation.matrix[1][2] = trueUp.z;
orientation.matrix[2][0] = -forward.x;
orientation.matrix[2][1] = -forward.y;
orientation.matrix[2][2] = -forward.z;
return orientation.translate(-from.x, -from.y, -from.z);
}
Transform Transform::translation(double x, double y, double z) {
Transform transform;
transform.matrix[0][3] = x;
transform.matrix[1][3] = y;
transform.matrix[2][3] = z;
return transform;
}
Transform Transform::scaling(double x, double y, double z) {
Transform transform;
transform.matrix[0][0] = x;
transform.matrix[1][1] = y;
transform.matrix[2][2] = z;
return transform;
}
Transform Transform::xRotation(double angle) {
Transform transform;
double cosine = cos(angle);
double sine = sin(angle);
transform.matrix[1][1] = cosine;
transform.matrix[1][2] = -sine;
transform.matrix[2][1] = sine;
transform.matrix[2][2] = cosine;
return transform;
}
Transform Transform::yRotation(double angle) {
Transform transform;
double cosine = cos(angle);
double sine = sin(angle);
transform.matrix[0][0] = cosine;
transform.matrix[0][2] = sine;
transform.matrix[2][0] = -sine;
transform.matrix[2][2] = cosine;
return transform;
}
Transform Transform::zRotation(double angle) {
Transform transform;
double cosine = cos(angle);
double sine = sin(angle);
transform.matrix[0][0] = cosine;
transform.matrix[0][1] = -sine;
transform.matrix[1][0] = sine;
transform.matrix[1][1] = cosine;
return transform;
}
Transform Transform::shearing(double xToY, double xToZ, double yToX, double yToZ, double zToX, double zToY) {
Transform transform;
transform.matrix[0][1] = xToY;
transform.matrix[0][2] = xToZ;
transform.matrix[1][0] = yToX;
transform.matrix[1][2] = yToZ;
transform.matrix[2][0] = zToX;
transform.matrix[2][1] = zToY;
return transform;
}
//TODO: Change function call to * operator
//TODO: To have normal order change this->multiply(other) to other.multiply(this)
Transform &Transform::translate(double x, double y, double z) {
return this->multiplyTransforms(Transform::translation(x, y, z));
}
Transform &Transform::scale(double x, double y, double z) {
return this->multiplyTransforms(Transform::scaling(x, y, z));
}
Transform &Transform::rotateX(double angle) {
return this->multiplyTransforms(Transform::xRotation(angle));
}
Transform &Transform::rotateY(double angle) {
return this->multiplyTransforms(Transform::yRotation(angle));
}
Transform &Transform::rotateZ(double angle) {
return this->multiplyTransforms(Transform::zRotation(angle));
}
Transform &Transform::shear(double xToY, double xToZ, double yToX, double yToZ, double zToX, double zToY) {
return this->multiplyTransforms(Transform::shearing(xToY, xToZ, yToX, yToZ, zToX, zToY));
}
//TODO: Refactor so operation can work both on Matrix and Transform
//TODO: Fix this shit (not efficient)
Transform &Transform::multiplyTransforms(const Transform &other) {
//Bugged because it changed the matrix while calculating it 🤦
Transform temp;
for (int i = 0; i < this->sizeY; ++i) {
for (int j = 0; j < this->sizeX; ++j) {
temp[i][j] = this->matrix[i][0] * other[0][j] + this->matrix[i][1] * other[1][j] +
this->matrix[i][2] * other[2][j] + this->matrix[i][3] * other[3][j];
}
}
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
this->matrix[i][j] = temp[i][j];
}
}
return *this;
}
| 27.466667
| 109
| 0.645388
|
Max135
|
7a3b3a1bf901347e386b7bf100bb81fe8bdb0d3a
| 2,530
|
cpp
|
C++
|
source/assets/font.cpp
|
xeek-pro/isometric
|
6f7d05ce597683552d5dc3078a1634fddd41092b
|
[
"MIT"
] | 1
|
2021-08-02T04:49:44.000Z
|
2021-08-02T04:49:44.000Z
|
source/assets/font.cpp
|
xeek-pro/isometric
|
6f7d05ce597683552d5dc3078a1634fddd41092b
|
[
"MIT"
] | null | null | null |
source/assets/font.cpp
|
xeek-pro/isometric
|
6f7d05ce597683552d5dc3078a1634fddd41092b
|
[
"MIT"
] | 1
|
2021-09-09T16:49:53.000Z
|
2021-09-09T16:49:53.000Z
|
#include <SDL.h>
#include <SDL_ttf.h>
#include "font.h"
#include "../source/application/application.h"
#include <algorithm>
using namespace isometric::assets;
font::font(const std::string& name)
: asset(name)
{
}
font::~font()
{
clear();
}
std::unique_ptr<font> font::load(const std::string& name, const std::string& path, const std::vector<int>& point_sizes)
{
if (!application::get_app() || !application::get_app()->is_initialized())
{
auto error_msg = std::string("Attempted to load image before an application object has been created and initialized");
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, error_msg.c_str());
throw std::exception(error_msg.c_str());
}
auto new_font = std::unique_ptr<font>(new font(name));
for (int point_size : point_sizes)
{
TTF_Font* sdl_font = TTF_OpenFont(path.c_str(), point_size);
if (sdl_font == NULL)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Failed to load font named [%s] with point size [%d] from '%s'", name.c_str(), point_size, path.c_str());
new_font.reset();
return nullptr;
}
new_font->point_sizes.push_back(point_size);
new_font->fonts[point_size] = sdl_font;
}
return std::move(new_font);
}
const std::vector<int>& isometric::assets::font::get_point_sizes() const
{
return this->point_sizes;
}
int isometric::assets::font::get_closest_point_size(int point_size) const
{
if (this->point_sizes.empty()) return 0;
else
{
return (*std::upper_bound(point_sizes.begin(), point_sizes.end() - 1, point_size));
}
}
std::unique_ptr<font> font::load(const std::string& name, const std::string& path, int point_size)
{
auto sizes = std::vector<int>{ point_size };
return std::move(load(name, path, sizes));
}
TTF_Font* font::get_font(int point_size) const
{
if (fonts.empty())
{
return nullptr;
}
else if (fonts.contains(point_size))
{
return fonts.at(point_size);
}
else
{
int closest_point_size = get_closest_point_size(point_size);
TTF_Font* closest_match = fonts.at(closest_point_size);
return closest_match;
}
}
void font::clear()
{
for (auto& pair : fonts)
{
int point_size = pair.first;
TTF_Font* sdl_font = pair.second;
if (sdl_font)
{
TTF_CloseFont(sdl_font);
sdl_font = nullptr;
}
}
point_sizes.clear();
fonts.clear();
}
| 24.563107
| 160
| 0.630435
|
xeek-pro
|
7a3b5fa521f65db58c34e584942079488b9ce37a
| 9,798
|
cpp
|
C++
|
lab07/src/GUI.cpp
|
Shaid3r/PKG
|
1eb5f5a9b1bf395821da385b075f2097801d130a
|
[
"MIT"
] | null | null | null |
lab07/src/GUI.cpp
|
Shaid3r/PKG
|
1eb5f5a9b1bf395821da385b075f2097801d130a
|
[
"MIT"
] | null | null | null |
lab07/src/GUI.cpp
|
Shaid3r/PKG
|
1eb5f5a9b1bf395821da385b075f2097801d130a
|
[
"MIT"
] | null | null | null |
///////////////////////////////////////////////////////////////////////////
// C++ code generated with wxFormBuilder (version Dec 8 2017)
// http://www.wxformbuilder.org/
//
// PLEASE DO *NOT* EDIT THIS FILE!
///////////////////////////////////////////////////////////////////////////
#include "GUI.h"
///////////////////////////////////////////////////////////////////////////
MyFrame1::MyFrame1( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxFrame( parent, id, title, pos, size, style )
{
this->SetSizeHints( wxSize( -1,-1 ), wxDefaultSize );
wxBoxSizer* bSizer1;
bSizer1 = new wxBoxSizer( wxVERTICAL );
m_panel1 = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxSize( 500,500 ), wxTAB_TRAVERSAL );
m_panel1->SetForegroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_ACTIVECAPTION ) );
m_panel1->SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_ACTIVECAPTION ) );
m_panel1->SetMinSize( wxSize( 500,500 ) );
m_panel1->SetMaxSize( wxSize( 500,500 ) );
bSizer1->Add( m_panel1, 1, wxEXPAND | wxALL, 5 );
wxBoxSizer* bSizer3;
bSizer3 = new wxBoxSizer( wxHORIZONTAL );
wxStaticBoxSizer* sbSizer1;
sbSizer1 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxT("Tryb rysowania") ), wxHORIZONTAL );
sbSizer1->SetMinSize( wxSize( -1,60 ) );
m_cb_Kontur = new wxCheckBox( sbSizer1->GetStaticBox(), wxID_ANY, wxT("Kontur"), wxDefaultPosition, wxDefaultSize, 0 );
m_cb_Kontur->SetValue(true);
sbSizer1->Add( m_cb_Kontur, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
m_cb_Mapa = new wxCheckBox( sbSizer1->GetStaticBox(), wxID_ANY, wxT("Mapa"), wxDefaultPosition, wxDefaultSize, 0 );
sbSizer1->Add( m_cb_Mapa, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
m_rb_NC = new wxRadioButton( sbSizer1->GetStaticBox(), wxID_ANY, wxT("N/C"), wxDefaultPosition, wxDefaultSize, 0 );
m_rb_NC->SetValue( true );
m_rb_NC->Enable( false );
sbSizer1->Add( m_rb_NC, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
m_rb_NZC = new wxRadioButton( sbSizer1->GetStaticBox(), wxID_ANY, wxT("N/Z/C"), wxDefaultPosition, wxDefaultSize, 0 );
m_rb_NZC->Enable( false );
sbSizer1->Add( m_rb_NZC, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
m_rb_Na_szaro = new wxRadioButton( sbSizer1->GetStaticBox(), wxID_ANY, wxT("Na szaro"), wxDefaultPosition, wxDefaultSize, 0 );
m_rb_Na_szaro->Enable( false );
sbSizer1->Add( m_rb_Na_szaro, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
bSizer3->Add( sbSizer1, 1, 0, 5 );
sbSizer2 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxT("Wybór funkcji") ), wxHORIZONTAL );
m_tb_function_1 = new wxToggleButton( sbSizer2->GetStaticBox(), wxID_ANY, wxT("1"), wxDefaultPosition, wxSize( 27,27 ), 0 );
sbSizer2->Add( m_tb_function_1, 0, wxALL, 5 );
sbSizer2->Add( 0, 0, 1, wxEXPAND, 5 );
m_tb_function_2 = new wxToggleButton( sbSizer2->GetStaticBox(), wxID_ANY, wxT("2"), wxDefaultPosition, wxSize( 27,27 ), 0 );
sbSizer2->Add( m_tb_function_2, 0, wxALL, 5 );
sbSizer2->Add( 0, 0, 1, wxEXPAND, 5 );
m_tb_function_3 = new wxToggleButton( sbSizer2->GetStaticBox(), wxID_ANY, wxT("3"), wxDefaultPosition, wxSize( 27,27 ), 0 );
sbSizer2->Add( m_tb_function_3, 0, wxALL, 5 );
sbSizer2->Add( 0, 0, 1, wxEXPAND, 5 );
m_tb_function_4 = new wxToggleButton( sbSizer2->GetStaticBox(), wxID_ANY, wxT("4"), wxDefaultPosition, wxSize( 27,27 ), 0 );
sbSizer2->Add( m_tb_function_4, 0, wxALL, 5 );
bSizer3->Add( sbSizer2, 1, wxALIGN_RIGHT, 5 );
bSizer1->Add( bSizer3, 1, wxEXPAND, 5 );
wxBoxSizer* bSizer4;
bSizer4 = new wxBoxSizer( wxHORIZONTAL );
m_s_ile_poziomic = new wxSlider( this, wxID_ANY, 5, 1, 9, wxDefaultPosition, wxDefaultSize, wxSL_HORIZONTAL );
m_s_ile_poziomic->SetMinSize( wxSize( 200,-1 ) );
bSizer4->Add( m_s_ile_poziomic, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
bSizer4->Add( 0, 0, 1, wxALIGN_CENTER_VERTICAL|wxEXPAND, 5 );
m_st_liczba_poziomic = new wxStaticText( this, wxID_ANY, wxT("Liczba poziomic: 5"), wxDefaultPosition, wxDefaultSize, 0 );
m_st_liczba_poziomic->Wrap( -1 );
bSizer4->Add( m_st_liczba_poziomic, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
bSizer4->Add( 0, 0, 1, wxALIGN_CENTER_VERTICAL|wxEXPAND, 5 );
m_tb_pokaz_punkty = new wxToggleButton( this, wxID_ANY, wxT("Pokaż punkty"), wxDefaultPosition, wxDefaultSize, 0 );
bSizer4->Add( m_tb_pokaz_punkty, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
bSizer1->Add( bSizer4, 1, wxEXPAND, 5 );
this->SetSizer( bSizer1 );
this->Layout();
this->Centre( wxBOTH );
// Connect Events
this->Connect( wxEVT_UPDATE_UI, wxUpdateUIEventHandler( MyFrame1::UpdateUI ) );
m_cb_Kontur->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( MyFrame1::m_cb_Kontur_Click ), NULL, this );
m_cb_Mapa->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( MyFrame1::m_cb_Mapa_Click ), NULL, this );
m_rb_NC->Connect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( MyFrame1::m_cb_Mapa_Click ), NULL, this );
m_rb_NZC->Connect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( MyFrame1::m_cb_Mapa_Click ), NULL, this );
m_rb_Na_szaro->Connect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( MyFrame1::m_cb_Mapa_Click ), NULL, this );
m_tb_function_1->Connect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_function_1_click ), NULL, this );
m_tb_function_2->Connect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_function_2_click ), NULL, this );
m_tb_function_3->Connect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_function_3_click ), NULL, this );
m_tb_function_4->Connect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_function_4_click ), NULL, this );
m_s_ile_poziomic->Connect( wxEVT_SCROLL_TOP, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Connect( wxEVT_SCROLL_BOTTOM, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Connect( wxEVT_SCROLL_LINEUP, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Connect( wxEVT_SCROLL_LINEDOWN, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Connect( wxEVT_SCROLL_PAGEUP, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Connect( wxEVT_SCROLL_PAGEDOWN, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Connect( wxEVT_SCROLL_THUMBTRACK, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Connect( wxEVT_SCROLL_THUMBRELEASE, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Connect( wxEVT_SCROLL_CHANGED, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_tb_pokaz_punkty->Connect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_pokaz_punkty_toggle ), NULL, this );
}
MyFrame1::~MyFrame1()
{
// Disconnect Events
this->Disconnect( wxEVT_UPDATE_UI, wxUpdateUIEventHandler( MyFrame1::UpdateUI ) );
m_cb_Kontur->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( MyFrame1::m_cb_Kontur_Click ), NULL, this );
m_cb_Mapa->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( MyFrame1::m_cb_Mapa_Click ), NULL, this );
m_rb_NC->Disconnect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( MyFrame1::m_cb_Mapa_Click ), NULL, this );
m_rb_NZC->Disconnect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( MyFrame1::m_cb_Mapa_Click ), NULL, this );
m_rb_Na_szaro->Disconnect( wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler( MyFrame1::m_cb_Mapa_Click ), NULL, this );
m_tb_function_1->Disconnect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_function_1_click ), NULL, this );
m_tb_function_2->Disconnect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_function_2_click ), NULL, this );
m_tb_function_3->Disconnect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_function_3_click ), NULL, this );
m_tb_function_4->Disconnect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_function_4_click ), NULL, this );
m_s_ile_poziomic->Disconnect( wxEVT_SCROLL_TOP, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Disconnect( wxEVT_SCROLL_BOTTOM, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Disconnect( wxEVT_SCROLL_LINEUP, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Disconnect( wxEVT_SCROLL_LINEDOWN, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Disconnect( wxEVT_SCROLL_PAGEUP, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Disconnect( wxEVT_SCROLL_PAGEDOWN, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Disconnect( wxEVT_SCROLL_THUMBTRACK, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Disconnect( wxEVT_SCROLL_THUMBRELEASE, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_s_ile_poziomic->Disconnect( wxEVT_SCROLL_CHANGED, wxScrollEventHandler( MyFrame1::m_s_ile_poziomic_scroll ), NULL, this );
m_tb_pokaz_punkty->Disconnect( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, wxCommandEventHandler( MyFrame1::m_tb_pokaz_punkty_toggle ), NULL, this );
}
| 58.670659
| 178
| 0.747091
|
Shaid3r
|
7a3c7167e30b51be47f1e749053a155d80fd741c
| 1,811
|
cpp
|
C++
|
13- Linked Lists/palindrome_ll.cpp
|
ShreyashRoyzada/C-plus-plus-Algorithms
|
9db89faf0a9b9e636aece3e7289f21ab6a1e3748
|
[
"MIT"
] | 21
|
2020-10-03T03:57:19.000Z
|
2022-03-25T22:41:05.000Z
|
13- Linked Lists/palindrome_ll.cpp
|
ShreyashRoyzada/C-plus-plus-Algorithms
|
9db89faf0a9b9e636aece3e7289f21ab6a1e3748
|
[
"MIT"
] | 40
|
2020-10-02T07:02:34.000Z
|
2021-10-30T16:00:07.000Z
|
13- Linked Lists/palindrome_ll.cpp
|
ShreyashRoyzada/C-plus-plus-Algorithms
|
9db89faf0a9b9e636aece3e7289f21ab6a1e3748
|
[
"MIT"
] | 90
|
2020-10-02T07:06:22.000Z
|
2022-03-25T22:41:17.000Z
|
// in this program we check if the given LL is a palindrome or not and return 1 for Palindrome and 0 for not palindrome
#include <iostream>
#include <stack>
using namespace std;
// linked list structure
struct Node {
int data;
struct Node *next;
Node(int x) {
data = x;
next = NULL;
}
};
// function to check given linked list is palindrome or not
bool isPalindrome(Node *head, int n);
int main()
{
int T,i,n,l,firstdata;
cin>>T;
while(T--)
{
struct Node *head = NULL, *tail = NULL;
cin>>n;
// taking first data of LL
cin>>firstdata;
head = new Node(firstdata);
tail = head;
// taking remaining data of LL
for(i=1;i<n;i++)
{
cin>>l;
tail->next = new Node(l);
tail = tail->next;
}
cout<<isPalindrome(head,n)<<endl;
}
return 0;
}
bool isPalindrome(Node *head, int n)
{
//initialize all the pointers
Node* temp=head;
Node* tempcount=head;
Node* r=head;
Node* p=NULL;
Node* q=NULL;
//if only 1 element is present
if(n==1)
return 1;
//if only 2 elements are present
if(n==2){
if(temp->data!=temp->next->data)
return 0;
else
return 1;
}
//for any number of elements present in LL
int new_count=n/2;
while(new_count>0){
r=r->next;
new_count--;
}
while(r != NULL){
p=q;
q=r;
r=r->next;
q->next=p;
}
int a = n/2;
while(a>1){
if(q->data!=temp->data){
return 0;
break;
}
q=q->next;
temp=temp->next;
a--;
}
if(q->data==temp->data)
return 1;
else
return 0;
}
| 18.479592
| 119
| 0.500276
|
ShreyashRoyzada
|
7a3de087e3b0a72a0b09de3724cad297b9c30ba7
| 527
|
hpp
|
C++
|
.experimentals/include/amtrs/compati-stl/.inc/filesystem-def.hpp
|
isaponsoft/libamtrs
|
5adf821ee15592fc3280985658ca8a4b175ffcaa
|
[
"BSD-2-Clause-FreeBSD"
] | 1
|
2019-12-10T02:12:49.000Z
|
2019-12-10T02:12:49.000Z
|
.experimentals/include/amtrs/compati-stl/.inc/filesystem-def.hpp
|
isaponsoft/libamtrs
|
5adf821ee15592fc3280985658ca8a4b175ffcaa
|
[
"BSD-2-Clause-FreeBSD"
] | null | null | null |
.experimentals/include/amtrs/compati-stl/.inc/filesystem-def.hpp
|
isaponsoft/libamtrs
|
5adf821ee15592fc3280985658ca8a4b175ffcaa
|
[
"BSD-2-Clause-FreeBSD"
] | null | null | null |
/* Copyright (c) 2019, isaponsoft (Isao Shibuya) All rights reserved. *
* Use of this source code is governed by a BSD-style license that *
* can be found in the LICENSE file. */
#ifndef __libamtrs__filesystem__stdfs__def__hpp
#define __libamtrs__filesystem__stdfs__def__hpp
#define AMTRS_STD_FILESYSTEM__NAMESPACE amtrs::compati::filesystem
#define AMTRS_STD_FILESYSTEM__NAMESPACE_BEGIN namespace AMTRS_STD_FILESYSTEM__NAMESPACE {
#define AMTRS_STD_FILESYSTEM__NAMESPACE_END }
#endif
| 52.7
| 89
| 0.772296
|
isaponsoft
|
7a459a6aa8578e9217608a55f34eff6e335dfbb4
| 520
|
cpp
|
C++
|
pgm16_01.cpp
|
neharkarvishal/Data-Structures-and-Algorithms-with-Object-Oriented-Design-Patterns-in-C-
|
c9a29d2dd43ad8561e828c25f98de6a8c8f2317a
|
[
"Unlicense"
] | 1
|
2021-07-13T03:58:36.000Z
|
2021-07-13T03:58:36.000Z
|
pgm16_01.cpp
|
neharkarvishal/Data-Structures-and-Algorithms-with-Object-Oriented-Design-Patterns-in-C-
|
c9a29d2dd43ad8561e828c25f98de6a8c8f2317a
|
[
"Unlicense"
] | null | null | null |
pgm16_01.cpp
|
neharkarvishal/Data-Structures-and-Algorithms-with-Object-Oriented-Design-Patterns-in-C-
|
c9a29d2dd43ad8561e828c25f98de6a8c8f2317a
|
[
"Unlicense"
] | null | null | null |
//
// This file contains the C++ code from Program 16.1 of
// "Data Structures and Algorithms
// with Object-Oriented Design Patterns in C++"
// by Bruno R. Preiss.
//
// Copyright (c) 1998 by Bruno R. Preiss, P.Eng. All rights reserved.
//
// http://www.pads.uwaterloo.ca/Bruno.Preiss/books/opus4/programs/pgm16_01.cpp
//
class Vertex : public Object
{
public:
typedef unsigned int Number;
protected:
Number number;
public:
Vertex (Number);
virtual operator Number () const;
// ...
};
| 23.636364
| 80
| 0.663462
|
neharkarvishal
|
7a464efdc20b7ed15edd2e2fb26ef66710b8d364
| 972
|
cpp
|
C++
|
hdu/1000/13/1335.cpp
|
TheBadZhang/OJ
|
b5407f2483aa630068343b412ecaf3a9e3303f7e
|
[
"Apache-2.0"
] | 1
|
2020-07-22T16:54:07.000Z
|
2020-07-22T16:54:07.000Z
|
hdu/1000/13/1335.cpp
|
TheBadZhang/OJ
|
b5407f2483aa630068343b412ecaf3a9e3303f7e
|
[
"Apache-2.0"
] | 1
|
2018-05-12T12:53:06.000Z
|
2018-05-12T12:53:06.000Z
|
hdu/1000/13/1335.cpp
|
TheBadZhang/OJ
|
b5407f2483aa630068343b412ecaf3a9e3303f7e
|
[
"Apache-2.0"
] | null | null | null |
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define N 20
char s[N], w[N];
char y[N];
int a, b;
int T(int x, int n) {
int s = 1;
for (int i = 1; i <= n; i++) {
s *= x;
}
return s;
}
int main() {
while (scanf("%s%d%d", s, &a, &b) != EOF) {
int i, sum = 0, l;
l = strlen(s);
for (i = 0; i < l; i++) {
if (s[i] >= '0' && s[i] <= '9') {
sum += ((s[i] - '0') * T(a, l - i - 1));
}
else if (s[i] >= 'A' && s[i] <= 'Z') {
sum += ((s[i] - 'A' + 10) * T(a, l - i - 1));
}
}
int cnt = 0;
while (sum > 0) {
int u = sum % b;
if (u >= 0 && u <= 9) {
w[cnt++] = u + '0';
}
else {
w[cnt++] = (u - 10) + 'A';
}
sum /= b;
}
for (i = 0; i < cnt; i++) {
y[i] = w[cnt - i - 1];
}
if (cnt > 7) {
printf(" ERROR");
}
else {
for (i = 0; i < 7 - cnt; i++) {
printf(" ");
}
for (i = 0; i < cnt; i++) {
printf("%c", y[i]);
}
}
printf("\n");
}
return 0;
}
| 17.357143
| 49
| 0.371399
|
TheBadZhang
|
7a47e89d4b622154aa5985afbedfcf5ac7491df7
| 1,504
|
cpp
|
C++
|
0463 - Island Perimeter/cpp/main.cpp
|
xiaoswu/Leetcode
|
e4ae8b2f72a312ee247084457cf4e6dbcfd20e18
|
[
"MIT"
] | 5
|
2018-10-18T06:47:19.000Z
|
2020-06-19T09:30:03.000Z
|
0463 - Island Perimeter/cpp/main.cpp
|
xiaoswu/Leetcode
|
e4ae8b2f72a312ee247084457cf4e6dbcfd20e18
|
[
"MIT"
] | null | null | null |
0463 - Island Perimeter/cpp/main.cpp
|
xiaoswu/Leetcode
|
e4ae8b2f72a312ee247084457cf4e6dbcfd20e18
|
[
"MIT"
] | null | null | null |
//
// main.cpp
// 463 - Island Perimeter
//
// Created by ynfMac on 2019/11/26.
// Copyright © 2019 ynfMac. All rights reserved.
//
#include <iostream>
#include <vector>
using namespace std;
class Solution {
private:
int d[4][2] = {{1,0},{-1,0},{0,1},{0, -1}};
int C,R;
bool isInArea(int x, int y){
return x >= 0 && x < C && y >= 0 && y < R;
}
public:
int islandPerimeter(vector<vector<int>>& grid) {
C = grid.size();
if (C == 0) {
return 0;
}
R = grid[0].size();
if (R == 0) {
return 0;
}
int result = 0;
for (int i = 0; i < C; i++) {
for (int j = 0; j < R; j++) {
if (grid[i][j] == 1) {
result += islandEdge(grid,i,j);
}
}
}
return result;
}
int islandEdge(vector<vector<int>>& grid, int x,int y){
int edge = 4;
cout << x;
cout << y;
for (int i = 0; i < 4;i++) {
int newX = x + d[i][0];
int newY = y + d[i][1];
if (isInArea(newX, newY) && grid[newX][newY]) {
edge --;
}
}
return edge;
}
};
int main(int argc, const char * argv[]) {
vector<vector<int>> vec = vector<vector<int>>{{1,1}};
cout << Solution().islandPerimeter(vec);
std::cout << "Hello, World!\n";
return 0;
}
| 20.60274
| 59
| 0.40891
|
xiaoswu
|
7a4816c8482dc04dc8afed51bbe499600a23b979
| 457,727
|
cpp
|
C++
|
Unity-Project/App-HL2/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs198.cpp
|
JBrentJ/mslearn-mixed-reality-and-azure-digital-twins-in-unity
|
6e13b31a0b053443b9c93267d8f174f1554e79dd
|
[
"CC-BY-4.0",
"MIT"
] | 1
|
2021-06-01T19:33:53.000Z
|
2021-06-01T19:33:53.000Z
|
Unity-Project/App-HL2/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs198.cpp
|
JBrentJ/mslearn-mixed-reality-and-azure-digital-twins-in-unity
|
6e13b31a0b053443b9c93267d8f174f1554e79dd
|
[
"CC-BY-4.0",
"MIT"
] | null | null | null |
Unity-Project/App-HL2/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs198.cpp
|
JBrentJ/mslearn-mixed-reality-and-azure-digital-twins-in-unity
|
6e13b31a0b053443b9c93267d8f174f1554e79dd
|
[
"CC-BY-4.0",
"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.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject/MeshData>
struct List_1_tFB0CB232CE88C5B88CE821554A7D3FA62CCB01FF;
// System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject/QuadData>
struct List_1_tFE68FBF4E8F070DD0335517B9447CD21B6A3535C;
// System.Byte[]
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726;
// System.Char[]
struct CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34;
// System.Int32[]
struct Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32;
// System.String[]
struct StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A;
// System.Type[]
struct TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755;
// System.UInt32[]
struct UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF;
// UnityEngine.BoxCollider
struct BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5;
// UnityEngine.GameObject
struct GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319;
// System.IFormatProvider
struct IFormatProvider_tF2AECC4B14F41D36718920D67F930CED940412DF;
// UnityEngine.MeshCollider
struct MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98;
// UnityEngine.MeshFilter
struct MeshFilter_t763BB2BBF3881176AD25E4570E6DD215BA0AA51A;
// UnityEngine.MeshRenderer
struct MeshRenderer_tCD983A2F635E12BCB0BAA2E635D96A318757908B;
// ProgressController
struct ProgressController_tF9F02EB59D94987ECAFF59CC4CA61158B949E6E8;
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50;
// SiteOverviewTurbineButton
struct SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939;
// SiteOverviewUIPanel
struct SiteOverviewUIPanel_tC1890DA197296EDD75E4E430A5254B9AC192AEA0;
// Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver
struct Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971;
// Microsoft.MixedReality.Toolkit.Utilities.Solvers.SolverHandler
struct SolverHandler_t6CF6DCC834885CCD53A484458C1B78548C6D8810;
// Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject
struct SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A;
// Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessPlanarObject
struct SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE;
// Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject
struct SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612;
// UnityEngine.Sprite
struct Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9;
// System.Data.SqlTypes.SqlBytes
struct SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6;
// System.Data.SqlTypes.SqlChars
struct SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53;
// System.Data.SqlTypes.SqlStreamChars
struct SqlStreamChars_t910B848D31E31CB82C6F50F1ECE148D614DE4665;
// System.IO.Stream
struct Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB;
// System.String
struct String_t;
// TMPro.TextMeshProUGUI
struct TextMeshProUGUI_tCC5BE8A76E6E9AF92521A462E8D81ACFBA7C85F1;
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5;
// WindTurbineGameEvent
struct WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB;
// WindTurbineScriptableObject
struct WindTurbineScriptableObject_t03D27141AD20B61458ADEA1BADEEEF48CC01E1B0;
IL2CPP_EXTERN_C RuntimeClass* ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* DoubleU5BU5D_t8E1B42EB2ABB79FBD193A6B8C8D97A7CDE44A4FB_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int16U5BU5D_tD134F1E6F746D4C09C987436805256C210C2FFCD_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int64U5BU5D_tCA61E42872C63A4286B24EEE6E0650143B43DCE6_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* String_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UInt16U5BU5D_t42D35C587B07DCDBCFDADF572C6D733AE85B2A67_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UInt64U5BU5D_t7C6E32D10F47677C1CEF3C30F4E4CE95B3A633E2_il2cpp_TypeInfo_var;
struct DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ;
struct Guid_t ;
struct IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB;
struct IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA;
struct IIterator_1_t53A3C573D4888D0C268E9C0D9515A4BDAD329CCC;
struct IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C;
struct IVectorView_1_t0652AC4EC7AA575BE5D7797DFD20689718705BE0;
struct Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 ;
struct Rect_tC45F1DDF39812623644DE296D8057A4958176627 ;
struct Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 ;
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ;
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726;
struct DoubleU5BU5D_t8E1B42EB2ABB79FBD193A6B8C8D97A7CDE44A4FB;
struct GuidU5BU5D_t6DCED1B9FC5592C43FAA73D81705104BD18151B8;
struct Int16U5BU5D_tD134F1E6F746D4C09C987436805256C210C2FFCD;
struct Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32;
struct Int64U5BU5D_tCA61E42872C63A4286B24EEE6E0650143B43DCE6;
struct SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA;
struct SiteOverviewTurbineButtonU5BU5D_t3ACBCC0C5A7D36AFE732F05FFE492AA4B8CCCF5C;
struct SolverU5BU5D_t7D4E8D7D33AE0E86ADE266E97543F909C6A9D1B6;
struct SpatialAwarenessMeshObjectU5BU5D_tA94B023FDD95287C601B9EC531C41DA60D5D0C5A;
struct SpatialAwarenessPlanarObjectU5BU5D_t772A69ED777B1C864FC824CA32DA58CA28AC6743;
struct SpatialAwarenessSceneObjectU5BU5D_t6F70086B6848AB4D5DA4B5454581DCEA06A370E3;
struct SpriteU5BU5D_t8DB77E112FFC97B722E701189DCB4059F943FD77;
struct SqlBinaryU5BU5D_t4A1CD2FDEEC6E9EAEC15A8C28A7701484B8D4485;
struct SqlBooleanU5BU5D_t07B79EADC41ED65294851549545D3F3918FDC6A0;
struct SqlByteU5BU5D_tB403A2418F730327A0789B78506CDACCECBB4CB6;
struct SqlBytesU5BU5D_t6F60DB18D1E498C69C2A2A292075B88252A47C49;
struct SqlCharsU5BU5D_t20FD646DC66170A3025ACFD16C890584136139FC;
struct SqlDateTimeU5BU5D_t12EEE5C7616A30E9F9CE304F76B5912B2A47EABF;
struct SqlDecimalU5BU5D_t436F1578CFBAD13111599A27A32FB894D8307CBD;
struct SqlDoubleU5BU5D_t65F627E3E10E5B61B332C69E3E8180BB1B5C5EA7;
struct SqlGuidU5BU5D_t7B958D75216823CC6FD381B81133477AFD2DE5E2;
struct SqlInt16U5BU5D_tFDBC98064CCDBA5EF1A928770767FF5E428F68B0;
struct SqlInt32U5BU5D_t4E9A0DCCD18A21ED32AE342EE7288F4722D13002;
struct SqlInt64U5BU5D_t07215C71C5947E0BE4CF431CB6124BC53ADA28C5;
struct SqlMoneyU5BU5D_tF5702E9AA3B2D27362711637FFD105D198723C95;
struct SqlSingleU5BU5D_t2F81D199741A89C70F73D8FAC1385A28379B442F;
struct StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A;
struct UInt16U5BU5D_t42D35C587B07DCDBCFDADF572C6D733AE85B2A67;
struct UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF;
struct UInt64U5BU5D_t7C6E32D10F47677C1CEF3C30F4E4CE95B3A633E2;
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.Collections.IIterable`1<System.Single>
struct NOVTABLE IIterable_1_t0EA6FF8BF23034840DB9F5189AF1D72411992F7E : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mBD8D20BBA2E9F188C15175F2C9AB4039C6400ED1(IIterator_1_t53A3C573D4888D0C268E9C0D9515A4BDAD329CCC** comReturnValue) = 0;
};
// Windows.Foundation.IReferenceArray`1<System.Single>
struct NOVTABLE IReferenceArray_1_t1BB7D08F28C5D27D16C0145A86D139290E764ABC : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IReferenceArray_1_get_Value_mDB41698A556618F72FF5F33C60E6D9B78435F619(uint32_t* comReturnValueArraySize, float** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IVectorView`1<System.Object>
struct NOVTABLE IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260(uint32_t ___index0, Il2CppIInspectable** comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B(uint32_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1(uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue) = 0;
};
// Windows.Foundation.Collections.IVectorView`1<System.Single>
struct NOVTABLE IVectorView_1_t0652AC4EC7AA575BE5D7797DFD20689718705BE0 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m3D2911EEE429BEE9DFCCFD08528A6B62938AE14E(uint32_t ___index0, float* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_mE51A5C7833E725EA8286E5878D80E9D44ECDFF41(uint32_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_m4C0458BD59B3F97E792DE7EB4399297542D76C97(float ___value0, uint32_t* ___index1, bool* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m481FCAC8A5B7E6C75882A80893023447977DA78B(uint32_t ___startIndex0, uint32_t ___items1ArraySize, float* ___items1, uint32_t* comReturnValue) = 0;
};
// Windows.Foundation.Collections.IVector`1<System.Single>
struct NOVTABLE IVector_1_t5FBA1DB686EDD35620DC2CCA810C0754A18E8C9D : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IVector_1_GetAt_mB49A020A8CDF0AAF8DCFB381FD74A77688B0FA71(uint32_t ___index0, float* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_get_Size_m494C6D174D411D7FC20D21CE0FA2C0EDD5E91568(uint32_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_GetView_m2720307D308D3DCD49B6AF4C4A08D67498D2B186(IVectorView_1_t0652AC4EC7AA575BE5D7797DFD20689718705BE0** comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_IndexOf_mC1E5DFCDEDC953A4E1CA8BB1C427FBE7EA517FF4(float ___value0, uint32_t* ___index1, bool* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_SetAt_m478207B3FCA7EB1D8264306765201B9B4C8725AD(uint32_t ___index0, float ___value1) = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_InsertAt_m6C9D77B26BDE0B12FE238687DA397FC58C2032A2(uint32_t ___index0, float ___value1) = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_RemoveAt_m3EFDAC8DAF08714CB4FDF41FA54DF4EB2E0F9D97(uint32_t ___index0) = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_Append_mB47ED34CA2102C71646E947495BA9D14451E29C6(float ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_RemoveAtEnd_m04EB0AD3F455408D30F0FFE3100BEB8367635CFC() = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_Clear_mE43500616C5480A63657796BB0AE2E60D7BA49A9() = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_GetMany_m436FF76C0F1FFB49549025672552A1353FEF8745(uint32_t ___startIndex0, uint32_t ___items1ArraySize, float* ___items1, uint32_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IVector_1_ReplaceAll_mF925EE20FE793EF0740B86913574AE2E17FD6B93(uint32_t ___items0ArraySize, float* ___items0) = 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.UI.Xaml.Interop.IBindableVector
struct NOVTABLE IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) = 0;
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) = 0;
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) = 0;
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) = 0;
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) = 0;
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() = 0;
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() = 0;
};
// System.Object
// Microsoft.MixedReality.Toolkit.SpatialAwareness.BaseSpatialAwarenessObject
struct BaseSpatialAwarenessObject_tDEC7FF3F1B319E20ED34F26109C51E5D4BB48883 : public RuntimeObject
{
public:
// System.Int32 Microsoft.MixedReality.Toolkit.SpatialAwareness.BaseSpatialAwarenessObject::<Id>k__BackingField
int32_t ___U3CIdU3Ek__BackingField_0;
// UnityEngine.GameObject Microsoft.MixedReality.Toolkit.SpatialAwareness.BaseSpatialAwarenessObject::<GameObject>k__BackingField
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___U3CGameObjectU3Ek__BackingField_1;
// UnityEngine.MeshRenderer Microsoft.MixedReality.Toolkit.SpatialAwareness.BaseSpatialAwarenessObject::<Renderer>k__BackingField
MeshRenderer_tCD983A2F635E12BCB0BAA2E635D96A318757908B * ___U3CRendererU3Ek__BackingField_2;
// UnityEngine.MeshFilter Microsoft.MixedReality.Toolkit.SpatialAwareness.BaseSpatialAwarenessObject::<Filter>k__BackingField
MeshFilter_t763BB2BBF3881176AD25E4570E6DD215BA0AA51A * ___U3CFilterU3Ek__BackingField_3;
public:
inline static int32_t get_offset_of_U3CIdU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(BaseSpatialAwarenessObject_tDEC7FF3F1B319E20ED34F26109C51E5D4BB48883, ___U3CIdU3Ek__BackingField_0)); }
inline int32_t get_U3CIdU3Ek__BackingField_0() const { return ___U3CIdU3Ek__BackingField_0; }
inline int32_t* get_address_of_U3CIdU3Ek__BackingField_0() { return &___U3CIdU3Ek__BackingField_0; }
inline void set_U3CIdU3Ek__BackingField_0(int32_t value)
{
___U3CIdU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CGameObjectU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(BaseSpatialAwarenessObject_tDEC7FF3F1B319E20ED34F26109C51E5D4BB48883, ___U3CGameObjectU3Ek__BackingField_1)); }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * get_U3CGameObjectU3Ek__BackingField_1() const { return ___U3CGameObjectU3Ek__BackingField_1; }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 ** get_address_of_U3CGameObjectU3Ek__BackingField_1() { return &___U3CGameObjectU3Ek__BackingField_1; }
inline void set_U3CGameObjectU3Ek__BackingField_1(GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * value)
{
___U3CGameObjectU3Ek__BackingField_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CGameObjectU3Ek__BackingField_1), (void*)value);
}
inline static int32_t get_offset_of_U3CRendererU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(BaseSpatialAwarenessObject_tDEC7FF3F1B319E20ED34F26109C51E5D4BB48883, ___U3CRendererU3Ek__BackingField_2)); }
inline MeshRenderer_tCD983A2F635E12BCB0BAA2E635D96A318757908B * get_U3CRendererU3Ek__BackingField_2() const { return ___U3CRendererU3Ek__BackingField_2; }
inline MeshRenderer_tCD983A2F635E12BCB0BAA2E635D96A318757908B ** get_address_of_U3CRendererU3Ek__BackingField_2() { return &___U3CRendererU3Ek__BackingField_2; }
inline void set_U3CRendererU3Ek__BackingField_2(MeshRenderer_tCD983A2F635E12BCB0BAA2E635D96A318757908B * value)
{
___U3CRendererU3Ek__BackingField_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CRendererU3Ek__BackingField_2), (void*)value);
}
inline static int32_t get_offset_of_U3CFilterU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(BaseSpatialAwarenessObject_tDEC7FF3F1B319E20ED34F26109C51E5D4BB48883, ___U3CFilterU3Ek__BackingField_3)); }
inline MeshFilter_t763BB2BBF3881176AD25E4570E6DD215BA0AA51A * get_U3CFilterU3Ek__BackingField_3() const { return ___U3CFilterU3Ek__BackingField_3; }
inline MeshFilter_t763BB2BBF3881176AD25E4570E6DD215BA0AA51A ** get_address_of_U3CFilterU3Ek__BackingField_3() { return &___U3CFilterU3Ek__BackingField_3; }
inline void set_U3CFilterU3Ek__BackingField_3(MeshFilter_t763BB2BBF3881176AD25E4570E6DD215BA0AA51A * value)
{
___U3CFilterU3Ek__BackingField_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CFilterU3Ek__BackingField_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.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);
}
};
// System.Byte
struct Byte_t0111FAB8B8685667EDDAF77683F0D8F86B659056
{
public:
// System.Byte System.Byte::m_value
uint8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Byte_t0111FAB8B8685667EDDAF77683F0D8F86B659056, ___m_value_0)); }
inline uint8_t get_m_value_0() const { return ___m_value_0; }
inline uint8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint8_t value)
{
___m_value_0 = value;
}
};
// System.DateTime
struct DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405
{
public:
// System.UInt64 System.DateTime::dateData
uint64_t ___dateData_44;
public:
inline static int32_t get_offset_of_dateData_44() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405, ___dateData_44)); }
inline uint64_t get_dateData_44() const { return ___dateData_44; }
inline uint64_t* get_address_of_dateData_44() { return &___dateData_44; }
inline void set_dateData_44(uint64_t value)
{
___dateData_44 = value;
}
};
struct DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields
{
public:
// System.Int32[] System.DateTime::DaysToMonth365
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___DaysToMonth365_29;
// System.Int32[] System.DateTime::DaysToMonth366
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___DaysToMonth366_30;
// System.DateTime System.DateTime::MinValue
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___MinValue_31;
// System.DateTime System.DateTime::MaxValue
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___MaxValue_32;
public:
inline static int32_t get_offset_of_DaysToMonth365_29() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___DaysToMonth365_29)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_DaysToMonth365_29() const { return ___DaysToMonth365_29; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_DaysToMonth365_29() { return &___DaysToMonth365_29; }
inline void set_DaysToMonth365_29(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___DaysToMonth365_29 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth365_29), (void*)value);
}
inline static int32_t get_offset_of_DaysToMonth366_30() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___DaysToMonth366_30)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_DaysToMonth366_30() const { return ___DaysToMonth366_30; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_DaysToMonth366_30() { return &___DaysToMonth366_30; }
inline void set_DaysToMonth366_30(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___DaysToMonth366_30 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth366_30), (void*)value);
}
inline static int32_t get_offset_of_MinValue_31() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___MinValue_31)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_MinValue_31() const { return ___MinValue_31; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_MinValue_31() { return &___MinValue_31; }
inline void set_MinValue_31(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___MinValue_31 = value;
}
inline static int32_t get_offset_of_MaxValue_32() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___MaxValue_32)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_MaxValue_32() const { return ___MaxValue_32; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_MaxValue_32() { return &___MaxValue_32; }
inline void set_MaxValue_32(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___MaxValue_32 = 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.Double
struct Double_t42821932CB52DE2057E685D0E1AF3DE5033D2181
{
public:
// System.Double System.Double::m_value
double ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Double_t42821932CB52DE2057E685D0E1AF3DE5033D2181, ___m_value_0)); }
inline double get_m_value_0() const { return ___m_value_0; }
inline double* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(double value)
{
___m_value_0 = value;
}
};
struct Double_t42821932CB52DE2057E685D0E1AF3DE5033D2181_StaticFields
{
public:
// System.Double System.Double::NegativeZero
double ___NegativeZero_7;
public:
inline static int32_t get_offset_of_NegativeZero_7() { return static_cast<int32_t>(offsetof(Double_t42821932CB52DE2057E685D0E1AF3DE5033D2181_StaticFields, ___NegativeZero_7)); }
inline double get_NegativeZero_7() const { return ___NegativeZero_7; }
inline double* get_address_of_NegativeZero_7() { return &___NegativeZero_7; }
inline void set_NegativeZero_7(double value)
{
___NegativeZero_7 = value;
}
};
// 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.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);
}
};
// System.Int16
struct Int16_tD0F031114106263BB459DA1F099FF9F42691295A
{
public:
// System.Int16 System.Int16::m_value
int16_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int16_tD0F031114106263BB459DA1F099FF9F42691295A, ___m_value_0)); }
inline int16_t get_m_value_0() const { return ___m_value_0; }
inline int16_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int16_t value)
{
___m_value_0 = value;
}
};
// 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.Int64
struct Int64_t378EE0D608BD3107E77238E85F30D2BBD46981F3
{
public:
// System.Int64 System.Int64::m_value
int64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int64_t378EE0D608BD3107E77238E85F30D2BBD46981F3, ___m_value_0)); }
inline int64_t get_m_value_0() const { return ___m_value_0; }
inline int64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int64_t value)
{
___m_value_0 = value;
}
};
// 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;
}
};
// UnityEngine.Quaternion
struct Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4
{
public:
// System.Single UnityEngine.Quaternion::x
float ___x_0;
// System.Single UnityEngine.Quaternion::y
float ___y_1;
// System.Single UnityEngine.Quaternion::z
float ___z_2;
// System.Single UnityEngine.Quaternion::w
float ___w_3;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___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_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___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_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___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_t6D28618CF65156D4A0AD747370DDFD0C514A31B4, ___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;
}
};
struct Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4_StaticFields
{
public:
// UnityEngine.Quaternion UnityEngine.Quaternion::identityQuaternion
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___identityQuaternion_4;
public:
inline static int32_t get_offset_of_identityQuaternion_4() { return static_cast<int32_t>(offsetof(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4_StaticFields, ___identityQuaternion_4)); }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 get_identityQuaternion_4() const { return ___identityQuaternion_4; }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * get_address_of_identityQuaternion_4() { return &___identityQuaternion_4; }
inline void set_identityQuaternion_4(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 value)
{
___identityQuaternion_4 = 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;
}
};
// 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;
}
};
// Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject
struct SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A : public BaseSpatialAwarenessObject_tDEC7FF3F1B319E20ED34F26109C51E5D4BB48883
{
public:
// UnityEngine.MeshCollider Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject::<Collider>k__BackingField
MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * ___U3CColliderU3Ek__BackingField_5;
public:
inline static int32_t get_offset_of_U3CColliderU3Ek__BackingField_5() { return static_cast<int32_t>(offsetof(SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A, ___U3CColliderU3Ek__BackingField_5)); }
inline MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * get_U3CColliderU3Ek__BackingField_5() const { return ___U3CColliderU3Ek__BackingField_5; }
inline MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 ** get_address_of_U3CColliderU3Ek__BackingField_5() { return &___U3CColliderU3Ek__BackingField_5; }
inline void set_U3CColliderU3Ek__BackingField_5(MeshCollider_t1983F4E7E53D8C6B65FE21A8B4E2345A84D57E98 * value)
{
___U3CColliderU3Ek__BackingField_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CColliderU3Ek__BackingField_5), (void*)value);
}
};
struct SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A_StaticFields
{
public:
// System.Type[] Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject::RequiredMeshComponents
TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755* ___RequiredMeshComponents_4;
public:
inline static int32_t get_offset_of_RequiredMeshComponents_4() { return static_cast<int32_t>(offsetof(SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A_StaticFields, ___RequiredMeshComponents_4)); }
inline TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755* get_RequiredMeshComponents_4() const { return ___RequiredMeshComponents_4; }
inline TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755** get_address_of_RequiredMeshComponents_4() { return &___RequiredMeshComponents_4; }
inline void set_RequiredMeshComponents_4(TypeU5BU5D_t85B10489E46F06CEC7C4B1CCBD0E01FAB6649755* value)
{
___RequiredMeshComponents_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___RequiredMeshComponents_4), (void*)value);
}
};
// System.Data.SqlTypes.SqlBinary
struct SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B
{
public:
// System.Byte[] System.Data.SqlTypes.SqlBinary::_value
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ____value_0;
public:
inline static int32_t get_offset_of__value_0() { return static_cast<int32_t>(offsetof(SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B, ____value_0)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get__value_0() const { return ____value_0; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of__value_0() { return &____value_0; }
inline void set__value_0(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
____value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____value_0), (void*)value);
}
};
struct SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B_StaticFields
{
public:
// System.Data.SqlTypes.SqlBinary System.Data.SqlTypes.SqlBinary::Null
SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B ___Null_1;
public:
inline static int32_t get_offset_of_Null_1() { return static_cast<int32_t>(offsetof(SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B_StaticFields, ___Null_1)); }
inline SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B get_Null_1() const { return ___Null_1; }
inline SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B * get_address_of_Null_1() { return &___Null_1; }
inline void set_Null_1(SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B value)
{
___Null_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___Null_1))->____value_0), (void*)NULL);
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlBinary
struct SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B_marshaled_pinvoke
{
Il2CppSafeArray/*NONE*/* ____value_0;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlBinary
struct SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B_marshaled_com
{
Il2CppSafeArray/*NONE*/* ____value_0;
};
// System.Data.SqlTypes.SqlBoolean
struct SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3
{
public:
// System.Byte System.Data.SqlTypes.SqlBoolean::m_value
uint8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3, ___m_value_0)); }
inline uint8_t get_m_value_0() const { return ___m_value_0; }
inline uint8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint8_t value)
{
___m_value_0 = value;
}
};
struct SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3_StaticFields
{
public:
// System.Data.SqlTypes.SqlBoolean System.Data.SqlTypes.SqlBoolean::True
SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 ___True_1;
// System.Data.SqlTypes.SqlBoolean System.Data.SqlTypes.SqlBoolean::False
SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 ___False_2;
// System.Data.SqlTypes.SqlBoolean System.Data.SqlTypes.SqlBoolean::Null
SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 ___Null_3;
// System.Data.SqlTypes.SqlBoolean System.Data.SqlTypes.SqlBoolean::Zero
SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 ___Zero_4;
// System.Data.SqlTypes.SqlBoolean System.Data.SqlTypes.SqlBoolean::One
SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 ___One_5;
public:
inline static int32_t get_offset_of_True_1() { return static_cast<int32_t>(offsetof(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3_StaticFields, ___True_1)); }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 get_True_1() const { return ___True_1; }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 * get_address_of_True_1() { return &___True_1; }
inline void set_True_1(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 value)
{
___True_1 = value;
}
inline static int32_t get_offset_of_False_2() { return static_cast<int32_t>(offsetof(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3_StaticFields, ___False_2)); }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 get_False_2() const { return ___False_2; }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 * get_address_of_False_2() { return &___False_2; }
inline void set_False_2(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 value)
{
___False_2 = value;
}
inline static int32_t get_offset_of_Null_3() { return static_cast<int32_t>(offsetof(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3_StaticFields, ___Null_3)); }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 get_Null_3() const { return ___Null_3; }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 * get_address_of_Null_3() { return &___Null_3; }
inline void set_Null_3(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 value)
{
___Null_3 = value;
}
inline static int32_t get_offset_of_Zero_4() { return static_cast<int32_t>(offsetof(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3_StaticFields, ___Zero_4)); }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 get_Zero_4() const { return ___Zero_4; }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 * get_address_of_Zero_4() { return &___Zero_4; }
inline void set_Zero_4(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 value)
{
___Zero_4 = value;
}
inline static int32_t get_offset_of_One_5() { return static_cast<int32_t>(offsetof(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3_StaticFields, ___One_5)); }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 get_One_5() const { return ___One_5; }
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 * get_address_of_One_5() { return &___One_5; }
inline void set_One_5(SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 value)
{
___One_5 = value;
}
};
// System.Data.SqlTypes.SqlByte
struct SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41
{
public:
// System.Boolean System.Data.SqlTypes.SqlByte::m_fNotNull
bool ___m_fNotNull_0;
// System.Byte System.Data.SqlTypes.SqlByte::m_value
uint8_t ___m_value_1;
public:
inline static int32_t get_offset_of_m_fNotNull_0() { return static_cast<int32_t>(offsetof(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41, ___m_fNotNull_0)); }
inline bool get_m_fNotNull_0() const { return ___m_fNotNull_0; }
inline bool* get_address_of_m_fNotNull_0() { return &___m_fNotNull_0; }
inline void set_m_fNotNull_0(bool value)
{
___m_fNotNull_0 = value;
}
inline static int32_t get_offset_of_m_value_1() { return static_cast<int32_t>(offsetof(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41, ___m_value_1)); }
inline uint8_t get_m_value_1() const { return ___m_value_1; }
inline uint8_t* get_address_of_m_value_1() { return &___m_value_1; }
inline void set_m_value_1(uint8_t value)
{
___m_value_1 = value;
}
};
struct SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41_StaticFields
{
public:
// System.Int32 System.Data.SqlTypes.SqlByte::s_iBitNotByteMax
int32_t ___s_iBitNotByteMax_2;
// System.Data.SqlTypes.SqlByte System.Data.SqlTypes.SqlByte::Null
SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 ___Null_3;
// System.Data.SqlTypes.SqlByte System.Data.SqlTypes.SqlByte::Zero
SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 ___Zero_4;
// System.Data.SqlTypes.SqlByte System.Data.SqlTypes.SqlByte::MinValue
SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 ___MinValue_5;
// System.Data.SqlTypes.SqlByte System.Data.SqlTypes.SqlByte::MaxValue
SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 ___MaxValue_6;
public:
inline static int32_t get_offset_of_s_iBitNotByteMax_2() { return static_cast<int32_t>(offsetof(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41_StaticFields, ___s_iBitNotByteMax_2)); }
inline int32_t get_s_iBitNotByteMax_2() const { return ___s_iBitNotByteMax_2; }
inline int32_t* get_address_of_s_iBitNotByteMax_2() { return &___s_iBitNotByteMax_2; }
inline void set_s_iBitNotByteMax_2(int32_t value)
{
___s_iBitNotByteMax_2 = value;
}
inline static int32_t get_offset_of_Null_3() { return static_cast<int32_t>(offsetof(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41_StaticFields, ___Null_3)); }
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 get_Null_3() const { return ___Null_3; }
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 * get_address_of_Null_3() { return &___Null_3; }
inline void set_Null_3(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 value)
{
___Null_3 = value;
}
inline static int32_t get_offset_of_Zero_4() { return static_cast<int32_t>(offsetof(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41_StaticFields, ___Zero_4)); }
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 get_Zero_4() const { return ___Zero_4; }
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 * get_address_of_Zero_4() { return &___Zero_4; }
inline void set_Zero_4(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 value)
{
___Zero_4 = value;
}
inline static int32_t get_offset_of_MinValue_5() { return static_cast<int32_t>(offsetof(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41_StaticFields, ___MinValue_5)); }
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 get_MinValue_5() const { return ___MinValue_5; }
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 * get_address_of_MinValue_5() { return &___MinValue_5; }
inline void set_MinValue_5(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 value)
{
___MinValue_5 = value;
}
inline static int32_t get_offset_of_MaxValue_6() { return static_cast<int32_t>(offsetof(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41_StaticFields, ___MaxValue_6)); }
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 get_MaxValue_6() const { return ___MaxValue_6; }
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 * get_address_of_MaxValue_6() { return &___MaxValue_6; }
inline void set_MaxValue_6(SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 value)
{
___MaxValue_6 = value;
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlByte
struct SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41_marshaled_pinvoke
{
int32_t ___m_fNotNull_0;
uint8_t ___m_value_1;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlByte
struct SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41_marshaled_com
{
int32_t ___m_fNotNull_0;
uint8_t ___m_value_1;
};
// System.Data.SqlTypes.SqlDecimal
struct SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B
{
public:
// System.Byte System.Data.SqlTypes.SqlDecimal::_bStatus
uint8_t ____bStatus_0;
// System.Byte System.Data.SqlTypes.SqlDecimal::_bLen
uint8_t ____bLen_1;
// System.Byte System.Data.SqlTypes.SqlDecimal::_bPrec
uint8_t ____bPrec_2;
// System.Byte System.Data.SqlTypes.SqlDecimal::_bScale
uint8_t ____bScale_3;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::_data1
uint32_t ____data1_4;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::_data2
uint32_t ____data2_5;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::_data3
uint32_t ____data3_6;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::_data4
uint32_t ____data4_7;
public:
inline static int32_t get_offset_of__bStatus_0() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B, ____bStatus_0)); }
inline uint8_t get__bStatus_0() const { return ____bStatus_0; }
inline uint8_t* get_address_of__bStatus_0() { return &____bStatus_0; }
inline void set__bStatus_0(uint8_t value)
{
____bStatus_0 = value;
}
inline static int32_t get_offset_of__bLen_1() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B, ____bLen_1)); }
inline uint8_t get__bLen_1() const { return ____bLen_1; }
inline uint8_t* get_address_of__bLen_1() { return &____bLen_1; }
inline void set__bLen_1(uint8_t value)
{
____bLen_1 = value;
}
inline static int32_t get_offset_of__bPrec_2() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B, ____bPrec_2)); }
inline uint8_t get__bPrec_2() const { return ____bPrec_2; }
inline uint8_t* get_address_of__bPrec_2() { return &____bPrec_2; }
inline void set__bPrec_2(uint8_t value)
{
____bPrec_2 = value;
}
inline static int32_t get_offset_of__bScale_3() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B, ____bScale_3)); }
inline uint8_t get__bScale_3() const { return ____bScale_3; }
inline uint8_t* get_address_of__bScale_3() { return &____bScale_3; }
inline void set__bScale_3(uint8_t value)
{
____bScale_3 = value;
}
inline static int32_t get_offset_of__data1_4() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B, ____data1_4)); }
inline uint32_t get__data1_4() const { return ____data1_4; }
inline uint32_t* get_address_of__data1_4() { return &____data1_4; }
inline void set__data1_4(uint32_t value)
{
____data1_4 = value;
}
inline static int32_t get_offset_of__data2_5() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B, ____data2_5)); }
inline uint32_t get__data2_5() const { return ____data2_5; }
inline uint32_t* get_address_of__data2_5() { return &____data2_5; }
inline void set__data2_5(uint32_t value)
{
____data2_5 = value;
}
inline static int32_t get_offset_of__data3_6() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B, ____data3_6)); }
inline uint32_t get__data3_6() const { return ____data3_6; }
inline uint32_t* get_address_of__data3_6() { return &____data3_6; }
inline void set__data3_6(uint32_t value)
{
____data3_6 = value;
}
inline static int32_t get_offset_of__data4_7() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B, ____data4_7)); }
inline uint32_t get__data4_7() const { return ____data4_7; }
inline uint32_t* get_address_of__data4_7() { return &____data4_7; }
inline void set__data4_7(uint32_t value)
{
____data4_7 = value;
}
};
struct SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields
{
public:
// System.Byte System.Data.SqlTypes.SqlDecimal::s_NUMERIC_MAX_PRECISION
uint8_t ___s_NUMERIC_MAX_PRECISION_8;
// System.Byte System.Data.SqlTypes.SqlDecimal::MaxPrecision
uint8_t ___MaxPrecision_9;
// System.Byte System.Data.SqlTypes.SqlDecimal::MaxScale
uint8_t ___MaxScale_10;
// System.Byte System.Data.SqlTypes.SqlDecimal::s_bNullMask
uint8_t ___s_bNullMask_11;
// System.Byte System.Data.SqlTypes.SqlDecimal::s_bIsNull
uint8_t ___s_bIsNull_12;
// System.Byte System.Data.SqlTypes.SqlDecimal::s_bNotNull
uint8_t ___s_bNotNull_13;
// System.Byte System.Data.SqlTypes.SqlDecimal::s_bReverseNullMask
uint8_t ___s_bReverseNullMask_14;
// System.Byte System.Data.SqlTypes.SqlDecimal::s_bSignMask
uint8_t ___s_bSignMask_15;
// System.Byte System.Data.SqlTypes.SqlDecimal::s_bPositive
uint8_t ___s_bPositive_16;
// System.Byte System.Data.SqlTypes.SqlDecimal::s_bNegative
uint8_t ___s_bNegative_17;
// System.Byte System.Data.SqlTypes.SqlDecimal::s_bReverseSignMask
uint8_t ___s_bReverseSignMask_18;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_uiZero
uint32_t ___s_uiZero_19;
// System.Int32 System.Data.SqlTypes.SqlDecimal::s_cNumeMax
int32_t ___s_cNumeMax_20;
// System.Int64 System.Data.SqlTypes.SqlDecimal::s_lInt32Base
int64_t ___s_lInt32Base_21;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_ulInt32Base
uint64_t ___s_ulInt32Base_22;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_ulInt32BaseForMod
uint64_t ___s_ulInt32BaseForMod_23;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_llMax
uint64_t ___s_llMax_24;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulBase10
uint32_t ___s_ulBase10_25;
// System.Double System.Data.SqlTypes.SqlDecimal::s_DUINT_BASE
double ___s_DUINT_BASE_26;
// System.Double System.Data.SqlTypes.SqlDecimal::s_DUINT_BASE2
double ___s_DUINT_BASE2_27;
// System.Double System.Data.SqlTypes.SqlDecimal::s_DUINT_BASE3
double ___s_DUINT_BASE3_28;
// System.Double System.Data.SqlTypes.SqlDecimal::s_DMAX_NUME
double ___s_DMAX_NUME_29;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_DBL_DIG
uint32_t ___s_DBL_DIG_30;
// System.Byte System.Data.SqlTypes.SqlDecimal::s_cNumeDivScaleMin
uint8_t ___s_cNumeDivScaleMin_31;
// System.UInt32[] System.Data.SqlTypes.SqlDecimal::s_rgulShiftBase
UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* ___s_rgulShiftBase_32;
// System.UInt32[] System.Data.SqlTypes.SqlDecimal::s_decimalHelpersLo
UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* ___s_decimalHelpersLo_33;
// System.UInt32[] System.Data.SqlTypes.SqlDecimal::s_decimalHelpersMid
UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* ___s_decimalHelpersMid_34;
// System.UInt32[] System.Data.SqlTypes.SqlDecimal::s_decimalHelpersHi
UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* ___s_decimalHelpersHi_35;
// System.UInt32[] System.Data.SqlTypes.SqlDecimal::s_decimalHelpersHiHi
UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* ___s_decimalHelpersHiHi_36;
// System.Byte[] System.Data.SqlTypes.SqlDecimal::s_rgCLenFromPrec
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___s_rgCLenFromPrec_37;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulT1
uint32_t ___s_ulT1_38;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulT2
uint32_t ___s_ulT2_39;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulT3
uint32_t ___s_ulT3_40;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulT4
uint32_t ___s_ulT4_41;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulT5
uint32_t ___s_ulT5_42;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulT6
uint32_t ___s_ulT6_43;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulT7
uint32_t ___s_ulT7_44;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulT8
uint32_t ___s_ulT8_45;
// System.UInt32 System.Data.SqlTypes.SqlDecimal::s_ulT9
uint32_t ___s_ulT9_46;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT10
uint64_t ___s_dwlT10_47;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT11
uint64_t ___s_dwlT11_48;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT12
uint64_t ___s_dwlT12_49;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT13
uint64_t ___s_dwlT13_50;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT14
uint64_t ___s_dwlT14_51;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT15
uint64_t ___s_dwlT15_52;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT16
uint64_t ___s_dwlT16_53;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT17
uint64_t ___s_dwlT17_54;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT18
uint64_t ___s_dwlT18_55;
// System.UInt64 System.Data.SqlTypes.SqlDecimal::s_dwlT19
uint64_t ___s_dwlT19_56;
// System.Data.SqlTypes.SqlDecimal System.Data.SqlTypes.SqlDecimal::Null
SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B ___Null_57;
// System.Data.SqlTypes.SqlDecimal System.Data.SqlTypes.SqlDecimal::MinValue
SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B ___MinValue_58;
// System.Data.SqlTypes.SqlDecimal System.Data.SqlTypes.SqlDecimal::MaxValue
SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B ___MaxValue_59;
public:
inline static int32_t get_offset_of_s_NUMERIC_MAX_PRECISION_8() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_NUMERIC_MAX_PRECISION_8)); }
inline uint8_t get_s_NUMERIC_MAX_PRECISION_8() const { return ___s_NUMERIC_MAX_PRECISION_8; }
inline uint8_t* get_address_of_s_NUMERIC_MAX_PRECISION_8() { return &___s_NUMERIC_MAX_PRECISION_8; }
inline void set_s_NUMERIC_MAX_PRECISION_8(uint8_t value)
{
___s_NUMERIC_MAX_PRECISION_8 = value;
}
inline static int32_t get_offset_of_MaxPrecision_9() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___MaxPrecision_9)); }
inline uint8_t get_MaxPrecision_9() const { return ___MaxPrecision_9; }
inline uint8_t* get_address_of_MaxPrecision_9() { return &___MaxPrecision_9; }
inline void set_MaxPrecision_9(uint8_t value)
{
___MaxPrecision_9 = value;
}
inline static int32_t get_offset_of_MaxScale_10() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___MaxScale_10)); }
inline uint8_t get_MaxScale_10() const { return ___MaxScale_10; }
inline uint8_t* get_address_of_MaxScale_10() { return &___MaxScale_10; }
inline void set_MaxScale_10(uint8_t value)
{
___MaxScale_10 = value;
}
inline static int32_t get_offset_of_s_bNullMask_11() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_bNullMask_11)); }
inline uint8_t get_s_bNullMask_11() const { return ___s_bNullMask_11; }
inline uint8_t* get_address_of_s_bNullMask_11() { return &___s_bNullMask_11; }
inline void set_s_bNullMask_11(uint8_t value)
{
___s_bNullMask_11 = value;
}
inline static int32_t get_offset_of_s_bIsNull_12() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_bIsNull_12)); }
inline uint8_t get_s_bIsNull_12() const { return ___s_bIsNull_12; }
inline uint8_t* get_address_of_s_bIsNull_12() { return &___s_bIsNull_12; }
inline void set_s_bIsNull_12(uint8_t value)
{
___s_bIsNull_12 = value;
}
inline static int32_t get_offset_of_s_bNotNull_13() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_bNotNull_13)); }
inline uint8_t get_s_bNotNull_13() const { return ___s_bNotNull_13; }
inline uint8_t* get_address_of_s_bNotNull_13() { return &___s_bNotNull_13; }
inline void set_s_bNotNull_13(uint8_t value)
{
___s_bNotNull_13 = value;
}
inline static int32_t get_offset_of_s_bReverseNullMask_14() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_bReverseNullMask_14)); }
inline uint8_t get_s_bReverseNullMask_14() const { return ___s_bReverseNullMask_14; }
inline uint8_t* get_address_of_s_bReverseNullMask_14() { return &___s_bReverseNullMask_14; }
inline void set_s_bReverseNullMask_14(uint8_t value)
{
___s_bReverseNullMask_14 = value;
}
inline static int32_t get_offset_of_s_bSignMask_15() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_bSignMask_15)); }
inline uint8_t get_s_bSignMask_15() const { return ___s_bSignMask_15; }
inline uint8_t* get_address_of_s_bSignMask_15() { return &___s_bSignMask_15; }
inline void set_s_bSignMask_15(uint8_t value)
{
___s_bSignMask_15 = value;
}
inline static int32_t get_offset_of_s_bPositive_16() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_bPositive_16)); }
inline uint8_t get_s_bPositive_16() const { return ___s_bPositive_16; }
inline uint8_t* get_address_of_s_bPositive_16() { return &___s_bPositive_16; }
inline void set_s_bPositive_16(uint8_t value)
{
___s_bPositive_16 = value;
}
inline static int32_t get_offset_of_s_bNegative_17() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_bNegative_17)); }
inline uint8_t get_s_bNegative_17() const { return ___s_bNegative_17; }
inline uint8_t* get_address_of_s_bNegative_17() { return &___s_bNegative_17; }
inline void set_s_bNegative_17(uint8_t value)
{
___s_bNegative_17 = value;
}
inline static int32_t get_offset_of_s_bReverseSignMask_18() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_bReverseSignMask_18)); }
inline uint8_t get_s_bReverseSignMask_18() const { return ___s_bReverseSignMask_18; }
inline uint8_t* get_address_of_s_bReverseSignMask_18() { return &___s_bReverseSignMask_18; }
inline void set_s_bReverseSignMask_18(uint8_t value)
{
___s_bReverseSignMask_18 = value;
}
inline static int32_t get_offset_of_s_uiZero_19() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_uiZero_19)); }
inline uint32_t get_s_uiZero_19() const { return ___s_uiZero_19; }
inline uint32_t* get_address_of_s_uiZero_19() { return &___s_uiZero_19; }
inline void set_s_uiZero_19(uint32_t value)
{
___s_uiZero_19 = value;
}
inline static int32_t get_offset_of_s_cNumeMax_20() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_cNumeMax_20)); }
inline int32_t get_s_cNumeMax_20() const { return ___s_cNumeMax_20; }
inline int32_t* get_address_of_s_cNumeMax_20() { return &___s_cNumeMax_20; }
inline void set_s_cNumeMax_20(int32_t value)
{
___s_cNumeMax_20 = value;
}
inline static int32_t get_offset_of_s_lInt32Base_21() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_lInt32Base_21)); }
inline int64_t get_s_lInt32Base_21() const { return ___s_lInt32Base_21; }
inline int64_t* get_address_of_s_lInt32Base_21() { return &___s_lInt32Base_21; }
inline void set_s_lInt32Base_21(int64_t value)
{
___s_lInt32Base_21 = value;
}
inline static int32_t get_offset_of_s_ulInt32Base_22() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulInt32Base_22)); }
inline uint64_t get_s_ulInt32Base_22() const { return ___s_ulInt32Base_22; }
inline uint64_t* get_address_of_s_ulInt32Base_22() { return &___s_ulInt32Base_22; }
inline void set_s_ulInt32Base_22(uint64_t value)
{
___s_ulInt32Base_22 = value;
}
inline static int32_t get_offset_of_s_ulInt32BaseForMod_23() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulInt32BaseForMod_23)); }
inline uint64_t get_s_ulInt32BaseForMod_23() const { return ___s_ulInt32BaseForMod_23; }
inline uint64_t* get_address_of_s_ulInt32BaseForMod_23() { return &___s_ulInt32BaseForMod_23; }
inline void set_s_ulInt32BaseForMod_23(uint64_t value)
{
___s_ulInt32BaseForMod_23 = value;
}
inline static int32_t get_offset_of_s_llMax_24() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_llMax_24)); }
inline uint64_t get_s_llMax_24() const { return ___s_llMax_24; }
inline uint64_t* get_address_of_s_llMax_24() { return &___s_llMax_24; }
inline void set_s_llMax_24(uint64_t value)
{
___s_llMax_24 = value;
}
inline static int32_t get_offset_of_s_ulBase10_25() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulBase10_25)); }
inline uint32_t get_s_ulBase10_25() const { return ___s_ulBase10_25; }
inline uint32_t* get_address_of_s_ulBase10_25() { return &___s_ulBase10_25; }
inline void set_s_ulBase10_25(uint32_t value)
{
___s_ulBase10_25 = value;
}
inline static int32_t get_offset_of_s_DUINT_BASE_26() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_DUINT_BASE_26)); }
inline double get_s_DUINT_BASE_26() const { return ___s_DUINT_BASE_26; }
inline double* get_address_of_s_DUINT_BASE_26() { return &___s_DUINT_BASE_26; }
inline void set_s_DUINT_BASE_26(double value)
{
___s_DUINT_BASE_26 = value;
}
inline static int32_t get_offset_of_s_DUINT_BASE2_27() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_DUINT_BASE2_27)); }
inline double get_s_DUINT_BASE2_27() const { return ___s_DUINT_BASE2_27; }
inline double* get_address_of_s_DUINT_BASE2_27() { return &___s_DUINT_BASE2_27; }
inline void set_s_DUINT_BASE2_27(double value)
{
___s_DUINT_BASE2_27 = value;
}
inline static int32_t get_offset_of_s_DUINT_BASE3_28() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_DUINT_BASE3_28)); }
inline double get_s_DUINT_BASE3_28() const { return ___s_DUINT_BASE3_28; }
inline double* get_address_of_s_DUINT_BASE3_28() { return &___s_DUINT_BASE3_28; }
inline void set_s_DUINT_BASE3_28(double value)
{
___s_DUINT_BASE3_28 = value;
}
inline static int32_t get_offset_of_s_DMAX_NUME_29() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_DMAX_NUME_29)); }
inline double get_s_DMAX_NUME_29() const { return ___s_DMAX_NUME_29; }
inline double* get_address_of_s_DMAX_NUME_29() { return &___s_DMAX_NUME_29; }
inline void set_s_DMAX_NUME_29(double value)
{
___s_DMAX_NUME_29 = value;
}
inline static int32_t get_offset_of_s_DBL_DIG_30() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_DBL_DIG_30)); }
inline uint32_t get_s_DBL_DIG_30() const { return ___s_DBL_DIG_30; }
inline uint32_t* get_address_of_s_DBL_DIG_30() { return &___s_DBL_DIG_30; }
inline void set_s_DBL_DIG_30(uint32_t value)
{
___s_DBL_DIG_30 = value;
}
inline static int32_t get_offset_of_s_cNumeDivScaleMin_31() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_cNumeDivScaleMin_31)); }
inline uint8_t get_s_cNumeDivScaleMin_31() const { return ___s_cNumeDivScaleMin_31; }
inline uint8_t* get_address_of_s_cNumeDivScaleMin_31() { return &___s_cNumeDivScaleMin_31; }
inline void set_s_cNumeDivScaleMin_31(uint8_t value)
{
___s_cNumeDivScaleMin_31 = value;
}
inline static int32_t get_offset_of_s_rgulShiftBase_32() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_rgulShiftBase_32)); }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* get_s_rgulShiftBase_32() const { return ___s_rgulShiftBase_32; }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF** get_address_of_s_rgulShiftBase_32() { return &___s_rgulShiftBase_32; }
inline void set_s_rgulShiftBase_32(UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* value)
{
___s_rgulShiftBase_32 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_rgulShiftBase_32), (void*)value);
}
inline static int32_t get_offset_of_s_decimalHelpersLo_33() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_decimalHelpersLo_33)); }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* get_s_decimalHelpersLo_33() const { return ___s_decimalHelpersLo_33; }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF** get_address_of_s_decimalHelpersLo_33() { return &___s_decimalHelpersLo_33; }
inline void set_s_decimalHelpersLo_33(UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* value)
{
___s_decimalHelpersLo_33 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_decimalHelpersLo_33), (void*)value);
}
inline static int32_t get_offset_of_s_decimalHelpersMid_34() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_decimalHelpersMid_34)); }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* get_s_decimalHelpersMid_34() const { return ___s_decimalHelpersMid_34; }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF** get_address_of_s_decimalHelpersMid_34() { return &___s_decimalHelpersMid_34; }
inline void set_s_decimalHelpersMid_34(UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* value)
{
___s_decimalHelpersMid_34 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_decimalHelpersMid_34), (void*)value);
}
inline static int32_t get_offset_of_s_decimalHelpersHi_35() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_decimalHelpersHi_35)); }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* get_s_decimalHelpersHi_35() const { return ___s_decimalHelpersHi_35; }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF** get_address_of_s_decimalHelpersHi_35() { return &___s_decimalHelpersHi_35; }
inline void set_s_decimalHelpersHi_35(UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* value)
{
___s_decimalHelpersHi_35 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_decimalHelpersHi_35), (void*)value);
}
inline static int32_t get_offset_of_s_decimalHelpersHiHi_36() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_decimalHelpersHiHi_36)); }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* get_s_decimalHelpersHiHi_36() const { return ___s_decimalHelpersHiHi_36; }
inline UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF** get_address_of_s_decimalHelpersHiHi_36() { return &___s_decimalHelpersHiHi_36; }
inline void set_s_decimalHelpersHiHi_36(UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* value)
{
___s_decimalHelpersHiHi_36 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_decimalHelpersHiHi_36), (void*)value);
}
inline static int32_t get_offset_of_s_rgCLenFromPrec_37() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_rgCLenFromPrec_37)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_s_rgCLenFromPrec_37() const { return ___s_rgCLenFromPrec_37; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_s_rgCLenFromPrec_37() { return &___s_rgCLenFromPrec_37; }
inline void set_s_rgCLenFromPrec_37(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___s_rgCLenFromPrec_37 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_rgCLenFromPrec_37), (void*)value);
}
inline static int32_t get_offset_of_s_ulT1_38() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulT1_38)); }
inline uint32_t get_s_ulT1_38() const { return ___s_ulT1_38; }
inline uint32_t* get_address_of_s_ulT1_38() { return &___s_ulT1_38; }
inline void set_s_ulT1_38(uint32_t value)
{
___s_ulT1_38 = value;
}
inline static int32_t get_offset_of_s_ulT2_39() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulT2_39)); }
inline uint32_t get_s_ulT2_39() const { return ___s_ulT2_39; }
inline uint32_t* get_address_of_s_ulT2_39() { return &___s_ulT2_39; }
inline void set_s_ulT2_39(uint32_t value)
{
___s_ulT2_39 = value;
}
inline static int32_t get_offset_of_s_ulT3_40() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulT3_40)); }
inline uint32_t get_s_ulT3_40() const { return ___s_ulT3_40; }
inline uint32_t* get_address_of_s_ulT3_40() { return &___s_ulT3_40; }
inline void set_s_ulT3_40(uint32_t value)
{
___s_ulT3_40 = value;
}
inline static int32_t get_offset_of_s_ulT4_41() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulT4_41)); }
inline uint32_t get_s_ulT4_41() const { return ___s_ulT4_41; }
inline uint32_t* get_address_of_s_ulT4_41() { return &___s_ulT4_41; }
inline void set_s_ulT4_41(uint32_t value)
{
___s_ulT4_41 = value;
}
inline static int32_t get_offset_of_s_ulT5_42() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulT5_42)); }
inline uint32_t get_s_ulT5_42() const { return ___s_ulT5_42; }
inline uint32_t* get_address_of_s_ulT5_42() { return &___s_ulT5_42; }
inline void set_s_ulT5_42(uint32_t value)
{
___s_ulT5_42 = value;
}
inline static int32_t get_offset_of_s_ulT6_43() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulT6_43)); }
inline uint32_t get_s_ulT6_43() const { return ___s_ulT6_43; }
inline uint32_t* get_address_of_s_ulT6_43() { return &___s_ulT6_43; }
inline void set_s_ulT6_43(uint32_t value)
{
___s_ulT6_43 = value;
}
inline static int32_t get_offset_of_s_ulT7_44() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulT7_44)); }
inline uint32_t get_s_ulT7_44() const { return ___s_ulT7_44; }
inline uint32_t* get_address_of_s_ulT7_44() { return &___s_ulT7_44; }
inline void set_s_ulT7_44(uint32_t value)
{
___s_ulT7_44 = value;
}
inline static int32_t get_offset_of_s_ulT8_45() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulT8_45)); }
inline uint32_t get_s_ulT8_45() const { return ___s_ulT8_45; }
inline uint32_t* get_address_of_s_ulT8_45() { return &___s_ulT8_45; }
inline void set_s_ulT8_45(uint32_t value)
{
___s_ulT8_45 = value;
}
inline static int32_t get_offset_of_s_ulT9_46() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_ulT9_46)); }
inline uint32_t get_s_ulT9_46() const { return ___s_ulT9_46; }
inline uint32_t* get_address_of_s_ulT9_46() { return &___s_ulT9_46; }
inline void set_s_ulT9_46(uint32_t value)
{
___s_ulT9_46 = value;
}
inline static int32_t get_offset_of_s_dwlT10_47() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT10_47)); }
inline uint64_t get_s_dwlT10_47() const { return ___s_dwlT10_47; }
inline uint64_t* get_address_of_s_dwlT10_47() { return &___s_dwlT10_47; }
inline void set_s_dwlT10_47(uint64_t value)
{
___s_dwlT10_47 = value;
}
inline static int32_t get_offset_of_s_dwlT11_48() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT11_48)); }
inline uint64_t get_s_dwlT11_48() const { return ___s_dwlT11_48; }
inline uint64_t* get_address_of_s_dwlT11_48() { return &___s_dwlT11_48; }
inline void set_s_dwlT11_48(uint64_t value)
{
___s_dwlT11_48 = value;
}
inline static int32_t get_offset_of_s_dwlT12_49() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT12_49)); }
inline uint64_t get_s_dwlT12_49() const { return ___s_dwlT12_49; }
inline uint64_t* get_address_of_s_dwlT12_49() { return &___s_dwlT12_49; }
inline void set_s_dwlT12_49(uint64_t value)
{
___s_dwlT12_49 = value;
}
inline static int32_t get_offset_of_s_dwlT13_50() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT13_50)); }
inline uint64_t get_s_dwlT13_50() const { return ___s_dwlT13_50; }
inline uint64_t* get_address_of_s_dwlT13_50() { return &___s_dwlT13_50; }
inline void set_s_dwlT13_50(uint64_t value)
{
___s_dwlT13_50 = value;
}
inline static int32_t get_offset_of_s_dwlT14_51() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT14_51)); }
inline uint64_t get_s_dwlT14_51() const { return ___s_dwlT14_51; }
inline uint64_t* get_address_of_s_dwlT14_51() { return &___s_dwlT14_51; }
inline void set_s_dwlT14_51(uint64_t value)
{
___s_dwlT14_51 = value;
}
inline static int32_t get_offset_of_s_dwlT15_52() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT15_52)); }
inline uint64_t get_s_dwlT15_52() const { return ___s_dwlT15_52; }
inline uint64_t* get_address_of_s_dwlT15_52() { return &___s_dwlT15_52; }
inline void set_s_dwlT15_52(uint64_t value)
{
___s_dwlT15_52 = value;
}
inline static int32_t get_offset_of_s_dwlT16_53() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT16_53)); }
inline uint64_t get_s_dwlT16_53() const { return ___s_dwlT16_53; }
inline uint64_t* get_address_of_s_dwlT16_53() { return &___s_dwlT16_53; }
inline void set_s_dwlT16_53(uint64_t value)
{
___s_dwlT16_53 = value;
}
inline static int32_t get_offset_of_s_dwlT17_54() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT17_54)); }
inline uint64_t get_s_dwlT17_54() const { return ___s_dwlT17_54; }
inline uint64_t* get_address_of_s_dwlT17_54() { return &___s_dwlT17_54; }
inline void set_s_dwlT17_54(uint64_t value)
{
___s_dwlT17_54 = value;
}
inline static int32_t get_offset_of_s_dwlT18_55() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT18_55)); }
inline uint64_t get_s_dwlT18_55() const { return ___s_dwlT18_55; }
inline uint64_t* get_address_of_s_dwlT18_55() { return &___s_dwlT18_55; }
inline void set_s_dwlT18_55(uint64_t value)
{
___s_dwlT18_55 = value;
}
inline static int32_t get_offset_of_s_dwlT19_56() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___s_dwlT19_56)); }
inline uint64_t get_s_dwlT19_56() const { return ___s_dwlT19_56; }
inline uint64_t* get_address_of_s_dwlT19_56() { return &___s_dwlT19_56; }
inline void set_s_dwlT19_56(uint64_t value)
{
___s_dwlT19_56 = value;
}
inline static int32_t get_offset_of_Null_57() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___Null_57)); }
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B get_Null_57() const { return ___Null_57; }
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B * get_address_of_Null_57() { return &___Null_57; }
inline void set_Null_57(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B value)
{
___Null_57 = value;
}
inline static int32_t get_offset_of_MinValue_58() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___MinValue_58)); }
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B get_MinValue_58() const { return ___MinValue_58; }
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B * get_address_of_MinValue_58() { return &___MinValue_58; }
inline void set_MinValue_58(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B value)
{
___MinValue_58 = value;
}
inline static int32_t get_offset_of_MaxValue_59() { return static_cast<int32_t>(offsetof(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B_StaticFields, ___MaxValue_59)); }
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B get_MaxValue_59() const { return ___MaxValue_59; }
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B * get_address_of_MaxValue_59() { return &___MaxValue_59; }
inline void set_MaxValue_59(SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B value)
{
___MaxValue_59 = value;
}
};
// System.Data.SqlTypes.SqlDouble
struct SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA
{
public:
// System.Boolean System.Data.SqlTypes.SqlDouble::m_fNotNull
bool ___m_fNotNull_0;
// System.Double System.Data.SqlTypes.SqlDouble::m_value
double ___m_value_1;
public:
inline static int32_t get_offset_of_m_fNotNull_0() { return static_cast<int32_t>(offsetof(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA, ___m_fNotNull_0)); }
inline bool get_m_fNotNull_0() const { return ___m_fNotNull_0; }
inline bool* get_address_of_m_fNotNull_0() { return &___m_fNotNull_0; }
inline void set_m_fNotNull_0(bool value)
{
___m_fNotNull_0 = value;
}
inline static int32_t get_offset_of_m_value_1() { return static_cast<int32_t>(offsetof(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA, ___m_value_1)); }
inline double get_m_value_1() const { return ___m_value_1; }
inline double* get_address_of_m_value_1() { return &___m_value_1; }
inline void set_m_value_1(double value)
{
___m_value_1 = value;
}
};
struct SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA_StaticFields
{
public:
// System.Data.SqlTypes.SqlDouble System.Data.SqlTypes.SqlDouble::Null
SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA ___Null_2;
// System.Data.SqlTypes.SqlDouble System.Data.SqlTypes.SqlDouble::Zero
SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA ___Zero_3;
// System.Data.SqlTypes.SqlDouble System.Data.SqlTypes.SqlDouble::MinValue
SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA ___MinValue_4;
// System.Data.SqlTypes.SqlDouble System.Data.SqlTypes.SqlDouble::MaxValue
SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA ___MaxValue_5;
public:
inline static int32_t get_offset_of_Null_2() { return static_cast<int32_t>(offsetof(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA_StaticFields, ___Null_2)); }
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA get_Null_2() const { return ___Null_2; }
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA * get_address_of_Null_2() { return &___Null_2; }
inline void set_Null_2(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA value)
{
___Null_2 = value;
}
inline static int32_t get_offset_of_Zero_3() { return static_cast<int32_t>(offsetof(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA_StaticFields, ___Zero_3)); }
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA get_Zero_3() const { return ___Zero_3; }
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA * get_address_of_Zero_3() { return &___Zero_3; }
inline void set_Zero_3(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA value)
{
___Zero_3 = value;
}
inline static int32_t get_offset_of_MinValue_4() { return static_cast<int32_t>(offsetof(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA_StaticFields, ___MinValue_4)); }
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA get_MinValue_4() const { return ___MinValue_4; }
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA * get_address_of_MinValue_4() { return &___MinValue_4; }
inline void set_MinValue_4(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA value)
{
___MinValue_4 = value;
}
inline static int32_t get_offset_of_MaxValue_5() { return static_cast<int32_t>(offsetof(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA_StaticFields, ___MaxValue_5)); }
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA get_MaxValue_5() const { return ___MaxValue_5; }
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA * get_address_of_MaxValue_5() { return &___MaxValue_5; }
inline void set_MaxValue_5(SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA value)
{
___MaxValue_5 = value;
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlDouble
struct SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA_marshaled_pinvoke
{
int32_t ___m_fNotNull_0;
double ___m_value_1;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlDouble
struct SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA_marshaled_com
{
int32_t ___m_fNotNull_0;
double ___m_value_1;
};
// System.Data.SqlTypes.SqlGuid
struct SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46
{
public:
// System.Byte[] System.Data.SqlTypes.SqlGuid::m_value
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___m_value_2;
public:
inline static int32_t get_offset_of_m_value_2() { return static_cast<int32_t>(offsetof(SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46, ___m_value_2)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_m_value_2() const { return ___m_value_2; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_m_value_2() { return &___m_value_2; }
inline void set_m_value_2(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___m_value_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_value_2), (void*)value);
}
};
struct SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46_StaticFields
{
public:
// System.Int32 System.Data.SqlTypes.SqlGuid::s_sizeOfGuid
int32_t ___s_sizeOfGuid_0;
// System.Int32[] System.Data.SqlTypes.SqlGuid::s_rgiGuidOrder
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___s_rgiGuidOrder_1;
// System.Data.SqlTypes.SqlGuid System.Data.SqlTypes.SqlGuid::Null
SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 ___Null_3;
public:
inline static int32_t get_offset_of_s_sizeOfGuid_0() { return static_cast<int32_t>(offsetof(SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46_StaticFields, ___s_sizeOfGuid_0)); }
inline int32_t get_s_sizeOfGuid_0() const { return ___s_sizeOfGuid_0; }
inline int32_t* get_address_of_s_sizeOfGuid_0() { return &___s_sizeOfGuid_0; }
inline void set_s_sizeOfGuid_0(int32_t value)
{
___s_sizeOfGuid_0 = value;
}
inline static int32_t get_offset_of_s_rgiGuidOrder_1() { return static_cast<int32_t>(offsetof(SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46_StaticFields, ___s_rgiGuidOrder_1)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_s_rgiGuidOrder_1() const { return ___s_rgiGuidOrder_1; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_s_rgiGuidOrder_1() { return &___s_rgiGuidOrder_1; }
inline void set_s_rgiGuidOrder_1(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___s_rgiGuidOrder_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_rgiGuidOrder_1), (void*)value);
}
inline static int32_t get_offset_of_Null_3() { return static_cast<int32_t>(offsetof(SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46_StaticFields, ___Null_3)); }
inline SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 get_Null_3() const { return ___Null_3; }
inline SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 * get_address_of_Null_3() { return &___Null_3; }
inline void set_Null_3(SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 value)
{
___Null_3 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___Null_3))->___m_value_2), (void*)NULL);
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlGuid
struct SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46_marshaled_pinvoke
{
Il2CppSafeArray/*NONE*/* ___m_value_2;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlGuid
struct SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46_marshaled_com
{
Il2CppSafeArray/*NONE*/* ___m_value_2;
};
// System.Data.SqlTypes.SqlInt16
struct SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F
{
public:
// System.Boolean System.Data.SqlTypes.SqlInt16::m_fNotNull
bool ___m_fNotNull_0;
// System.Int16 System.Data.SqlTypes.SqlInt16::m_value
int16_t ___m_value_1;
public:
inline static int32_t get_offset_of_m_fNotNull_0() { return static_cast<int32_t>(offsetof(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F, ___m_fNotNull_0)); }
inline bool get_m_fNotNull_0() const { return ___m_fNotNull_0; }
inline bool* get_address_of_m_fNotNull_0() { return &___m_fNotNull_0; }
inline void set_m_fNotNull_0(bool value)
{
___m_fNotNull_0 = value;
}
inline static int32_t get_offset_of_m_value_1() { return static_cast<int32_t>(offsetof(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F, ___m_value_1)); }
inline int16_t get_m_value_1() const { return ___m_value_1; }
inline int16_t* get_address_of_m_value_1() { return &___m_value_1; }
inline void set_m_value_1(int16_t value)
{
___m_value_1 = value;
}
};
struct SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F_StaticFields
{
public:
// System.Int32 System.Data.SqlTypes.SqlInt16::s_MASKI2
int32_t ___s_MASKI2_2;
// System.Data.SqlTypes.SqlInt16 System.Data.SqlTypes.SqlInt16::Null
SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F ___Null_3;
// System.Data.SqlTypes.SqlInt16 System.Data.SqlTypes.SqlInt16::Zero
SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F ___Zero_4;
// System.Data.SqlTypes.SqlInt16 System.Data.SqlTypes.SqlInt16::MinValue
SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F ___MinValue_5;
// System.Data.SqlTypes.SqlInt16 System.Data.SqlTypes.SqlInt16::MaxValue
SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F ___MaxValue_6;
public:
inline static int32_t get_offset_of_s_MASKI2_2() { return static_cast<int32_t>(offsetof(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F_StaticFields, ___s_MASKI2_2)); }
inline int32_t get_s_MASKI2_2() const { return ___s_MASKI2_2; }
inline int32_t* get_address_of_s_MASKI2_2() { return &___s_MASKI2_2; }
inline void set_s_MASKI2_2(int32_t value)
{
___s_MASKI2_2 = value;
}
inline static int32_t get_offset_of_Null_3() { return static_cast<int32_t>(offsetof(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F_StaticFields, ___Null_3)); }
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F get_Null_3() const { return ___Null_3; }
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F * get_address_of_Null_3() { return &___Null_3; }
inline void set_Null_3(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F value)
{
___Null_3 = value;
}
inline static int32_t get_offset_of_Zero_4() { return static_cast<int32_t>(offsetof(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F_StaticFields, ___Zero_4)); }
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F get_Zero_4() const { return ___Zero_4; }
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F * get_address_of_Zero_4() { return &___Zero_4; }
inline void set_Zero_4(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F value)
{
___Zero_4 = value;
}
inline static int32_t get_offset_of_MinValue_5() { return static_cast<int32_t>(offsetof(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F_StaticFields, ___MinValue_5)); }
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F get_MinValue_5() const { return ___MinValue_5; }
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F * get_address_of_MinValue_5() { return &___MinValue_5; }
inline void set_MinValue_5(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F value)
{
___MinValue_5 = value;
}
inline static int32_t get_offset_of_MaxValue_6() { return static_cast<int32_t>(offsetof(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F_StaticFields, ___MaxValue_6)); }
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F get_MaxValue_6() const { return ___MaxValue_6; }
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F * get_address_of_MaxValue_6() { return &___MaxValue_6; }
inline void set_MaxValue_6(SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F value)
{
___MaxValue_6 = value;
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlInt16
struct SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F_marshaled_pinvoke
{
int32_t ___m_fNotNull_0;
int16_t ___m_value_1;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlInt16
struct SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F_marshaled_com
{
int32_t ___m_fNotNull_0;
int16_t ___m_value_1;
};
// System.Data.SqlTypes.SqlInt32
struct SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5
{
public:
// System.Boolean System.Data.SqlTypes.SqlInt32::m_fNotNull
bool ___m_fNotNull_0;
// System.Int32 System.Data.SqlTypes.SqlInt32::m_value
int32_t ___m_value_1;
public:
inline static int32_t get_offset_of_m_fNotNull_0() { return static_cast<int32_t>(offsetof(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5, ___m_fNotNull_0)); }
inline bool get_m_fNotNull_0() const { return ___m_fNotNull_0; }
inline bool* get_address_of_m_fNotNull_0() { return &___m_fNotNull_0; }
inline void set_m_fNotNull_0(bool value)
{
___m_fNotNull_0 = value;
}
inline static int32_t get_offset_of_m_value_1() { return static_cast<int32_t>(offsetof(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5, ___m_value_1)); }
inline int32_t get_m_value_1() const { return ___m_value_1; }
inline int32_t* get_address_of_m_value_1() { return &___m_value_1; }
inline void set_m_value_1(int32_t value)
{
___m_value_1 = value;
}
};
struct SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5_StaticFields
{
public:
// System.Int64 System.Data.SqlTypes.SqlInt32::s_iIntMin
int64_t ___s_iIntMin_2;
// System.Int64 System.Data.SqlTypes.SqlInt32::s_lBitNotIntMax
int64_t ___s_lBitNotIntMax_3;
// System.Data.SqlTypes.SqlInt32 System.Data.SqlTypes.SqlInt32::Null
SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 ___Null_4;
// System.Data.SqlTypes.SqlInt32 System.Data.SqlTypes.SqlInt32::Zero
SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 ___Zero_5;
// System.Data.SqlTypes.SqlInt32 System.Data.SqlTypes.SqlInt32::MinValue
SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 ___MinValue_6;
// System.Data.SqlTypes.SqlInt32 System.Data.SqlTypes.SqlInt32::MaxValue
SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 ___MaxValue_7;
public:
inline static int32_t get_offset_of_s_iIntMin_2() { return static_cast<int32_t>(offsetof(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5_StaticFields, ___s_iIntMin_2)); }
inline int64_t get_s_iIntMin_2() const { return ___s_iIntMin_2; }
inline int64_t* get_address_of_s_iIntMin_2() { return &___s_iIntMin_2; }
inline void set_s_iIntMin_2(int64_t value)
{
___s_iIntMin_2 = value;
}
inline static int32_t get_offset_of_s_lBitNotIntMax_3() { return static_cast<int32_t>(offsetof(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5_StaticFields, ___s_lBitNotIntMax_3)); }
inline int64_t get_s_lBitNotIntMax_3() const { return ___s_lBitNotIntMax_3; }
inline int64_t* get_address_of_s_lBitNotIntMax_3() { return &___s_lBitNotIntMax_3; }
inline void set_s_lBitNotIntMax_3(int64_t value)
{
___s_lBitNotIntMax_3 = value;
}
inline static int32_t get_offset_of_Null_4() { return static_cast<int32_t>(offsetof(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5_StaticFields, ___Null_4)); }
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 get_Null_4() const { return ___Null_4; }
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 * get_address_of_Null_4() { return &___Null_4; }
inline void set_Null_4(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 value)
{
___Null_4 = value;
}
inline static int32_t get_offset_of_Zero_5() { return static_cast<int32_t>(offsetof(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5_StaticFields, ___Zero_5)); }
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 get_Zero_5() const { return ___Zero_5; }
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 * get_address_of_Zero_5() { return &___Zero_5; }
inline void set_Zero_5(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 value)
{
___Zero_5 = value;
}
inline static int32_t get_offset_of_MinValue_6() { return static_cast<int32_t>(offsetof(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5_StaticFields, ___MinValue_6)); }
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 get_MinValue_6() const { return ___MinValue_6; }
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 * get_address_of_MinValue_6() { return &___MinValue_6; }
inline void set_MinValue_6(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 value)
{
___MinValue_6 = value;
}
inline static int32_t get_offset_of_MaxValue_7() { return static_cast<int32_t>(offsetof(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5_StaticFields, ___MaxValue_7)); }
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 get_MaxValue_7() const { return ___MaxValue_7; }
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 * get_address_of_MaxValue_7() { return &___MaxValue_7; }
inline void set_MaxValue_7(SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 value)
{
___MaxValue_7 = value;
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlInt32
struct SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5_marshaled_pinvoke
{
int32_t ___m_fNotNull_0;
int32_t ___m_value_1;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlInt32
struct SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5_marshaled_com
{
int32_t ___m_fNotNull_0;
int32_t ___m_value_1;
};
// System.Data.SqlTypes.SqlInt64
struct SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE
{
public:
// System.Boolean System.Data.SqlTypes.SqlInt64::m_fNotNull
bool ___m_fNotNull_0;
// System.Int64 System.Data.SqlTypes.SqlInt64::m_value
int64_t ___m_value_1;
public:
inline static int32_t get_offset_of_m_fNotNull_0() { return static_cast<int32_t>(offsetof(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE, ___m_fNotNull_0)); }
inline bool get_m_fNotNull_0() const { return ___m_fNotNull_0; }
inline bool* get_address_of_m_fNotNull_0() { return &___m_fNotNull_0; }
inline void set_m_fNotNull_0(bool value)
{
___m_fNotNull_0 = value;
}
inline static int32_t get_offset_of_m_value_1() { return static_cast<int32_t>(offsetof(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE, ___m_value_1)); }
inline int64_t get_m_value_1() const { return ___m_value_1; }
inline int64_t* get_address_of_m_value_1() { return &___m_value_1; }
inline void set_m_value_1(int64_t value)
{
___m_value_1 = value;
}
};
struct SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE_StaticFields
{
public:
// System.Int64 System.Data.SqlTypes.SqlInt64::s_lLowIntMask
int64_t ___s_lLowIntMask_2;
// System.Int64 System.Data.SqlTypes.SqlInt64::s_lHighIntMask
int64_t ___s_lHighIntMask_3;
// System.Data.SqlTypes.SqlInt64 System.Data.SqlTypes.SqlInt64::Null
SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE ___Null_4;
// System.Data.SqlTypes.SqlInt64 System.Data.SqlTypes.SqlInt64::Zero
SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE ___Zero_5;
// System.Data.SqlTypes.SqlInt64 System.Data.SqlTypes.SqlInt64::MinValue
SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE ___MinValue_6;
// System.Data.SqlTypes.SqlInt64 System.Data.SqlTypes.SqlInt64::MaxValue
SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE ___MaxValue_7;
public:
inline static int32_t get_offset_of_s_lLowIntMask_2() { return static_cast<int32_t>(offsetof(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE_StaticFields, ___s_lLowIntMask_2)); }
inline int64_t get_s_lLowIntMask_2() const { return ___s_lLowIntMask_2; }
inline int64_t* get_address_of_s_lLowIntMask_2() { return &___s_lLowIntMask_2; }
inline void set_s_lLowIntMask_2(int64_t value)
{
___s_lLowIntMask_2 = value;
}
inline static int32_t get_offset_of_s_lHighIntMask_3() { return static_cast<int32_t>(offsetof(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE_StaticFields, ___s_lHighIntMask_3)); }
inline int64_t get_s_lHighIntMask_3() const { return ___s_lHighIntMask_3; }
inline int64_t* get_address_of_s_lHighIntMask_3() { return &___s_lHighIntMask_3; }
inline void set_s_lHighIntMask_3(int64_t value)
{
___s_lHighIntMask_3 = value;
}
inline static int32_t get_offset_of_Null_4() { return static_cast<int32_t>(offsetof(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE_StaticFields, ___Null_4)); }
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE get_Null_4() const { return ___Null_4; }
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE * get_address_of_Null_4() { return &___Null_4; }
inline void set_Null_4(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE value)
{
___Null_4 = value;
}
inline static int32_t get_offset_of_Zero_5() { return static_cast<int32_t>(offsetof(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE_StaticFields, ___Zero_5)); }
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE get_Zero_5() const { return ___Zero_5; }
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE * get_address_of_Zero_5() { return &___Zero_5; }
inline void set_Zero_5(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE value)
{
___Zero_5 = value;
}
inline static int32_t get_offset_of_MinValue_6() { return static_cast<int32_t>(offsetof(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE_StaticFields, ___MinValue_6)); }
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE get_MinValue_6() const { return ___MinValue_6; }
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE * get_address_of_MinValue_6() { return &___MinValue_6; }
inline void set_MinValue_6(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE value)
{
___MinValue_6 = value;
}
inline static int32_t get_offset_of_MaxValue_7() { return static_cast<int32_t>(offsetof(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE_StaticFields, ___MaxValue_7)); }
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE get_MaxValue_7() const { return ___MaxValue_7; }
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE * get_address_of_MaxValue_7() { return &___MaxValue_7; }
inline void set_MaxValue_7(SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE value)
{
___MaxValue_7 = value;
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlInt64
struct SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE_marshaled_pinvoke
{
int32_t ___m_fNotNull_0;
int64_t ___m_value_1;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlInt64
struct SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE_marshaled_com
{
int32_t ___m_fNotNull_0;
int64_t ___m_value_1;
};
// System.Data.SqlTypes.SqlMoney
struct SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA
{
public:
// System.Boolean System.Data.SqlTypes.SqlMoney::_fNotNull
bool ____fNotNull_0;
// System.Int64 System.Data.SqlTypes.SqlMoney::_value
int64_t ____value_1;
public:
inline static int32_t get_offset_of__fNotNull_0() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA, ____fNotNull_0)); }
inline bool get__fNotNull_0() const { return ____fNotNull_0; }
inline bool* get_address_of__fNotNull_0() { return &____fNotNull_0; }
inline void set__fNotNull_0(bool value)
{
____fNotNull_0 = value;
}
inline static int32_t get_offset_of__value_1() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA, ____value_1)); }
inline int64_t get__value_1() const { return ____value_1; }
inline int64_t* get_address_of__value_1() { return &____value_1; }
inline void set__value_1(int64_t value)
{
____value_1 = value;
}
};
struct SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields
{
public:
// System.Int32 System.Data.SqlTypes.SqlMoney::s_iMoneyScale
int32_t ___s_iMoneyScale_2;
// System.Int64 System.Data.SqlTypes.SqlMoney::s_lTickBase
int64_t ___s_lTickBase_3;
// System.Double System.Data.SqlTypes.SqlMoney::s_dTickBase
double ___s_dTickBase_4;
// System.Int64 System.Data.SqlTypes.SqlMoney::s_minLong
int64_t ___s_minLong_5;
// System.Int64 System.Data.SqlTypes.SqlMoney::s_maxLong
int64_t ___s_maxLong_6;
// System.Data.SqlTypes.SqlMoney System.Data.SqlTypes.SqlMoney::Null
SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA ___Null_7;
// System.Data.SqlTypes.SqlMoney System.Data.SqlTypes.SqlMoney::Zero
SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA ___Zero_8;
// System.Data.SqlTypes.SqlMoney System.Data.SqlTypes.SqlMoney::MinValue
SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA ___MinValue_9;
// System.Data.SqlTypes.SqlMoney System.Data.SqlTypes.SqlMoney::MaxValue
SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA ___MaxValue_10;
public:
inline static int32_t get_offset_of_s_iMoneyScale_2() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields, ___s_iMoneyScale_2)); }
inline int32_t get_s_iMoneyScale_2() const { return ___s_iMoneyScale_2; }
inline int32_t* get_address_of_s_iMoneyScale_2() { return &___s_iMoneyScale_2; }
inline void set_s_iMoneyScale_2(int32_t value)
{
___s_iMoneyScale_2 = value;
}
inline static int32_t get_offset_of_s_lTickBase_3() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields, ___s_lTickBase_3)); }
inline int64_t get_s_lTickBase_3() const { return ___s_lTickBase_3; }
inline int64_t* get_address_of_s_lTickBase_3() { return &___s_lTickBase_3; }
inline void set_s_lTickBase_3(int64_t value)
{
___s_lTickBase_3 = value;
}
inline static int32_t get_offset_of_s_dTickBase_4() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields, ___s_dTickBase_4)); }
inline double get_s_dTickBase_4() const { return ___s_dTickBase_4; }
inline double* get_address_of_s_dTickBase_4() { return &___s_dTickBase_4; }
inline void set_s_dTickBase_4(double value)
{
___s_dTickBase_4 = value;
}
inline static int32_t get_offset_of_s_minLong_5() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields, ___s_minLong_5)); }
inline int64_t get_s_minLong_5() const { return ___s_minLong_5; }
inline int64_t* get_address_of_s_minLong_5() { return &___s_minLong_5; }
inline void set_s_minLong_5(int64_t value)
{
___s_minLong_5 = value;
}
inline static int32_t get_offset_of_s_maxLong_6() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields, ___s_maxLong_6)); }
inline int64_t get_s_maxLong_6() const { return ___s_maxLong_6; }
inline int64_t* get_address_of_s_maxLong_6() { return &___s_maxLong_6; }
inline void set_s_maxLong_6(int64_t value)
{
___s_maxLong_6 = value;
}
inline static int32_t get_offset_of_Null_7() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields, ___Null_7)); }
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA get_Null_7() const { return ___Null_7; }
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA * get_address_of_Null_7() { return &___Null_7; }
inline void set_Null_7(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA value)
{
___Null_7 = value;
}
inline static int32_t get_offset_of_Zero_8() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields, ___Zero_8)); }
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA get_Zero_8() const { return ___Zero_8; }
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA * get_address_of_Zero_8() { return &___Zero_8; }
inline void set_Zero_8(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA value)
{
___Zero_8 = value;
}
inline static int32_t get_offset_of_MinValue_9() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields, ___MinValue_9)); }
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA get_MinValue_9() const { return ___MinValue_9; }
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA * get_address_of_MinValue_9() { return &___MinValue_9; }
inline void set_MinValue_9(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA value)
{
___MinValue_9 = value;
}
inline static int32_t get_offset_of_MaxValue_10() { return static_cast<int32_t>(offsetof(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_StaticFields, ___MaxValue_10)); }
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA get_MaxValue_10() const { return ___MaxValue_10; }
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA * get_address_of_MaxValue_10() { return &___MaxValue_10; }
inline void set_MaxValue_10(SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA value)
{
___MaxValue_10 = value;
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlMoney
struct SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_marshaled_pinvoke
{
int32_t ____fNotNull_0;
int64_t ____value_1;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlMoney
struct SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA_marshaled_com
{
int32_t ____fNotNull_0;
int64_t ____value_1;
};
// System.Data.SqlTypes.SqlSingle
struct SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E
{
public:
// System.Boolean System.Data.SqlTypes.SqlSingle::_fNotNull
bool ____fNotNull_0;
// System.Single System.Data.SqlTypes.SqlSingle::_value
float ____value_1;
public:
inline static int32_t get_offset_of__fNotNull_0() { return static_cast<int32_t>(offsetof(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E, ____fNotNull_0)); }
inline bool get__fNotNull_0() const { return ____fNotNull_0; }
inline bool* get_address_of__fNotNull_0() { return &____fNotNull_0; }
inline void set__fNotNull_0(bool value)
{
____fNotNull_0 = value;
}
inline static int32_t get_offset_of__value_1() { return static_cast<int32_t>(offsetof(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E, ____value_1)); }
inline float get__value_1() const { return ____value_1; }
inline float* get_address_of__value_1() { return &____value_1; }
inline void set__value_1(float value)
{
____value_1 = value;
}
};
struct SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E_StaticFields
{
public:
// System.Data.SqlTypes.SqlSingle System.Data.SqlTypes.SqlSingle::Null
SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E ___Null_2;
// System.Data.SqlTypes.SqlSingle System.Data.SqlTypes.SqlSingle::Zero
SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E ___Zero_3;
// System.Data.SqlTypes.SqlSingle System.Data.SqlTypes.SqlSingle::MinValue
SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E ___MinValue_4;
// System.Data.SqlTypes.SqlSingle System.Data.SqlTypes.SqlSingle::MaxValue
SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E ___MaxValue_5;
public:
inline static int32_t get_offset_of_Null_2() { return static_cast<int32_t>(offsetof(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E_StaticFields, ___Null_2)); }
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E get_Null_2() const { return ___Null_2; }
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E * get_address_of_Null_2() { return &___Null_2; }
inline void set_Null_2(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E value)
{
___Null_2 = value;
}
inline static int32_t get_offset_of_Zero_3() { return static_cast<int32_t>(offsetof(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E_StaticFields, ___Zero_3)); }
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E get_Zero_3() const { return ___Zero_3; }
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E * get_address_of_Zero_3() { return &___Zero_3; }
inline void set_Zero_3(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E value)
{
___Zero_3 = value;
}
inline static int32_t get_offset_of_MinValue_4() { return static_cast<int32_t>(offsetof(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E_StaticFields, ___MinValue_4)); }
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E get_MinValue_4() const { return ___MinValue_4; }
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E * get_address_of_MinValue_4() { return &___MinValue_4; }
inline void set_MinValue_4(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E value)
{
___MinValue_4 = value;
}
inline static int32_t get_offset_of_MaxValue_5() { return static_cast<int32_t>(offsetof(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E_StaticFields, ___MaxValue_5)); }
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E get_MaxValue_5() const { return ___MaxValue_5; }
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E * get_address_of_MaxValue_5() { return &___MaxValue_5; }
inline void set_MaxValue_5(SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E value)
{
___MaxValue_5 = value;
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlSingle
struct SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E_marshaled_pinvoke
{
int32_t ____fNotNull_0;
float ____value_1;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlSingle
struct SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E_marshaled_com
{
int32_t ____fNotNull_0;
float ____value_1;
};
// System.UInt16
struct UInt16_t894EA9D4FB7C799B244E7BBF2DF0EEEDBC77A8BD
{
public:
// System.UInt16 System.UInt16::m_value
uint16_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt16_t894EA9D4FB7C799B244E7BBF2DF0EEEDBC77A8BD, ___m_value_0)); }
inline uint16_t get_m_value_0() const { return ___m_value_0; }
inline uint16_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint16_t value)
{
___m_value_0 = value;
}
};
// System.UInt32
struct UInt32_tE60352A06233E4E69DD198BCC67142159F686B15
{
public:
// System.UInt32 System.UInt32::m_value
uint32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt32_tE60352A06233E4E69DD198BCC67142159F686B15, ___m_value_0)); }
inline uint32_t get_m_value_0() const { return ___m_value_0; }
inline uint32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint32_t value)
{
___m_value_0 = value;
}
};
// System.UInt64
struct UInt64_tEC57511B3E3CA2DBA1BEBD434C6983E31C943281
{
public:
// System.UInt64 System.UInt64::m_value
uint64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt64_tEC57511B3E3CA2DBA1BEBD434C6983E31C943281, ___m_value_0)); }
inline uint64_t get_m_value_0() const { return ___m_value_0; }
inline uint64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint64_t value)
{
___m_value_0 = value;
}
};
// 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;
}
};
// 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;
};
// 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;
}
};
// Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessSurfaceTypes
struct SpatialAwarenessSurfaceTypes_t2C9E25F3650C54A7EA5B939EB508C79F9E0858A7
{
public:
// System.Int32 Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessSurfaceTypes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SpatialAwarenessSurfaceTypes_t2C9E25F3650C54A7EA5B939EB508C79F9E0858A7, ___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.Data.SqlTypes.SqlBytesCharsState
struct SqlBytesCharsState_tDE947198DFA4F1F888E5CEFB59A92F6D4DF59685
{
public:
// System.Int32 System.Data.SqlTypes.SqlBytesCharsState::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SqlBytesCharsState_tDE947198DFA4F1F888E5CEFB59A92F6D4DF59685, ___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.TimeSpan
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203
{
public:
// System.Int64 System.TimeSpan::_ticks
int64_t ____ticks_22;
public:
inline static int32_t get_offset_of__ticks_22() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203, ____ticks_22)); }
inline int64_t get__ticks_22() const { return ____ticks_22; }
inline int64_t* get_address_of__ticks_22() { return &____ticks_22; }
inline void set__ticks_22(int64_t value)
{
____ticks_22 = value;
}
};
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields
{
public:
// System.TimeSpan System.TimeSpan::Zero
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___Zero_19;
// System.TimeSpan System.TimeSpan::MaxValue
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___MaxValue_20;
// System.TimeSpan System.TimeSpan::MinValue
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___MinValue_21;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyConfigChecked
bool ____legacyConfigChecked_23;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyMode
bool ____legacyMode_24;
public:
inline static int32_t get_offset_of_Zero_19() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___Zero_19)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_Zero_19() const { return ___Zero_19; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_Zero_19() { return &___Zero_19; }
inline void set_Zero_19(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___Zero_19 = value;
}
inline static int32_t get_offset_of_MaxValue_20() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___MaxValue_20)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_MaxValue_20() const { return ___MaxValue_20; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_MaxValue_20() { return &___MaxValue_20; }
inline void set_MaxValue_20(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___MaxValue_20 = value;
}
inline static int32_t get_offset_of_MinValue_21() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___MinValue_21)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_MinValue_21() const { return ___MinValue_21; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_MinValue_21() { return &___MinValue_21; }
inline void set_MinValue_21(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___MinValue_21 = value;
}
inline static int32_t get_offset_of__legacyConfigChecked_23() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ____legacyConfigChecked_23)); }
inline bool get__legacyConfigChecked_23() const { return ____legacyConfigChecked_23; }
inline bool* get_address_of__legacyConfigChecked_23() { return &____legacyConfigChecked_23; }
inline void set__legacyConfigChecked_23(bool value)
{
____legacyConfigChecked_23 = value;
}
inline static int32_t get_offset_of__legacyMode_24() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ____legacyMode_24)); }
inline bool get__legacyMode_24() const { return ____legacyMode_24; }
inline bool* get_address_of__legacyMode_24() { return &____legacyMode_24; }
inline void set__legacyMode_24(bool value)
{
____legacyMode_24 = 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;
};
// Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessPlanarObject
struct SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE : public BaseSpatialAwarenessObject_tDEC7FF3F1B319E20ED34F26109C51E5D4BB48883
{
public:
// UnityEngine.BoxCollider Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessPlanarObject::<Collider>k__BackingField
BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * ___U3CColliderU3Ek__BackingField_4;
// Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessSurfaceTypes Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessPlanarObject::planeType
int32_t ___planeType_5;
public:
inline static int32_t get_offset_of_U3CColliderU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE, ___U3CColliderU3Ek__BackingField_4)); }
inline BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * get_U3CColliderU3Ek__BackingField_4() const { return ___U3CColliderU3Ek__BackingField_4; }
inline BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 ** get_address_of_U3CColliderU3Ek__BackingField_4() { return &___U3CColliderU3Ek__BackingField_4; }
inline void set_U3CColliderU3Ek__BackingField_4(BoxCollider_tA530691AC1A3C9FE6428F68F98588FCB1BF9AAA5 * value)
{
___U3CColliderU3Ek__BackingField_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CColliderU3Ek__BackingField_4), (void*)value);
}
inline static int32_t get_offset_of_planeType_5() { return static_cast<int32_t>(offsetof(SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE, ___planeType_5)); }
inline int32_t get_planeType_5() const { return ___planeType_5; }
inline int32_t* get_address_of_planeType_5() { return &___planeType_5; }
inline void set_planeType_5(int32_t value)
{
___planeType_5 = value;
}
};
// Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject
struct SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612 : public BaseSpatialAwarenessObject_tDEC7FF3F1B319E20ED34F26109C51E5D4BB48883
{
public:
// UnityEngine.Vector3 Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject::<Position>k__BackingField
Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E ___U3CPositionU3Ek__BackingField_4;
// UnityEngine.Quaternion Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject::<Rotation>k__BackingField
Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 ___U3CRotationU3Ek__BackingField_5;
// System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject/QuadData> Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject::<Quads>k__BackingField
List_1_tFE68FBF4E8F070DD0335517B9447CD21B6A3535C * ___U3CQuadsU3Ek__BackingField_6;
// System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject/MeshData> Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject::<Meshes>k__BackingField
List_1_tFB0CB232CE88C5B88CE821554A7D3FA62CCB01FF * ___U3CMeshesU3Ek__BackingField_7;
// Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessSurfaceTypes Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject::<SurfaceType>k__BackingField
int32_t ___U3CSurfaceTypeU3Ek__BackingField_8;
public:
inline static int32_t get_offset_of_U3CPositionU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612, ___U3CPositionU3Ek__BackingField_4)); }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E get_U3CPositionU3Ek__BackingField_4() const { return ___U3CPositionU3Ek__BackingField_4; }
inline Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E * get_address_of_U3CPositionU3Ek__BackingField_4() { return &___U3CPositionU3Ek__BackingField_4; }
inline void set_U3CPositionU3Ek__BackingField_4(Vector3_t65B972D6A585A0A5B63153CF1177A90D3C90D65E value)
{
___U3CPositionU3Ek__BackingField_4 = value;
}
inline static int32_t get_offset_of_U3CRotationU3Ek__BackingField_5() { return static_cast<int32_t>(offsetof(SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612, ___U3CRotationU3Ek__BackingField_5)); }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 get_U3CRotationU3Ek__BackingField_5() const { return ___U3CRotationU3Ek__BackingField_5; }
inline Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 * get_address_of_U3CRotationU3Ek__BackingField_5() { return &___U3CRotationU3Ek__BackingField_5; }
inline void set_U3CRotationU3Ek__BackingField_5(Quaternion_t6D28618CF65156D4A0AD747370DDFD0C514A31B4 value)
{
___U3CRotationU3Ek__BackingField_5 = value;
}
inline static int32_t get_offset_of_U3CQuadsU3Ek__BackingField_6() { return static_cast<int32_t>(offsetof(SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612, ___U3CQuadsU3Ek__BackingField_6)); }
inline List_1_tFE68FBF4E8F070DD0335517B9447CD21B6A3535C * get_U3CQuadsU3Ek__BackingField_6() const { return ___U3CQuadsU3Ek__BackingField_6; }
inline List_1_tFE68FBF4E8F070DD0335517B9447CD21B6A3535C ** get_address_of_U3CQuadsU3Ek__BackingField_6() { return &___U3CQuadsU3Ek__BackingField_6; }
inline void set_U3CQuadsU3Ek__BackingField_6(List_1_tFE68FBF4E8F070DD0335517B9447CD21B6A3535C * value)
{
___U3CQuadsU3Ek__BackingField_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CQuadsU3Ek__BackingField_6), (void*)value);
}
inline static int32_t get_offset_of_U3CMeshesU3Ek__BackingField_7() { return static_cast<int32_t>(offsetof(SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612, ___U3CMeshesU3Ek__BackingField_7)); }
inline List_1_tFB0CB232CE88C5B88CE821554A7D3FA62CCB01FF * get_U3CMeshesU3Ek__BackingField_7() const { return ___U3CMeshesU3Ek__BackingField_7; }
inline List_1_tFB0CB232CE88C5B88CE821554A7D3FA62CCB01FF ** get_address_of_U3CMeshesU3Ek__BackingField_7() { return &___U3CMeshesU3Ek__BackingField_7; }
inline void set_U3CMeshesU3Ek__BackingField_7(List_1_tFB0CB232CE88C5B88CE821554A7D3FA62CCB01FF * value)
{
___U3CMeshesU3Ek__BackingField_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CMeshesU3Ek__BackingField_7), (void*)value);
}
inline static int32_t get_offset_of_U3CSurfaceTypeU3Ek__BackingField_8() { return static_cast<int32_t>(offsetof(SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612, ___U3CSurfaceTypeU3Ek__BackingField_8)); }
inline int32_t get_U3CSurfaceTypeU3Ek__BackingField_8() const { return ___U3CSurfaceTypeU3Ek__BackingField_8; }
inline int32_t* get_address_of_U3CSurfaceTypeU3Ek__BackingField_8() { return &___U3CSurfaceTypeU3Ek__BackingField_8; }
inline void set_U3CSurfaceTypeU3Ek__BackingField_8(int32_t value)
{
___U3CSurfaceTypeU3Ek__BackingField_8 = value;
}
};
// UnityEngine.Sprite
struct Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A
{
public:
public:
};
// System.Data.SqlTypes.SqlBytes
struct SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6 : public RuntimeObject
{
public:
// System.Byte[] System.Data.SqlTypes.SqlBytes::_rgbBuf
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ____rgbBuf_0;
// System.Int64 System.Data.SqlTypes.SqlBytes::_lCurLen
int64_t ____lCurLen_1;
// System.IO.Stream System.Data.SqlTypes.SqlBytes::_stream
Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB * ____stream_2;
// System.Data.SqlTypes.SqlBytesCharsState System.Data.SqlTypes.SqlBytes::_state
int32_t ____state_3;
// System.Byte[] System.Data.SqlTypes.SqlBytes::_rgbWorkBuf
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ____rgbWorkBuf_4;
public:
inline static int32_t get_offset_of__rgbBuf_0() { return static_cast<int32_t>(offsetof(SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6, ____rgbBuf_0)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get__rgbBuf_0() const { return ____rgbBuf_0; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of__rgbBuf_0() { return &____rgbBuf_0; }
inline void set__rgbBuf_0(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
____rgbBuf_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rgbBuf_0), (void*)value);
}
inline static int32_t get_offset_of__lCurLen_1() { return static_cast<int32_t>(offsetof(SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6, ____lCurLen_1)); }
inline int64_t get__lCurLen_1() const { return ____lCurLen_1; }
inline int64_t* get_address_of__lCurLen_1() { return &____lCurLen_1; }
inline void set__lCurLen_1(int64_t value)
{
____lCurLen_1 = value;
}
inline static int32_t get_offset_of__stream_2() { return static_cast<int32_t>(offsetof(SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6, ____stream_2)); }
inline Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB * get__stream_2() const { return ____stream_2; }
inline Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB ** get_address_of__stream_2() { return &____stream_2; }
inline void set__stream_2(Stream_t5DC87DD578C2C5298D98E7802E92DEABB66E2ECB * value)
{
____stream_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stream_2), (void*)value);
}
inline static int32_t get_offset_of__state_3() { return static_cast<int32_t>(offsetof(SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6, ____state_3)); }
inline int32_t get__state_3() const { return ____state_3; }
inline int32_t* get_address_of__state_3() { return &____state_3; }
inline void set__state_3(int32_t value)
{
____state_3 = value;
}
inline static int32_t get_offset_of__rgbWorkBuf_4() { return static_cast<int32_t>(offsetof(SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6, ____rgbWorkBuf_4)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get__rgbWorkBuf_4() const { return ____rgbWorkBuf_4; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of__rgbWorkBuf_4() { return &____rgbWorkBuf_4; }
inline void set__rgbWorkBuf_4(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
____rgbWorkBuf_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rgbWorkBuf_4), (void*)value);
}
};
// System.Data.SqlTypes.SqlChars
struct SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53 : public RuntimeObject
{
public:
// System.Char[] System.Data.SqlTypes.SqlChars::_rgchBuf
CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* ____rgchBuf_0;
// System.Int64 System.Data.SqlTypes.SqlChars::_lCurLen
int64_t ____lCurLen_1;
// System.Data.SqlTypes.SqlStreamChars System.Data.SqlTypes.SqlChars::_stream
SqlStreamChars_t910B848D31E31CB82C6F50F1ECE148D614DE4665 * ____stream_2;
// System.Data.SqlTypes.SqlBytesCharsState System.Data.SqlTypes.SqlChars::_state
int32_t ____state_3;
// System.Char[] System.Data.SqlTypes.SqlChars::_rgchWorkBuf
CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* ____rgchWorkBuf_4;
public:
inline static int32_t get_offset_of__rgchBuf_0() { return static_cast<int32_t>(offsetof(SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53, ____rgchBuf_0)); }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* get__rgchBuf_0() const { return ____rgchBuf_0; }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34** get_address_of__rgchBuf_0() { return &____rgchBuf_0; }
inline void set__rgchBuf_0(CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* value)
{
____rgchBuf_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rgchBuf_0), (void*)value);
}
inline static int32_t get_offset_of__lCurLen_1() { return static_cast<int32_t>(offsetof(SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53, ____lCurLen_1)); }
inline int64_t get__lCurLen_1() const { return ____lCurLen_1; }
inline int64_t* get_address_of__lCurLen_1() { return &____lCurLen_1; }
inline void set__lCurLen_1(int64_t value)
{
____lCurLen_1 = value;
}
inline static int32_t get_offset_of__stream_2() { return static_cast<int32_t>(offsetof(SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53, ____stream_2)); }
inline SqlStreamChars_t910B848D31E31CB82C6F50F1ECE148D614DE4665 * get__stream_2() const { return ____stream_2; }
inline SqlStreamChars_t910B848D31E31CB82C6F50F1ECE148D614DE4665 ** get_address_of__stream_2() { return &____stream_2; }
inline void set__stream_2(SqlStreamChars_t910B848D31E31CB82C6F50F1ECE148D614DE4665 * value)
{
____stream_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stream_2), (void*)value);
}
inline static int32_t get_offset_of__state_3() { return static_cast<int32_t>(offsetof(SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53, ____state_3)); }
inline int32_t get__state_3() const { return ____state_3; }
inline int32_t* get_address_of__state_3() { return &____state_3; }
inline void set__state_3(int32_t value)
{
____state_3 = value;
}
inline static int32_t get_offset_of__rgchWorkBuf_4() { return static_cast<int32_t>(offsetof(SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53, ____rgchWorkBuf_4)); }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* get__rgchWorkBuf_4() const { return ____rgchWorkBuf_4; }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34** get_address_of__rgchWorkBuf_4() { return &____rgchWorkBuf_4; }
inline void set__rgchWorkBuf_4(CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* value)
{
____rgchWorkBuf_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rgchWorkBuf_4), (void*)value);
}
};
// System.Data.SqlTypes.SqlDateTime
struct SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D
{
public:
// System.Boolean System.Data.SqlTypes.SqlDateTime::m_fNotNull
bool ___m_fNotNull_0;
// System.Int32 System.Data.SqlTypes.SqlDateTime::m_day
int32_t ___m_day_1;
// System.Int32 System.Data.SqlTypes.SqlDateTime::m_time
int32_t ___m_time_2;
public:
inline static int32_t get_offset_of_m_fNotNull_0() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D, ___m_fNotNull_0)); }
inline bool get_m_fNotNull_0() const { return ___m_fNotNull_0; }
inline bool* get_address_of_m_fNotNull_0() { return &___m_fNotNull_0; }
inline void set_m_fNotNull_0(bool value)
{
___m_fNotNull_0 = value;
}
inline static int32_t get_offset_of_m_day_1() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D, ___m_day_1)); }
inline int32_t get_m_day_1() const { return ___m_day_1; }
inline int32_t* get_address_of_m_day_1() { return &___m_day_1; }
inline void set_m_day_1(int32_t value)
{
___m_day_1 = value;
}
inline static int32_t get_offset_of_m_time_2() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D, ___m_time_2)); }
inline int32_t get_m_time_2() const { return ___m_time_2; }
inline int32_t* get_address_of_m_time_2() { return &___m_time_2; }
inline void set_m_time_2(int32_t value)
{
___m_time_2 = value;
}
};
struct SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields
{
public:
// System.Double System.Data.SqlTypes.SqlDateTime::s_SQLTicksPerMillisecond
double ___s_SQLTicksPerMillisecond_3;
// System.Int32 System.Data.SqlTypes.SqlDateTime::SQLTicksPerSecond
int32_t ___SQLTicksPerSecond_4;
// System.Int32 System.Data.SqlTypes.SqlDateTime::SQLTicksPerMinute
int32_t ___SQLTicksPerMinute_5;
// System.Int32 System.Data.SqlTypes.SqlDateTime::SQLTicksPerHour
int32_t ___SQLTicksPerHour_6;
// System.Int32 System.Data.SqlTypes.SqlDateTime::s_SQLTicksPerDay
int32_t ___s_SQLTicksPerDay_7;
// System.Int64 System.Data.SqlTypes.SqlDateTime::s_ticksPerSecond
int64_t ___s_ticksPerSecond_8;
// System.DateTime System.Data.SqlTypes.SqlDateTime::s_SQLBaseDate
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___s_SQLBaseDate_9;
// System.Int64 System.Data.SqlTypes.SqlDateTime::s_SQLBaseDateTicks
int64_t ___s_SQLBaseDateTicks_10;
// System.Int32 System.Data.SqlTypes.SqlDateTime::s_minYear
int32_t ___s_minYear_11;
// System.Int32 System.Data.SqlTypes.SqlDateTime::s_maxYear
int32_t ___s_maxYear_12;
// System.Int32 System.Data.SqlTypes.SqlDateTime::s_minDay
int32_t ___s_minDay_13;
// System.Int32 System.Data.SqlTypes.SqlDateTime::s_maxDay
int32_t ___s_maxDay_14;
// System.Int32 System.Data.SqlTypes.SqlDateTime::s_minTime
int32_t ___s_minTime_15;
// System.Int32 System.Data.SqlTypes.SqlDateTime::s_maxTime
int32_t ___s_maxTime_16;
// System.Int32 System.Data.SqlTypes.SqlDateTime::s_dayBase
int32_t ___s_dayBase_17;
// System.Int32[] System.Data.SqlTypes.SqlDateTime::s_daysToMonth365
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___s_daysToMonth365_18;
// System.Int32[] System.Data.SqlTypes.SqlDateTime::s_daysToMonth366
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___s_daysToMonth366_19;
// System.DateTime System.Data.SqlTypes.SqlDateTime::s_minDateTime
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___s_minDateTime_20;
// System.DateTime System.Data.SqlTypes.SqlDateTime::s_maxDateTime
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___s_maxDateTime_21;
// System.TimeSpan System.Data.SqlTypes.SqlDateTime::s_minTimeSpan
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___s_minTimeSpan_22;
// System.TimeSpan System.Data.SqlTypes.SqlDateTime::s_maxTimeSpan
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___s_maxTimeSpan_23;
// System.String System.Data.SqlTypes.SqlDateTime::s_ISO8601_DateTimeFormat
String_t* ___s_ISO8601_DateTimeFormat_24;
// System.String[] System.Data.SqlTypes.SqlDateTime::s_dateTimeFormats
StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* ___s_dateTimeFormats_25;
// System.Data.SqlTypes.SqlDateTime System.Data.SqlTypes.SqlDateTime::MinValue
SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D ___MinValue_26;
// System.Data.SqlTypes.SqlDateTime System.Data.SqlTypes.SqlDateTime::MaxValue
SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D ___MaxValue_27;
// System.Data.SqlTypes.SqlDateTime System.Data.SqlTypes.SqlDateTime::Null
SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D ___Null_28;
public:
inline static int32_t get_offset_of_s_SQLTicksPerMillisecond_3() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_SQLTicksPerMillisecond_3)); }
inline double get_s_SQLTicksPerMillisecond_3() const { return ___s_SQLTicksPerMillisecond_3; }
inline double* get_address_of_s_SQLTicksPerMillisecond_3() { return &___s_SQLTicksPerMillisecond_3; }
inline void set_s_SQLTicksPerMillisecond_3(double value)
{
___s_SQLTicksPerMillisecond_3 = value;
}
inline static int32_t get_offset_of_SQLTicksPerSecond_4() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___SQLTicksPerSecond_4)); }
inline int32_t get_SQLTicksPerSecond_4() const { return ___SQLTicksPerSecond_4; }
inline int32_t* get_address_of_SQLTicksPerSecond_4() { return &___SQLTicksPerSecond_4; }
inline void set_SQLTicksPerSecond_4(int32_t value)
{
___SQLTicksPerSecond_4 = value;
}
inline static int32_t get_offset_of_SQLTicksPerMinute_5() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___SQLTicksPerMinute_5)); }
inline int32_t get_SQLTicksPerMinute_5() const { return ___SQLTicksPerMinute_5; }
inline int32_t* get_address_of_SQLTicksPerMinute_5() { return &___SQLTicksPerMinute_5; }
inline void set_SQLTicksPerMinute_5(int32_t value)
{
___SQLTicksPerMinute_5 = value;
}
inline static int32_t get_offset_of_SQLTicksPerHour_6() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___SQLTicksPerHour_6)); }
inline int32_t get_SQLTicksPerHour_6() const { return ___SQLTicksPerHour_6; }
inline int32_t* get_address_of_SQLTicksPerHour_6() { return &___SQLTicksPerHour_6; }
inline void set_SQLTicksPerHour_6(int32_t value)
{
___SQLTicksPerHour_6 = value;
}
inline static int32_t get_offset_of_s_SQLTicksPerDay_7() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_SQLTicksPerDay_7)); }
inline int32_t get_s_SQLTicksPerDay_7() const { return ___s_SQLTicksPerDay_7; }
inline int32_t* get_address_of_s_SQLTicksPerDay_7() { return &___s_SQLTicksPerDay_7; }
inline void set_s_SQLTicksPerDay_7(int32_t value)
{
___s_SQLTicksPerDay_7 = value;
}
inline static int32_t get_offset_of_s_ticksPerSecond_8() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_ticksPerSecond_8)); }
inline int64_t get_s_ticksPerSecond_8() const { return ___s_ticksPerSecond_8; }
inline int64_t* get_address_of_s_ticksPerSecond_8() { return &___s_ticksPerSecond_8; }
inline void set_s_ticksPerSecond_8(int64_t value)
{
___s_ticksPerSecond_8 = value;
}
inline static int32_t get_offset_of_s_SQLBaseDate_9() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_SQLBaseDate_9)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_s_SQLBaseDate_9() const { return ___s_SQLBaseDate_9; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_s_SQLBaseDate_9() { return &___s_SQLBaseDate_9; }
inline void set_s_SQLBaseDate_9(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___s_SQLBaseDate_9 = value;
}
inline static int32_t get_offset_of_s_SQLBaseDateTicks_10() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_SQLBaseDateTicks_10)); }
inline int64_t get_s_SQLBaseDateTicks_10() const { return ___s_SQLBaseDateTicks_10; }
inline int64_t* get_address_of_s_SQLBaseDateTicks_10() { return &___s_SQLBaseDateTicks_10; }
inline void set_s_SQLBaseDateTicks_10(int64_t value)
{
___s_SQLBaseDateTicks_10 = value;
}
inline static int32_t get_offset_of_s_minYear_11() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_minYear_11)); }
inline int32_t get_s_minYear_11() const { return ___s_minYear_11; }
inline int32_t* get_address_of_s_minYear_11() { return &___s_minYear_11; }
inline void set_s_minYear_11(int32_t value)
{
___s_minYear_11 = value;
}
inline static int32_t get_offset_of_s_maxYear_12() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_maxYear_12)); }
inline int32_t get_s_maxYear_12() const { return ___s_maxYear_12; }
inline int32_t* get_address_of_s_maxYear_12() { return &___s_maxYear_12; }
inline void set_s_maxYear_12(int32_t value)
{
___s_maxYear_12 = value;
}
inline static int32_t get_offset_of_s_minDay_13() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_minDay_13)); }
inline int32_t get_s_minDay_13() const { return ___s_minDay_13; }
inline int32_t* get_address_of_s_minDay_13() { return &___s_minDay_13; }
inline void set_s_minDay_13(int32_t value)
{
___s_minDay_13 = value;
}
inline static int32_t get_offset_of_s_maxDay_14() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_maxDay_14)); }
inline int32_t get_s_maxDay_14() const { return ___s_maxDay_14; }
inline int32_t* get_address_of_s_maxDay_14() { return &___s_maxDay_14; }
inline void set_s_maxDay_14(int32_t value)
{
___s_maxDay_14 = value;
}
inline static int32_t get_offset_of_s_minTime_15() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_minTime_15)); }
inline int32_t get_s_minTime_15() const { return ___s_minTime_15; }
inline int32_t* get_address_of_s_minTime_15() { return &___s_minTime_15; }
inline void set_s_minTime_15(int32_t value)
{
___s_minTime_15 = value;
}
inline static int32_t get_offset_of_s_maxTime_16() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_maxTime_16)); }
inline int32_t get_s_maxTime_16() const { return ___s_maxTime_16; }
inline int32_t* get_address_of_s_maxTime_16() { return &___s_maxTime_16; }
inline void set_s_maxTime_16(int32_t value)
{
___s_maxTime_16 = value;
}
inline static int32_t get_offset_of_s_dayBase_17() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_dayBase_17)); }
inline int32_t get_s_dayBase_17() const { return ___s_dayBase_17; }
inline int32_t* get_address_of_s_dayBase_17() { return &___s_dayBase_17; }
inline void set_s_dayBase_17(int32_t value)
{
___s_dayBase_17 = value;
}
inline static int32_t get_offset_of_s_daysToMonth365_18() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_daysToMonth365_18)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_s_daysToMonth365_18() const { return ___s_daysToMonth365_18; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_s_daysToMonth365_18() { return &___s_daysToMonth365_18; }
inline void set_s_daysToMonth365_18(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___s_daysToMonth365_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_daysToMonth365_18), (void*)value);
}
inline static int32_t get_offset_of_s_daysToMonth366_19() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_daysToMonth366_19)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_s_daysToMonth366_19() const { return ___s_daysToMonth366_19; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_s_daysToMonth366_19() { return &___s_daysToMonth366_19; }
inline void set_s_daysToMonth366_19(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___s_daysToMonth366_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_daysToMonth366_19), (void*)value);
}
inline static int32_t get_offset_of_s_minDateTime_20() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_minDateTime_20)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_s_minDateTime_20() const { return ___s_minDateTime_20; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_s_minDateTime_20() { return &___s_minDateTime_20; }
inline void set_s_minDateTime_20(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___s_minDateTime_20 = value;
}
inline static int32_t get_offset_of_s_maxDateTime_21() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_maxDateTime_21)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_s_maxDateTime_21() const { return ___s_maxDateTime_21; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_s_maxDateTime_21() { return &___s_maxDateTime_21; }
inline void set_s_maxDateTime_21(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___s_maxDateTime_21 = value;
}
inline static int32_t get_offset_of_s_minTimeSpan_22() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_minTimeSpan_22)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_s_minTimeSpan_22() const { return ___s_minTimeSpan_22; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_s_minTimeSpan_22() { return &___s_minTimeSpan_22; }
inline void set_s_minTimeSpan_22(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___s_minTimeSpan_22 = value;
}
inline static int32_t get_offset_of_s_maxTimeSpan_23() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_maxTimeSpan_23)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_s_maxTimeSpan_23() const { return ___s_maxTimeSpan_23; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_s_maxTimeSpan_23() { return &___s_maxTimeSpan_23; }
inline void set_s_maxTimeSpan_23(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___s_maxTimeSpan_23 = value;
}
inline static int32_t get_offset_of_s_ISO8601_DateTimeFormat_24() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_ISO8601_DateTimeFormat_24)); }
inline String_t* get_s_ISO8601_DateTimeFormat_24() const { return ___s_ISO8601_DateTimeFormat_24; }
inline String_t** get_address_of_s_ISO8601_DateTimeFormat_24() { return &___s_ISO8601_DateTimeFormat_24; }
inline void set_s_ISO8601_DateTimeFormat_24(String_t* value)
{
___s_ISO8601_DateTimeFormat_24 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_ISO8601_DateTimeFormat_24), (void*)value);
}
inline static int32_t get_offset_of_s_dateTimeFormats_25() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___s_dateTimeFormats_25)); }
inline StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* get_s_dateTimeFormats_25() const { return ___s_dateTimeFormats_25; }
inline StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A** get_address_of_s_dateTimeFormats_25() { return &___s_dateTimeFormats_25; }
inline void set_s_dateTimeFormats_25(StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* value)
{
___s_dateTimeFormats_25 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_dateTimeFormats_25), (void*)value);
}
inline static int32_t get_offset_of_MinValue_26() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___MinValue_26)); }
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D get_MinValue_26() const { return ___MinValue_26; }
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D * get_address_of_MinValue_26() { return &___MinValue_26; }
inline void set_MinValue_26(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D value)
{
___MinValue_26 = value;
}
inline static int32_t get_offset_of_MaxValue_27() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___MaxValue_27)); }
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D get_MaxValue_27() const { return ___MaxValue_27; }
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D * get_address_of_MaxValue_27() { return &___MaxValue_27; }
inline void set_MaxValue_27(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D value)
{
___MaxValue_27 = value;
}
inline static int32_t get_offset_of_Null_28() { return static_cast<int32_t>(offsetof(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_StaticFields, ___Null_28)); }
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D get_Null_28() const { return ___Null_28; }
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D * get_address_of_Null_28() { return &___Null_28; }
inline void set_Null_28(SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D value)
{
___Null_28 = value;
}
};
// Native definition for P/Invoke marshalling of System.Data.SqlTypes.SqlDateTime
struct SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_marshaled_pinvoke
{
int32_t ___m_fNotNull_0;
int32_t ___m_day_1;
int32_t ___m_time_2;
};
// Native definition for COM marshalling of System.Data.SqlTypes.SqlDateTime
struct SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D_marshaled_com
{
int32_t ___m_fNotNull_0;
int32_t ___m_day_1;
int32_t ___m_time_2;
};
// UnityEngine.Behaviour
struct Behaviour_t1A3DDDCF73B4627928FBFE02ED52B7251777DBD9 : public Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684
{
public:
public:
};
// UnityEngine.MonoBehaviour
struct MonoBehaviour_t37A501200D970A8257124B0EAE00A0FF3DDC354A : public Behaviour_t1A3DDDCF73B4627928FBFE02ED52B7251777DBD9
{
public:
public:
};
// SiteOverviewTurbineButton
struct SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939 : public MonoBehaviour_t37A501200D970A8257124B0EAE00A0FF3DDC354A
{
public:
// SiteOverviewUIPanel SiteOverviewTurbineButton::siteOverviewPanel
SiteOverviewUIPanel_tC1890DA197296EDD75E4E430A5254B9AC192AEA0 * ___siteOverviewPanel_4;
// TMPro.TextMeshProUGUI SiteOverviewTurbineButton::turbineNameLabel
TextMeshProUGUI_tCC5BE8A76E6E9AF92521A462E8D81ACFBA7C85F1 * ___turbineNameLabel_5;
// ProgressController SiteOverviewTurbineButton::progressController
ProgressController_tF9F02EB59D94987ECAFF59CC4CA61158B949E6E8 * ___progressController_6;
// UnityEngine.GameObject SiteOverviewTurbineButton::warningIndicator
GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * ___warningIndicator_7;
// WindTurbineScriptableObject SiteOverviewTurbineButton::windTurbineData
WindTurbineScriptableObject_t03D27141AD20B61458ADEA1BADEEEF48CC01E1B0 * ___windTurbineData_8;
// WindTurbineGameEvent SiteOverviewTurbineButton::focusOnTurbineEvent
WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB * ___focusOnTurbineEvent_9;
// WindTurbineGameEvent SiteOverviewTurbineButton::onHoverStart
WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB * ___onHoverStart_10;
// WindTurbineGameEvent SiteOverviewTurbineButton::onHoverEnd
WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB * ___onHoverEnd_11;
public:
inline static int32_t get_offset_of_siteOverviewPanel_4() { return static_cast<int32_t>(offsetof(SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939, ___siteOverviewPanel_4)); }
inline SiteOverviewUIPanel_tC1890DA197296EDD75E4E430A5254B9AC192AEA0 * get_siteOverviewPanel_4() const { return ___siteOverviewPanel_4; }
inline SiteOverviewUIPanel_tC1890DA197296EDD75E4E430A5254B9AC192AEA0 ** get_address_of_siteOverviewPanel_4() { return &___siteOverviewPanel_4; }
inline void set_siteOverviewPanel_4(SiteOverviewUIPanel_tC1890DA197296EDD75E4E430A5254B9AC192AEA0 * value)
{
___siteOverviewPanel_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___siteOverviewPanel_4), (void*)value);
}
inline static int32_t get_offset_of_turbineNameLabel_5() { return static_cast<int32_t>(offsetof(SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939, ___turbineNameLabel_5)); }
inline TextMeshProUGUI_tCC5BE8A76E6E9AF92521A462E8D81ACFBA7C85F1 * get_turbineNameLabel_5() const { return ___turbineNameLabel_5; }
inline TextMeshProUGUI_tCC5BE8A76E6E9AF92521A462E8D81ACFBA7C85F1 ** get_address_of_turbineNameLabel_5() { return &___turbineNameLabel_5; }
inline void set_turbineNameLabel_5(TextMeshProUGUI_tCC5BE8A76E6E9AF92521A462E8D81ACFBA7C85F1 * value)
{
___turbineNameLabel_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___turbineNameLabel_5), (void*)value);
}
inline static int32_t get_offset_of_progressController_6() { return static_cast<int32_t>(offsetof(SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939, ___progressController_6)); }
inline ProgressController_tF9F02EB59D94987ECAFF59CC4CA61158B949E6E8 * get_progressController_6() const { return ___progressController_6; }
inline ProgressController_tF9F02EB59D94987ECAFF59CC4CA61158B949E6E8 ** get_address_of_progressController_6() { return &___progressController_6; }
inline void set_progressController_6(ProgressController_tF9F02EB59D94987ECAFF59CC4CA61158B949E6E8 * value)
{
___progressController_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___progressController_6), (void*)value);
}
inline static int32_t get_offset_of_warningIndicator_7() { return static_cast<int32_t>(offsetof(SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939, ___warningIndicator_7)); }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * get_warningIndicator_7() const { return ___warningIndicator_7; }
inline GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 ** get_address_of_warningIndicator_7() { return &___warningIndicator_7; }
inline void set_warningIndicator_7(GameObject_tC000A2E1A7CF1E10FD7BA08863287C072207C319 * value)
{
___warningIndicator_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___warningIndicator_7), (void*)value);
}
inline static int32_t get_offset_of_windTurbineData_8() { return static_cast<int32_t>(offsetof(SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939, ___windTurbineData_8)); }
inline WindTurbineScriptableObject_t03D27141AD20B61458ADEA1BADEEEF48CC01E1B0 * get_windTurbineData_8() const { return ___windTurbineData_8; }
inline WindTurbineScriptableObject_t03D27141AD20B61458ADEA1BADEEEF48CC01E1B0 ** get_address_of_windTurbineData_8() { return &___windTurbineData_8; }
inline void set_windTurbineData_8(WindTurbineScriptableObject_t03D27141AD20B61458ADEA1BADEEEF48CC01E1B0 * value)
{
___windTurbineData_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___windTurbineData_8), (void*)value);
}
inline static int32_t get_offset_of_focusOnTurbineEvent_9() { return static_cast<int32_t>(offsetof(SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939, ___focusOnTurbineEvent_9)); }
inline WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB * get_focusOnTurbineEvent_9() const { return ___focusOnTurbineEvent_9; }
inline WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB ** get_address_of_focusOnTurbineEvent_9() { return &___focusOnTurbineEvent_9; }
inline void set_focusOnTurbineEvent_9(WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB * value)
{
___focusOnTurbineEvent_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___focusOnTurbineEvent_9), (void*)value);
}
inline static int32_t get_offset_of_onHoverStart_10() { return static_cast<int32_t>(offsetof(SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939, ___onHoverStart_10)); }
inline WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB * get_onHoverStart_10() const { return ___onHoverStart_10; }
inline WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB ** get_address_of_onHoverStart_10() { return &___onHoverStart_10; }
inline void set_onHoverStart_10(WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB * value)
{
___onHoverStart_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___onHoverStart_10), (void*)value);
}
inline static int32_t get_offset_of_onHoverEnd_11() { return static_cast<int32_t>(offsetof(SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939, ___onHoverEnd_11)); }
inline WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB * get_onHoverEnd_11() const { return ___onHoverEnd_11; }
inline WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB ** get_address_of_onHoverEnd_11() { return &___onHoverEnd_11; }
inline void set_onHoverEnd_11(WindTurbineGameEvent_tB0CD29D5DBE8F397B833AB90886F66A05343A1AB * value)
{
___onHoverEnd_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___onHoverEnd_11), (void*)value);
}
};
// Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver
struct Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971 : public MonoBehaviour_t37A501200D970A8257124B0EAE00A0FF3DDC354A
{
public:
// System.Boolean Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver::updateLinkedTransform
bool ___updateLinkedTransform_4;
// System.Single Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver::moveLerpTime
float ___moveLerpTime_5;
// System.Single Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver::rotateLerpTime
float ___rotateLerpTime_6;
// System.Single Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver::scaleLerpTime
float ___scaleLerpTime_7;
// System.Boolean Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver::maintainScaleOnInitialization
bool ___maintainScaleOnInitialization_8;
// System.Boolean Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver::smoothing
bool ___smoothing_9;
// System.Single Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver::lifetime
float ___lifetime_10;
// System.Single Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver::currentLifetime
float ___currentLifetime_11;
// Microsoft.MixedReality.Toolkit.Utilities.Solvers.SolverHandler Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver::SolverHandler
SolverHandler_t6CF6DCC834885CCD53A484458C1B78548C6D8810 * ___SolverHandler_12;
public:
inline static int32_t get_offset_of_updateLinkedTransform_4() { return static_cast<int32_t>(offsetof(Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971, ___updateLinkedTransform_4)); }
inline bool get_updateLinkedTransform_4() const { return ___updateLinkedTransform_4; }
inline bool* get_address_of_updateLinkedTransform_4() { return &___updateLinkedTransform_4; }
inline void set_updateLinkedTransform_4(bool value)
{
___updateLinkedTransform_4 = value;
}
inline static int32_t get_offset_of_moveLerpTime_5() { return static_cast<int32_t>(offsetof(Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971, ___moveLerpTime_5)); }
inline float get_moveLerpTime_5() const { return ___moveLerpTime_5; }
inline float* get_address_of_moveLerpTime_5() { return &___moveLerpTime_5; }
inline void set_moveLerpTime_5(float value)
{
___moveLerpTime_5 = value;
}
inline static int32_t get_offset_of_rotateLerpTime_6() { return static_cast<int32_t>(offsetof(Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971, ___rotateLerpTime_6)); }
inline float get_rotateLerpTime_6() const { return ___rotateLerpTime_6; }
inline float* get_address_of_rotateLerpTime_6() { return &___rotateLerpTime_6; }
inline void set_rotateLerpTime_6(float value)
{
___rotateLerpTime_6 = value;
}
inline static int32_t get_offset_of_scaleLerpTime_7() { return static_cast<int32_t>(offsetof(Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971, ___scaleLerpTime_7)); }
inline float get_scaleLerpTime_7() const { return ___scaleLerpTime_7; }
inline float* get_address_of_scaleLerpTime_7() { return &___scaleLerpTime_7; }
inline void set_scaleLerpTime_7(float value)
{
___scaleLerpTime_7 = value;
}
inline static int32_t get_offset_of_maintainScaleOnInitialization_8() { return static_cast<int32_t>(offsetof(Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971, ___maintainScaleOnInitialization_8)); }
inline bool get_maintainScaleOnInitialization_8() const { return ___maintainScaleOnInitialization_8; }
inline bool* get_address_of_maintainScaleOnInitialization_8() { return &___maintainScaleOnInitialization_8; }
inline void set_maintainScaleOnInitialization_8(bool value)
{
___maintainScaleOnInitialization_8 = value;
}
inline static int32_t get_offset_of_smoothing_9() { return static_cast<int32_t>(offsetof(Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971, ___smoothing_9)); }
inline bool get_smoothing_9() const { return ___smoothing_9; }
inline bool* get_address_of_smoothing_9() { return &___smoothing_9; }
inline void set_smoothing_9(bool value)
{
___smoothing_9 = value;
}
inline static int32_t get_offset_of_lifetime_10() { return static_cast<int32_t>(offsetof(Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971, ___lifetime_10)); }
inline float get_lifetime_10() const { return ___lifetime_10; }
inline float* get_address_of_lifetime_10() { return &___lifetime_10; }
inline void set_lifetime_10(float value)
{
___lifetime_10 = value;
}
inline static int32_t get_offset_of_currentLifetime_11() { return static_cast<int32_t>(offsetof(Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971, ___currentLifetime_11)); }
inline float get_currentLifetime_11() const { return ___currentLifetime_11; }
inline float* get_address_of_currentLifetime_11() { return &___currentLifetime_11; }
inline void set_currentLifetime_11(float value)
{
___currentLifetime_11 = value;
}
inline static int32_t get_offset_of_SolverHandler_12() { return static_cast<int32_t>(offsetof(Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971, ___SolverHandler_12)); }
inline SolverHandler_t6CF6DCC834885CCD53A484458C1B78548C6D8810 * get_SolverHandler_12() const { return ___SolverHandler_12; }
inline SolverHandler_t6CF6DCC834885CCD53A484458C1B78548C6D8810 ** get_address_of_SolverHandler_12() { return &___SolverHandler_12; }
inline void set_SolverHandler_12(SolverHandler_t6CF6DCC834885CCD53A484458C1B78548C6D8810 * value)
{
___SolverHandler_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___SolverHandler_12), (void*)value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// System.Single[]
struct SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA : public RuntimeArray
{
public:
ALIGN_FIELD (8) float m_Items[1];
public:
inline float GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline float* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, float value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline float GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline float* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, float value)
{
m_Items[index] = value;
}
};
// System.Byte[]
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726 : public RuntimeArray
{
public:
ALIGN_FIELD (8) uint8_t m_Items[1];
public:
inline uint8_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint8_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint8_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint8_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint8_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint8_t value)
{
m_Items[index] = value;
}
};
// System.Int16[]
struct Int16U5BU5D_tD134F1E6F746D4C09C987436805256C210C2FFCD : public RuntimeArray
{
public:
ALIGN_FIELD (8) int16_t m_Items[1];
public:
inline int16_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline int16_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, int16_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline int16_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline int16_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, int16_t value)
{
m_Items[index] = value;
}
};
// System.UInt16[]
struct UInt16U5BU5D_t42D35C587B07DCDBCFDADF572C6D733AE85B2A67 : public RuntimeArray
{
public:
ALIGN_FIELD (8) uint16_t m_Items[1];
public:
inline uint16_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint16_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint16_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint16_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint16_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint16_t value)
{
m_Items[index] = value;
}
};
// System.Int32[]
struct Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32 : public RuntimeArray
{
public:
ALIGN_FIELD (8) int32_t m_Items[1];
public:
inline int32_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline int32_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, int32_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline int32_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline int32_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, int32_t value)
{
m_Items[index] = value;
}
};
// System.UInt32[]
struct UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF : public RuntimeArray
{
public:
ALIGN_FIELD (8) uint32_t m_Items[1];
public:
inline uint32_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint32_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint32_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint32_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint32_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint32_t value)
{
m_Items[index] = value;
}
};
// System.Int64[]
struct Int64U5BU5D_tCA61E42872C63A4286B24EEE6E0650143B43DCE6 : public RuntimeArray
{
public:
ALIGN_FIELD (8) int64_t m_Items[1];
public:
inline int64_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline int64_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, int64_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline int64_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline int64_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, int64_t value)
{
m_Items[index] = value;
}
};
// System.UInt64[]
struct UInt64U5BU5D_t7C6E32D10F47677C1CEF3C30F4E4CE95B3A633E2 : public RuntimeArray
{
public:
ALIGN_FIELD (8) uint64_t m_Items[1];
public:
inline uint64_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint64_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint64_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint64_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint64_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint64_t value)
{
m_Items[index] = value;
}
};
// System.Double[]
struct DoubleU5BU5D_t8E1B42EB2ABB79FBD193A6B8C8D97A7CDE44A4FB : public RuntimeArray
{
public:
ALIGN_FIELD (8) double m_Items[1];
public:
inline double GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline double* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, double value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline double GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline double* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, double value)
{
m_Items[index] = value;
}
};
// System.String[]
struct StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A : public RuntimeArray
{
public:
ALIGN_FIELD (8) String_t* m_Items[1];
public:
inline String_t* GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline String_t** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, String_t* value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline String_t* GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline String_t** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, String_t* value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Guid[]
struct GuidU5BU5D_t6DCED1B9FC5592C43FAA73D81705104BD18151B8 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Guid_t m_Items[1];
public:
inline Guid_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Guid_t * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Guid_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline Guid_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Guid_t * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Guid_t value)
{
m_Items[index] = value;
}
};
// SiteOverviewTurbineButton[]
struct SiteOverviewTurbineButtonU5BU5D_t3ACBCC0C5A7D36AFE732F05FFE492AA4B8CCCF5C : public RuntimeArray
{
public:
ALIGN_FIELD (8) SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939 * m_Items[1];
public:
inline SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SiteOverviewTurbineButton_t774E530836694BA3714EC78176A40D5C27856939 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver[]
struct SolverU5BU5D_t7D4E8D7D33AE0E86ADE266E97543F909C6A9D1B6 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971 * m_Items[1];
public:
inline Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Solver_t8BBDA74686483C111074BE6BE588AB31E74B2971 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject[]
struct SpatialAwarenessMeshObjectU5BU5D_tA94B023FDD95287C601B9EC531C41DA60D5D0C5A : public RuntimeArray
{
public:
ALIGN_FIELD (8) SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A * m_Items[1];
public:
inline SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SpatialAwarenessMeshObject_t6599CE0971A63B6D01F0F352431B66848093BE5A * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessPlanarObject[]
struct SpatialAwarenessPlanarObjectU5BU5D_t772A69ED777B1C864FC824CA32DA58CA28AC6743 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE * m_Items[1];
public:
inline SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SpatialAwarenessPlanarObject_t548FB81C44BB10562EBA2CD41024B3A84ED7BDEE * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject[]
struct SpatialAwarenessSceneObjectU5BU5D_t6F70086B6848AB4D5DA4B5454581DCEA06A370E3 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612 * m_Items[1];
public:
inline SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SpatialAwarenessSceneObject_tB51F64F99C29A4803DEFA3EA7BC7947816DB8612 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// UnityEngine.Sprite[]
struct SpriteU5BU5D_t8DB77E112FFC97B722E701189DCB4059F943FD77 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * m_Items[1];
public:
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Sprite_t5B10B1178EC2E6F53D33FFD77557F31C08A51ED9 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Data.SqlTypes.SqlBinary[]
struct SqlBinaryU5BU5D_t4A1CD2FDEEC6E9EAEC15A8C28A7701484B8D4485 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B m_Items[1];
public:
inline SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->____value_0), (void*)NULL);
}
inline SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlBinary_t83BA1113ACB82E306D2EC534B0864D8A4A7D125B value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->____value_0), (void*)NULL);
}
};
// System.Data.SqlTypes.SqlBoolean[]
struct SqlBooleanU5BU5D_t07B79EADC41ED65294851549545D3F3918FDC6A0 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 m_Items[1];
public:
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlBoolean_tD34BC5894C8A7061B0E2D2D2CBE8E4A5257FD4F3 value)
{
m_Items[index] = value;
}
};
// System.Data.SqlTypes.SqlByte[]
struct SqlByteU5BU5D_tB403A2418F730327A0789B78506CDACCECBB4CB6 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 m_Items[1];
public:
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlByte_t5E78C40CFCD84AF432F47D15743E513022E09B41 value)
{
m_Items[index] = value;
}
};
// System.Data.SqlTypes.SqlBytes[]
struct SqlBytesU5BU5D_t6F60DB18D1E498C69C2A2A292075B88252A47C49 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6 * m_Items[1];
public:
inline SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlBytes_tA89570BFA7CB45E83EAFB32FF13B8ABEC21555B6 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Data.SqlTypes.SqlChars[]
struct SqlCharsU5BU5D_t20FD646DC66170A3025ACFD16C890584136139FC : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53 * m_Items[1];
public:
inline SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53 * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53 ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53 * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53 * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53 ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlChars_t123841A0B03CA780E6710DFE1A63ABA7CDE1CD53 * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Data.SqlTypes.SqlDateTime[]
struct SqlDateTimeU5BU5D_t12EEE5C7616A30E9F9CE304F76B5912B2A47EABF : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D m_Items[1];
public:
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlDateTime_t18DC6DADB09444EBDCCF6536AA4F1567EC19337D value)
{
m_Items[index] = value;
}
};
// System.Data.SqlTypes.SqlDecimal[]
struct SqlDecimalU5BU5D_t436F1578CFBAD13111599A27A32FB894D8307CBD : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B m_Items[1];
public:
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlDecimal_t2E3764DA58ABCDADAC6F390C24C8273EF87AA54B value)
{
m_Items[index] = value;
}
};
// System.Data.SqlTypes.SqlDouble[]
struct SqlDoubleU5BU5D_t65F627E3E10E5B61B332C69E3E8180BB1B5C5EA7 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA m_Items[1];
public:
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlDouble_t0D9EDD6B609690459BDBBB52962B791D3D40B1FA value)
{
m_Items[index] = value;
}
};
// System.Data.SqlTypes.SqlGuid[]
struct SqlGuidU5BU5D_t7B958D75216823CC6FD381B81133477AFD2DE5E2 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 m_Items[1];
public:
inline SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___m_value_2), (void*)NULL);
}
inline SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlGuid_t5D26918EA5666BC8EBF86F12192E616F0BA8DE46 value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___m_value_2), (void*)NULL);
}
};
// System.Data.SqlTypes.SqlInt16[]
struct SqlInt16U5BU5D_tFDBC98064CCDBA5EF1A928770767FF5E428F68B0 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F m_Items[1];
public:
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlInt16_tB003889273CEF2625C06174D4DB23DBBAFEDD72F value)
{
m_Items[index] = value;
}
};
// System.Data.SqlTypes.SqlInt32[]
struct SqlInt32U5BU5D_t4E9A0DCCD18A21ED32AE342EE7288F4722D13002 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 m_Items[1];
public:
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlInt32_t2AB23DF9003BEBE6DBD94E94C8C679454A8AF0E5 value)
{
m_Items[index] = value;
}
};
// System.Data.SqlTypes.SqlInt64[]
struct SqlInt64U5BU5D_t07215C71C5947E0BE4CF431CB6124BC53ADA28C5 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE m_Items[1];
public:
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlInt64_tCF441A47D276F6121644D08D6BEE0296E84E46AE value)
{
m_Items[index] = value;
}
};
// System.Data.SqlTypes.SqlMoney[]
struct SqlMoneyU5BU5D_tF5702E9AA3B2D27362711637FFD105D198723C95 : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA m_Items[1];
public:
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlMoney_t3AFB18BE9EB489D660B42B8A4276B7C3054E00CA value)
{
m_Items[index] = value;
}
};
// System.Data.SqlTypes.SqlSingle[]
struct SqlSingleU5BU5D_t2F81D199741A89C70F73D8FAC1385A28379B442F : public RuntimeArray
{
public:
ALIGN_FIELD (8) SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E m_Items[1];
public:
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, SqlSingle_t2CD814E1AA8A493B2181D8240064E7A0A034A32E value)
{
m_Items[index] = value;
}
};
il2cpp_hresult_t IVector_1_GetAt_mB49A020A8CDF0AAF8DCFB381FD74A77688B0FA71_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0, float* comReturnValue);
il2cpp_hresult_t IVector_1_get_Size_m494C6D174D411D7FC20D21CE0FA2C0EDD5E91568_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t* comReturnValue);
il2cpp_hresult_t IVector_1_GetView_m2720307D308D3DCD49B6AF4C4A08D67498D2B186_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IVectorView_1_t0652AC4EC7AA575BE5D7797DFD20689718705BE0** comReturnValue);
il2cpp_hresult_t IVector_1_IndexOf_mC1E5DFCDEDC953A4E1CA8BB1C427FBE7EA517FF4_ComCallableWrapperProjectedMethod(RuntimeObject* __this, float ___value0, uint32_t* ___index1, bool* comReturnValue);
il2cpp_hresult_t IVector_1_SetAt_m478207B3FCA7EB1D8264306765201B9B4C8725AD_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0, float ___value1);
il2cpp_hresult_t IVector_1_InsertAt_m6C9D77B26BDE0B12FE238687DA397FC58C2032A2_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0, float ___value1);
il2cpp_hresult_t IVector_1_RemoveAt_m3EFDAC8DAF08714CB4FDF41FA54DF4EB2E0F9D97_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0);
il2cpp_hresult_t IVector_1_Append_mB47ED34CA2102C71646E947495BA9D14451E29C6_ComCallableWrapperProjectedMethod(RuntimeObject* __this, float ___value0);
il2cpp_hresult_t IVector_1_RemoveAtEnd_m04EB0AD3F455408D30F0FFE3100BEB8367635CFC_ComCallableWrapperProjectedMethod(RuntimeObject* __this);
il2cpp_hresult_t IVector_1_Clear_mE43500616C5480A63657796BB0AE2E60D7BA49A9_ComCallableWrapperProjectedMethod(RuntimeObject* __this);
il2cpp_hresult_t IVector_1_GetMany_m436FF76C0F1FFB49549025672552A1353FEF8745_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___startIndex0, uint32_t ___items1ArraySize, float* ___items1, uint32_t* comReturnValue);
il2cpp_hresult_t IVector_1_ReplaceAll_mF925EE20FE793EF0740B86913574AE2E17FD6B93_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___items0ArraySize, float* ___items0);
il2cpp_hresult_t IIterable_1_First_mBD8D20BBA2E9F188C15175F2C9AB4039C6400ED1_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t53A3C573D4888D0C268E9C0D9515A4BDAD329CCC** comReturnValue);
il2cpp_hresult_t IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue);
il2cpp_hresult_t IVectorView_1_GetAt_m3D2911EEE429BEE9DFCCFD08528A6B62938AE14E_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0, float* comReturnValue);
il2cpp_hresult_t IVectorView_1_get_Size_mE51A5C7833E725EA8286E5878D80E9D44ECDFF41_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t* comReturnValue);
il2cpp_hresult_t IVectorView_1_IndexOf_m4C0458BD59B3F97E792DE7EB4399297542D76C97_ComCallableWrapperProjectedMethod(RuntimeObject* __this, float ___value0, uint32_t* ___index1, bool* comReturnValue);
il2cpp_hresult_t IVectorView_1_GetMany_m481FCAC8A5B7E6C75882A80893023447977DA78B_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___startIndex0, uint32_t ___items1ArraySize, float* ___items1, uint32_t* comReturnValue);
il2cpp_hresult_t IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0, Il2CppIInspectable** comReturnValue);
il2cpp_hresult_t IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t* comReturnValue);
il2cpp_hresult_t IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue);
il2cpp_hresult_t IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(RuntimeObject* __this, Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue);
il2cpp_hresult_t IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0, Il2CppIInspectable* ___value1);
il2cpp_hresult_t IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0, Il2CppIInspectable* ___value1);
il2cpp_hresult_t IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0);
il2cpp_hresult_t IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(RuntimeObject* __this, Il2CppIInspectable* ___value0);
il2cpp_hresult_t IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(RuntimeObject* __this);
il2cpp_hresult_t IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(RuntimeObject* __this);
il2cpp_hresult_t IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue);
il2cpp_hresult_t IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___index0, Il2CppIInspectable** comReturnValue);
il2cpp_hresult_t IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t* comReturnValue);
il2cpp_hresult_t IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67_ComCallableWrapperProjectedMethod(RuntimeObject* __this, Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue);
il2cpp_hresult_t IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1_ComCallableWrapperProjectedMethod(RuntimeObject* __this, uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue);
// 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 System.Single[]
struct SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA_ComCallableWrapper>, IVector_1_t5FBA1DB686EDD35620DC2CCA810C0754A18E8C9D, IIterable_1_t0EA6FF8BF23034840DB9F5189AF1D72411992F7E, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IVectorView_1_t0652AC4EC7AA575BE5D7797DFD20689718705BE0, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC, IReferenceArray_1_t1BB7D08F28C5D27D16C0145A86D139290E764ABC, IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8
{
inline SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA_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, &IVector_1_t5FBA1DB686EDD35620DC2CCA810C0754A18E8C9D::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVector_1_t5FBA1DB686EDD35620DC2CCA810C0754A18E8C9D*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t0EA6FF8BF23034840DB9F5189AF1D72411992F7E::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t0EA6FF8BF23034840DB9F5189AF1D72411992F7E*>(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, &IVectorView_1_t0652AC4EC7AA575BE5D7797DFD20689718705BE0::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVectorView_1_t0652AC4EC7AA575BE5D7797DFD20689718705BE0*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IReferenceArray_1_t1BB7D08F28C5D27D16C0145A86D139290E764ABC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IReferenceArray_1_t1BB7D08F28C5D27D16C0145A86D139290E764ABC*>(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>(7);
interfaceIds[0] = IVector_1_t5FBA1DB686EDD35620DC2CCA810C0754A18E8C9D::IID;
interfaceIds[1] = IIterable_1_t0EA6FF8BF23034840DB9F5189AF1D72411992F7E::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[3] = IVectorView_1_t0652AC4EC7AA575BE5D7797DFD20689718705BE0::IID;
interfaceIds[4] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID;
interfaceIds[5] = IReferenceArray_1_t1BB7D08F28C5D27D16C0145A86D139290E764ABC::IID;
interfaceIds[6] = IPropertyValue_t2D61E5557FBCC9F0476CC32B5738B21EFFA483E8::IID;
*iidCount = 7;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IVector_1_GetAt_mB49A020A8CDF0AAF8DCFB381FD74A77688B0FA71(uint32_t ___index0, float* comReturnValue) IL2CPP_OVERRIDE
{
return IVector_1_GetAt_mB49A020A8CDF0AAF8DCFB381FD74A77688B0FA71_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVector_1_get_Size_m494C6D174D411D7FC20D21CE0FA2C0EDD5E91568(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVector_1_get_Size_m494C6D174D411D7FC20D21CE0FA2C0EDD5E91568_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVector_1_GetView_m2720307D308D3DCD49B6AF4C4A08D67498D2B186(IVectorView_1_t0652AC4EC7AA575BE5D7797DFD20689718705BE0** comReturnValue) IL2CPP_OVERRIDE
{
return IVector_1_GetView_m2720307D308D3DCD49B6AF4C4A08D67498D2B186_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVector_1_IndexOf_mC1E5DFCDEDC953A4E1CA8BB1C427FBE7EA517FF4(float ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVector_1_IndexOf_mC1E5DFCDEDC953A4E1CA8BB1C427FBE7EA517FF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVector_1_SetAt_m478207B3FCA7EB1D8264306765201B9B4C8725AD(uint32_t ___index0, float ___value1) IL2CPP_OVERRIDE
{
return IVector_1_SetAt_m478207B3FCA7EB1D8264306765201B9B4C8725AD_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IVector_1_InsertAt_m6C9D77B26BDE0B12FE238687DA397FC58C2032A2(uint32_t ___index0, float ___value1) IL2CPP_OVERRIDE
{
return IVector_1_InsertAt_m6C9D77B26BDE0B12FE238687DA397FC58C2032A2_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IVector_1_RemoveAt_m3EFDAC8DAF08714CB4FDF41FA54DF4EB2E0F9D97(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IVector_1_RemoveAt_m3EFDAC8DAF08714CB4FDF41FA54DF4EB2E0F9D97_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IVector_1_Append_mB47ED34CA2102C71646E947495BA9D14451E29C6(float ___value0) IL2CPP_OVERRIDE
{
return IVector_1_Append_mB47ED34CA2102C71646E947495BA9D14451E29C6_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IVector_1_RemoveAtEnd_m04EB0AD3F455408D30F0FFE3100BEB8367635CFC() IL2CPP_OVERRIDE
{
return IVector_1_RemoveAtEnd_m04EB0AD3F455408D30F0FFE3100BEB8367635CFC_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IVector_1_Clear_mE43500616C5480A63657796BB0AE2E60D7BA49A9() IL2CPP_OVERRIDE
{
return IVector_1_Clear_mE43500616C5480A63657796BB0AE2E60D7BA49A9_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IVector_1_GetMany_m436FF76C0F1FFB49549025672552A1353FEF8745(uint32_t ___startIndex0, uint32_t ___items1ArraySize, float* ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVector_1_GetMany_m436FF76C0F1FFB49549025672552A1353FEF8745_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVector_1_ReplaceAll_mF925EE20FE793EF0740B86913574AE2E17FD6B93(uint32_t ___items0ArraySize, float* ___items0) IL2CPP_OVERRIDE
{
return IVector_1_ReplaceAll_mF925EE20FE793EF0740B86913574AE2E17FD6B93_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___items0ArraySize, ___items0);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mBD8D20BBA2E9F188C15175F2C9AB4039C6400ED1(IIterator_1_t53A3C573D4888D0C268E9C0D9515A4BDAD329CCC** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mBD8D20BBA2E9F188C15175F2C9AB4039C6400ED1_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
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 IVectorView_1_GetAt_m3D2911EEE429BEE9DFCCFD08528A6B62938AE14E(uint32_t ___index0, float* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetAt_m3D2911EEE429BEE9DFCCFD08528A6B62938AE14E_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_mE51A5C7833E725EA8286E5878D80E9D44ECDFF41(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_get_Size_mE51A5C7833E725EA8286E5878D80E9D44ECDFF41_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_m4C0458BD59B3F97E792DE7EB4399297542D76C97(float ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_IndexOf_m4C0458BD59B3F97E792DE7EB4399297542D76C97_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m481FCAC8A5B7E6C75882A80893023447977DA78B(uint32_t ___startIndex0, uint32_t ___items1ArraySize, float* ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetMany_m481FCAC8A5B7E6C75882A80893023447977DA78B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IReferenceArray_1_get_Value_mDB41698A556618F72FF5F33C60E6D9B78435F619(uint32_t* comReturnValueArraySize, float** 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
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* returnValue;
try
{
returnValue = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
}
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;
}
// Marshaling of return value back from managed representation
uint32_t _returnValue_marshaledArraySize = 0;
float* _returnValue_marshaled = NULL;
if (returnValue != NULL)
{
_returnValue_marshaledArraySize = static_cast<uint32_t>((returnValue)->max_length);
_returnValue_marshaled = il2cpp_codegen_marshal_allocate_array<float>(static_cast<int32_t>(_returnValue_marshaledArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(_returnValue_marshaledArraySize)); i++)
{
(_returnValue_marshaled)[i] = (returnValue)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
*comReturnValueArraySize = _returnValue_marshaledArraySize;
*comReturnValue = _returnValue_marshaled;
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 = 1032;
}
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("SingleArray", "Byte");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16_mBE4A7DC8A2B92F83EE058AE7515E84DADFA206AE(int16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Int16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16_mCF513D800195CA7050FD5AFB4E710FB0CFB531B5(uint16_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "UInt16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32_mDE5543C20D3D3C9E773CB6EDBDBC789D12CC59BA(int32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Int32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32_mD48C2097876EAE6D1E218D9123F58F168B374205(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "UInt32");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64_m4BAC154BEC3584DF3E34EDA6033EEF3DB6D4132E(int64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Int64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64_m981379F85C0C44EDBDD830A293693BE0BB3F62CA(uint64_t* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "UInt64");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingle_mED031D57B17B0F7BD3B4B250821D070155889F1F(float* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Single");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDouble_mA0880A7E89CE09C2639D6F8065B18E8F77EB082F(double* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Double");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16_m7B2226E30F72B0CCAE54B8EDB1AC4ACF1BE860A8(Il2CppChar* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Char16");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBoolean_m21FCEEA690B32CD86A36D40FB837FC7D894D5587(bool* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Boolean");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetString_m8D5702E4E1C67366D65DA23CA2812D6572DF819C(Il2CppHString* comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "String");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuid_m885F2850B49DB4B046564BC5FE414256801D9A11(Guid_t * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Guid");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTime_m023A766ED6FC58B347CF6F777F5C18C6AE246A3C(DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "DateTime");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetTimeSpan_m063CE76264EDAF37A1DA3CA5C9CF4AF85D8FC239(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "TimeSpan");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetPoint_m014D5E859273BA28DE642E38438EDCC64AB5C41B(Point_t155CCDBE84DC37ABFA2CBB4649526701CA3A5578 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Point");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSize_m0A952D186E59BEA03E6185EDEBAC26D544AFADAC(Size_tDA924E69AB75296FE3B5E81811B78FD56173BB92 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Size");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetRect_m0A96600149C7E6A493B8420CB316938AEF9A1A06(Rect_tC45F1DDF39812623644DE296D8057A4958176627 * comReturnValue) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Rect");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt8Array_m540E0503D8CFAE2579D449884B6AA883509C79D1(uint32_t* ___value0ArraySize, uint8_t** ___value0) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726_il2cpp_TypeInfo_var);
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;
// Marshaling of parameter '___value0' to managed representation
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
____value0_empty = (ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726*)SZArrayNew(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726_il2cpp_TypeInfo_var, static_cast<uint32_t>(arrayLength));
for (il2cpp_array_size_t i = 0; i < arrayLength; i++)
{
float item = (managedArray)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
if (item < 0)
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "Byte", i);
}
try
{
uint8_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToByte_m8FAE4E8EDDF055FF2F17C2C00D091EBAA0099D49((&item), NULL, NULL);
(____value0_empty)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(i), il2cppRetVal);
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "Byte", i);
}
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "Byte", i);
}
}
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<uint8_t>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt16Array_m279C289854DE8A2D45A6B6B09112DD9D2F0DF849(uint32_t* ___value0ArraySize, int16_t** ___value0) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Int16U5BU5D_tD134F1E6F746D4C09C987436805256C210C2FFCD_il2cpp_TypeInfo_var);
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;
// Marshaling of parameter '___value0' to managed representation
Int16U5BU5D_tD134F1E6F746D4C09C987436805256C210C2FFCD* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
____value0_empty = (Int16U5BU5D_tD134F1E6F746D4C09C987436805256C210C2FFCD*)SZArrayNew(Int16U5BU5D_tD134F1E6F746D4C09C987436805256C210C2FFCD_il2cpp_TypeInfo_var, static_cast<uint32_t>(arrayLength));
for (il2cpp_array_size_t i = 0; i < arrayLength; i++)
{
float item = (managedArray)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
try
{
int16_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToInt16_mBED24FBB9C6465ABAECDC3C894F41B7CF0E6FC6A((&item), NULL, NULL);
(____value0_empty)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(i), il2cppRetVal);
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "Int16", i);
}
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "Int16", i);
}
}
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<int16_t>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt16Array_m090AA712F6BB39F869BCC5CB90236377EE8673B1(uint32_t* ___value0ArraySize, uint16_t** ___value0) 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);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&UInt16U5BU5D_t42D35C587B07DCDBCFDADF572C6D733AE85B2A67_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Marshaling of parameter '___value0' to managed representation
UInt16U5BU5D_t42D35C587B07DCDBCFDADF572C6D733AE85B2A67* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
____value0_empty = (UInt16U5BU5D_t42D35C587B07DCDBCFDADF572C6D733AE85B2A67*)SZArrayNew(UInt16U5BU5D_t42D35C587B07DCDBCFDADF572C6D733AE85B2A67_il2cpp_TypeInfo_var, static_cast<uint32_t>(arrayLength));
for (il2cpp_array_size_t i = 0; i < arrayLength; i++)
{
float item = (managedArray)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
if (item < 0)
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "UInt16", i);
}
try
{
uint16_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToUInt16_mCBB71CEDC4797B00D50B4417A96EC702076C757A((&item), NULL, NULL);
(____value0_empty)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(i), il2cppRetVal);
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "UInt16", i);
}
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "UInt16", i);
}
}
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<uint16_t>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt32Array_mADF499B8CD16185128795A7B74D63E8CFE692B9A(uint32_t* ___value0ArraySize, int32_t** ___value0) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32_il2cpp_TypeInfo_var);
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;
// Marshaling of parameter '___value0' to managed representation
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
____value0_empty = (Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32*)SZArrayNew(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32_il2cpp_TypeInfo_var, static_cast<uint32_t>(arrayLength));
for (il2cpp_array_size_t i = 0; i < arrayLength; i++)
{
float item = (managedArray)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
try
{
int32_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToInt32_mD144638A230B62184C32B38DFFFDF955353F42AC((&item), NULL, NULL);
(____value0_empty)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(i), il2cppRetVal);
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "Int32", i);
}
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "Int32", i);
}
}
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<int32_t>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt32Array_m9B44B8D2EA2907A9A96ED653ACEF04873D9483F8(uint32_t* ___value0ArraySize, uint32_t** ___value0) 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);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Marshaling of parameter '___value0' to managed representation
UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
____value0_empty = (UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF*)SZArrayNew(UInt32U5BU5D_tCF06F1E9E72E0302C762578FF5358CC523F2A2CF_il2cpp_TypeInfo_var, static_cast<uint32_t>(arrayLength));
for (il2cpp_array_size_t i = 0; i < arrayLength; i++)
{
float item = (managedArray)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
if (item < 0)
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "UInt32", i);
}
try
{
uint32_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToUInt32_mF7B0C9FE3652F3FE2E0BDEEC4B90A316099B525E((&item), NULL, NULL);
(____value0_empty)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(i), il2cppRetVal);
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "UInt32", i);
}
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "UInt32", i);
}
}
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<uint32_t>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInt64Array_m9A04AC5F477463928280B42E2C40F13B15A1D564(uint32_t* ___value0ArraySize, int64_t** ___value0) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Int64U5BU5D_tCA61E42872C63A4286B24EEE6E0650143B43DCE6_il2cpp_TypeInfo_var);
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;
// Marshaling of parameter '___value0' to managed representation
Int64U5BU5D_tCA61E42872C63A4286B24EEE6E0650143B43DCE6* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
____value0_empty = (Int64U5BU5D_tCA61E42872C63A4286B24EEE6E0650143B43DCE6*)SZArrayNew(Int64U5BU5D_tCA61E42872C63A4286B24EEE6E0650143B43DCE6_il2cpp_TypeInfo_var, static_cast<uint32_t>(arrayLength));
for (il2cpp_array_size_t i = 0; i < arrayLength; i++)
{
float item = (managedArray)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
try
{
int64_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToInt64_mAC0D1AEA698E9A358F503A77DA9C2873465E7ADC((&item), NULL, NULL);
(____value0_empty)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(i), il2cppRetVal);
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "Int64", i);
}
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "Int64", i);
}
}
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<int64_t>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetUInt64Array_m776484C9C41D5A03991D89401FF84F9D425D6A5E(uint32_t* ___value0ArraySize, uint64_t** ___value0) 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);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&UInt64U5BU5D_t7C6E32D10F47677C1CEF3C30F4E4CE95B3A633E2_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
il2cpp::vm::ScopedThreadAttacher _vmThreadHelper;
// Marshaling of parameter '___value0' to managed representation
UInt64U5BU5D_t7C6E32D10F47677C1CEF3C30F4E4CE95B3A633E2* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
____value0_empty = (UInt64U5BU5D_t7C6E32D10F47677C1CEF3C30F4E4CE95B3A633E2*)SZArrayNew(UInt64U5BU5D_t7C6E32D10F47677C1CEF3C30F4E4CE95B3A633E2_il2cpp_TypeInfo_var, static_cast<uint32_t>(arrayLength));
for (il2cpp_array_size_t i = 0; i < arrayLength; i++)
{
float item = (managedArray)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
if (item < 0)
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "UInt64", i);
}
try
{
uint64_t il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToUInt64_m6A235CB0548A46C28B13E14D5F62DEADE7887613((&item), NULL, NULL);
(____value0_empty)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(i), il2cppRetVal);
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "UInt64", i);
}
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "UInt64", i);
}
}
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<uint64_t>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetSingleArray_m1E9CE76FA942B3AFA8995FBAE605E84733917B57(uint32_t* ___value0ArraySize, float** ___value0) 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;
// Marshaling of parameter '___value0' to managed representation
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* ____value0_empty = NULL;
// Managed method invocation
try
{
____value0_empty = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<float>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDoubleArray_m5DAB086BEB4816CAF7553E325B91A4B0B07953A5(uint32_t* ___value0ArraySize, double** ___value0) IL2CPP_OVERRIDE
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&DoubleU5BU5D_t8E1B42EB2ABB79FBD193A6B8C8D97A7CDE44A4FB_il2cpp_TypeInfo_var);
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;
// Marshaling of parameter '___value0' to managed representation
DoubleU5BU5D_t8E1B42EB2ABB79FBD193A6B8C8D97A7CDE44A4FB* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
____value0_empty = (DoubleU5BU5D_t8E1B42EB2ABB79FBD193A6B8C8D97A7CDE44A4FB*)SZArrayNew(DoubleU5BU5D_t8E1B42EB2ABB79FBD193A6B8C8D97A7CDE44A4FB_il2cpp_TypeInfo_var, static_cast<uint32_t>(arrayLength));
for (il2cpp_array_size_t i = 0; i < arrayLength; i++)
{
float item = (managedArray)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
try
{
double il2cppRetVal;
il2cppRetVal = Single_System_IConvertible_ToDouble_m103B0F5DD6C36D37816B2524CCFAB7A60F9781E6((&item), NULL, NULL);
(____value0_empty)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(i), il2cppRetVal);
}
catch (const Il2CppExceptionWrapper& ex)
{
if (IsInst((RuntimeObject*)ex.ex, OverflowException_tD1FBF4E54D81EC98EEF386B69344D336D1EC1AB9_il2cpp_TypeInfo_var))
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion(Box(Single_tE07797BA3C98D4CA9B5A19413C19A76688AB899E_il2cpp_TypeInfo_var, (managedArray)->GetAddressAtUnchecked(static_cast<il2cpp_array_size_t>(i))), "SingleArray", "Single", "Double", i);
}
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "Double", i);
}
}
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<double>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetChar16Array_m2C69248F68D7705FE44FA8F777B061FA77C706A1(uint32_t* ___value0ArraySize, Il2CppChar** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Char16[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetBooleanArray_m083CB5579BC465B4D1BD84CE8382CB747A9FCC8C(uint32_t* ___value0ArraySize, bool** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Boolean[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetStringArray_m680617C6226187D28C4978B710AFBB8581AAC98F(uint32_t* ___value0ArraySize, Il2CppHString** ___value0) 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;
// Marshaling of parameter '___value0' to managed representation
StringU5BU5D_tACEBFEDE350025B554CD507C9AE8FFE49359549A* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
if (arrayLength > 0)
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "String", 0);
}
____value0_empty = NULL;
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<Il2CppHString>(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
if ((____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i)) == NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_argument_null_exception("value"), NULL);
}
(*___value0)[i] = il2cpp_codegen_create_hstring((____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i)));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetInspectableArray_m6DCBE370A8CAC129E6D6BD91C6503D14A8109F79(uint32_t* ___value0ArraySize, Il2CppIInspectable*** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "Inspectable[]");
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetGuidArray_mE9983D9B5EE9AC1935C3EBD2F9E82DC7188E1D07(uint32_t* ___value0ArraySize, Guid_t ** ___value0) 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;
// Marshaling of parameter '___value0' to managed representation
GuidU5BU5D_t6DCED1B9FC5592C43FAA73D81705104BD18151B8* ____value0_empty = NULL;
// Managed method invocation
try
{
SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA* managedArray = static_cast<SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA*>(GetManagedObjectInline());
il2cpp_array_size_t arrayLength = managedArray->max_length;
if (arrayLength > 0)
{
return il2cpp_codegen_com_handle_invalid_ipropertyarray_conversion("SingleArray", "Single", "Guid", 0);
}
____value0_empty = NULL;
}
catch (const Il2CppExceptionWrapper& ex)
{
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;
}
// Marshaling of parameter '___value0' back from managed representation
if (____value0_empty != NULL)
{
*___value0ArraySize = static_cast<uint32_t>((____value0_empty)->max_length);
*___value0 = il2cpp_codegen_marshal_allocate_array<Guid_t >(static_cast<int32_t>(*___value0ArraySize));
for (int32_t i = 0; i < ARRAY_LENGTH_AS_INT32(static_cast<int32_t>(*___value0ArraySize)); i++)
{
(*___value0)[i] = (____value0_empty)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(i));
}
}
else
{
*___value0ArraySize = 0;
*___value0 = NULL;
}
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL IPropertyValue_GetDateTimeArray_mEECFC6C321405CDBC425D321E2A8EF3E7BC306A7(uint32_t* ___value0ArraySize, DateTime_t7C967DBDDE4CAEAA8B5AEB61E36309BCD7D26B8C ** ___value0) IL2CPP_OVERRIDE
{
return il2cpp_codegen_com_handle_invalid_iproperty_conversion("SingleArray", "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("SingleArray", "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("SingleArray", "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("SingleArray", "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("SingleArray", "Rect[]");
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SingleU5BU5D_t47E8DBF5B597C122478D1FFBD9DD57399A0650FA_ComCallableWrapper(obj));
}
// COM Callable Wrapper for SiteOverviewTurbineButton[]
struct SiteOverviewTurbineButtonU5BU5D_t3ACBCC0C5A7D36AFE732F05FFE492AA4B8CCCF5C_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SiteOverviewTurbineButtonU5BU5D_t3ACBCC0C5A7D36AFE732F05FFE492AA4B8CCCF5C_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SiteOverviewTurbineButtonU5BU5D_t3ACBCC0C5A7D36AFE732F05FFE492AA4B8CCCF5C_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SiteOverviewTurbineButtonU5BU5D_t3ACBCC0C5A7D36AFE732F05FFE492AA4B8CCCF5C_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, &IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[2] = IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID;
interfaceIds[3] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1(uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SiteOverviewTurbineButtonU5BU5D_t3ACBCC0C5A7D36AFE732F05FFE492AA4B8CCCF5C(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SiteOverviewTurbineButtonU5BU5D_t3ACBCC0C5A7D36AFE732F05FFE492AA4B8CCCF5C_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SiteOverviewTurbineButtonU5BU5D_t3ACBCC0C5A7D36AFE732F05FFE492AA4B8CCCF5C_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.Utilities.Solvers.Solver[]
struct SolverU5BU5D_t7D4E8D7D33AE0E86ADE266E97543F909C6A9D1B6_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SolverU5BU5D_t7D4E8D7D33AE0E86ADE266E97543F909C6A9D1B6_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SolverU5BU5D_t7D4E8D7D33AE0E86ADE266E97543F909C6A9D1B6_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SolverU5BU5D_t7D4E8D7D33AE0E86ADE266E97543F909C6A9D1B6_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, &IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[2] = IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID;
interfaceIds[3] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1(uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SolverU5BU5D_t7D4E8D7D33AE0E86ADE266E97543F909C6A9D1B6(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SolverU5BU5D_t7D4E8D7D33AE0E86ADE266E97543F909C6A9D1B6_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SolverU5BU5D_t7D4E8D7D33AE0E86ADE266E97543F909C6A9D1B6_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessMeshObject[]
struct SpatialAwarenessMeshObjectU5BU5D_tA94B023FDD95287C601B9EC531C41DA60D5D0C5A_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SpatialAwarenessMeshObjectU5BU5D_tA94B023FDD95287C601B9EC531C41DA60D5D0C5A_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SpatialAwarenessMeshObjectU5BU5D_tA94B023FDD95287C601B9EC531C41DA60D5D0C5A_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SpatialAwarenessMeshObjectU5BU5D_tA94B023FDD95287C601B9EC531C41DA60D5D0C5A_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, &IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[2] = IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID;
interfaceIds[3] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1(uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SpatialAwarenessMeshObjectU5BU5D_tA94B023FDD95287C601B9EC531C41DA60D5D0C5A(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SpatialAwarenessMeshObjectU5BU5D_tA94B023FDD95287C601B9EC531C41DA60D5D0C5A_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SpatialAwarenessMeshObjectU5BU5D_tA94B023FDD95287C601B9EC531C41DA60D5D0C5A_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.SpatialAwareness.SpatialAwarenessPlanarObject[]
struct SpatialAwarenessPlanarObjectU5BU5D_t772A69ED777B1C864FC824CA32DA58CA28AC6743_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SpatialAwarenessPlanarObjectU5BU5D_t772A69ED777B1C864FC824CA32DA58CA28AC6743_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SpatialAwarenessPlanarObjectU5BU5D_t772A69ED777B1C864FC824CA32DA58CA28AC6743_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SpatialAwarenessPlanarObjectU5BU5D_t772A69ED777B1C864FC824CA32DA58CA28AC6743_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, &IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[2] = IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID;
interfaceIds[3] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1(uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SpatialAwarenessPlanarObjectU5BU5D_t772A69ED777B1C864FC824CA32DA58CA28AC6743(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SpatialAwarenessPlanarObjectU5BU5D_t772A69ED777B1C864FC824CA32DA58CA28AC6743_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SpatialAwarenessPlanarObjectU5BU5D_t772A69ED777B1C864FC824CA32DA58CA28AC6743_ComCallableWrapper(obj));
}
// COM Callable Wrapper for Microsoft.MixedReality.Toolkit.Experimental.SpatialAwareness.SpatialAwarenessSceneObject[]
struct SpatialAwarenessSceneObjectU5BU5D_t6F70086B6848AB4D5DA4B5454581DCEA06A370E3_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SpatialAwarenessSceneObjectU5BU5D_t6F70086B6848AB4D5DA4B5454581DCEA06A370E3_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SpatialAwarenessSceneObjectU5BU5D_t6F70086B6848AB4D5DA4B5454581DCEA06A370E3_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SpatialAwarenessSceneObjectU5BU5D_t6F70086B6848AB4D5DA4B5454581DCEA06A370E3_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, &IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[2] = IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID;
interfaceIds[3] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1(uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SpatialAwarenessSceneObjectU5BU5D_t6F70086B6848AB4D5DA4B5454581DCEA06A370E3(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SpatialAwarenessSceneObjectU5BU5D_t6F70086B6848AB4D5DA4B5454581DCEA06A370E3_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SpatialAwarenessSceneObjectU5BU5D_t6F70086B6848AB4D5DA4B5454581DCEA06A370E3_ComCallableWrapper(obj));
}
// COM Callable Wrapper for UnityEngine.Sprite[]
struct SpriteU5BU5D_t8DB77E112FFC97B722E701189DCB4059F943FD77_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SpriteU5BU5D_t8DB77E112FFC97B722E701189DCB4059F943FD77_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SpriteU5BU5D_t8DB77E112FFC97B722E701189DCB4059F943FD77_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SpriteU5BU5D_t8DB77E112FFC97B722E701189DCB4059F943FD77_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, &IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[2] = IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID;
interfaceIds[3] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1(uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SpriteU5BU5D_t8DB77E112FFC97B722E701189DCB4059F943FD77(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SpriteU5BU5D_t8DB77E112FFC97B722E701189DCB4059F943FD77_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SpriteU5BU5D_t8DB77E112FFC97B722E701189DCB4059F943FD77_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlBinary[]
struct SqlBinaryU5BU5D_t4A1CD2FDEEC6E9EAEC15A8C28A7701484B8D4485_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlBinaryU5BU5D_t4A1CD2FDEEC6E9EAEC15A8C28A7701484B8D4485_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlBinaryU5BU5D_t4A1CD2FDEEC6E9EAEC15A8C28A7701484B8D4485_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlBinaryU5BU5D_t4A1CD2FDEEC6E9EAEC15A8C28A7701484B8D4485_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlBinaryU5BU5D_t4A1CD2FDEEC6E9EAEC15A8C28A7701484B8D4485(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlBinaryU5BU5D_t4A1CD2FDEEC6E9EAEC15A8C28A7701484B8D4485_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlBinaryU5BU5D_t4A1CD2FDEEC6E9EAEC15A8C28A7701484B8D4485_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlBoolean[]
struct SqlBooleanU5BU5D_t07B79EADC41ED65294851549545D3F3918FDC6A0_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlBooleanU5BU5D_t07B79EADC41ED65294851549545D3F3918FDC6A0_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlBooleanU5BU5D_t07B79EADC41ED65294851549545D3F3918FDC6A0_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlBooleanU5BU5D_t07B79EADC41ED65294851549545D3F3918FDC6A0_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlBooleanU5BU5D_t07B79EADC41ED65294851549545D3F3918FDC6A0(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlBooleanU5BU5D_t07B79EADC41ED65294851549545D3F3918FDC6A0_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlBooleanU5BU5D_t07B79EADC41ED65294851549545D3F3918FDC6A0_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlByte[]
struct SqlByteU5BU5D_tB403A2418F730327A0789B78506CDACCECBB4CB6_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlByteU5BU5D_tB403A2418F730327A0789B78506CDACCECBB4CB6_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlByteU5BU5D_tB403A2418F730327A0789B78506CDACCECBB4CB6_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlByteU5BU5D_tB403A2418F730327A0789B78506CDACCECBB4CB6_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlByteU5BU5D_tB403A2418F730327A0789B78506CDACCECBB4CB6(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlByteU5BU5D_tB403A2418F730327A0789B78506CDACCECBB4CB6_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlByteU5BU5D_tB403A2418F730327A0789B78506CDACCECBB4CB6_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlBytes[]
struct SqlBytesU5BU5D_t6F60DB18D1E498C69C2A2A292075B88252A47C49_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlBytesU5BU5D_t6F60DB18D1E498C69C2A2A292075B88252A47C49_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlBytesU5BU5D_t6F60DB18D1E498C69C2A2A292075B88252A47C49_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlBytesU5BU5D_t6F60DB18D1E498C69C2A2A292075B88252A47C49_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, &IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[2] = IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID;
interfaceIds[3] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1(uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlBytesU5BU5D_t6F60DB18D1E498C69C2A2A292075B88252A47C49(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlBytesU5BU5D_t6F60DB18D1E498C69C2A2A292075B88252A47C49_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlBytesU5BU5D_t6F60DB18D1E498C69C2A2A292075B88252A47C49_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlChars[]
struct SqlCharsU5BU5D_t20FD646DC66170A3025ACFD16C890584136139FC_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlCharsU5BU5D_t20FD646DC66170A3025ACFD16C890584136139FC_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlCharsU5BU5D_t20FD646DC66170A3025ACFD16C890584136139FC_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlCharsU5BU5D_t20FD646DC66170A3025ACFD16C890584136139FC_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, &IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(4);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
interfaceIds[2] = IVectorView_1_t9D427951F2D09C2E6F846759B5273E993F185D4A::IID;
interfaceIds[3] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID;
*iidCount = 4;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetAt_m38CCDDE1E25317AEF5170D9818FC01816AF34260_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_get_Size_m33BC340C458F20A80A8B07FF4764CEF1F5513F8B_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_IndexOf_mFAE432DA0C1902EEF54AB68CFFD3E2182C443F67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1(uint32_t ___startIndex0, uint32_t ___items1ArraySize, Il2CppIInspectable** ___items1, uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IVectorView_1_GetMany_m6AA46969FB50015EB7107EBCC29E48B7AD4BB6B1_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___startIndex0, ___items1ArraySize, ___items1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlCharsU5BU5D_t20FD646DC66170A3025ACFD16C890584136139FC(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlCharsU5BU5D_t20FD646DC66170A3025ACFD16C890584136139FC_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlCharsU5BU5D_t20FD646DC66170A3025ACFD16C890584136139FC_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlDateTime[]
struct SqlDateTimeU5BU5D_t12EEE5C7616A30E9F9CE304F76B5912B2A47EABF_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlDateTimeU5BU5D_t12EEE5C7616A30E9F9CE304F76B5912B2A47EABF_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlDateTimeU5BU5D_t12EEE5C7616A30E9F9CE304F76B5912B2A47EABF_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlDateTimeU5BU5D_t12EEE5C7616A30E9F9CE304F76B5912B2A47EABF_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlDateTimeU5BU5D_t12EEE5C7616A30E9F9CE304F76B5912B2A47EABF(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlDateTimeU5BU5D_t12EEE5C7616A30E9F9CE304F76B5912B2A47EABF_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlDateTimeU5BU5D_t12EEE5C7616A30E9F9CE304F76B5912B2A47EABF_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlDecimal[]
struct SqlDecimalU5BU5D_t436F1578CFBAD13111599A27A32FB894D8307CBD_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlDecimalU5BU5D_t436F1578CFBAD13111599A27A32FB894D8307CBD_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlDecimalU5BU5D_t436F1578CFBAD13111599A27A32FB894D8307CBD_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlDecimalU5BU5D_t436F1578CFBAD13111599A27A32FB894D8307CBD_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlDecimalU5BU5D_t436F1578CFBAD13111599A27A32FB894D8307CBD(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlDecimalU5BU5D_t436F1578CFBAD13111599A27A32FB894D8307CBD_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlDecimalU5BU5D_t436F1578CFBAD13111599A27A32FB894D8307CBD_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlDouble[]
struct SqlDoubleU5BU5D_t65F627E3E10E5B61B332C69E3E8180BB1B5C5EA7_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlDoubleU5BU5D_t65F627E3E10E5B61B332C69E3E8180BB1B5C5EA7_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlDoubleU5BU5D_t65F627E3E10E5B61B332C69E3E8180BB1B5C5EA7_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlDoubleU5BU5D_t65F627E3E10E5B61B332C69E3E8180BB1B5C5EA7_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlDoubleU5BU5D_t65F627E3E10E5B61B332C69E3E8180BB1B5C5EA7(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlDoubleU5BU5D_t65F627E3E10E5B61B332C69E3E8180BB1B5C5EA7_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlDoubleU5BU5D_t65F627E3E10E5B61B332C69E3E8180BB1B5C5EA7_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlGuid[]
struct SqlGuidU5BU5D_t7B958D75216823CC6FD381B81133477AFD2DE5E2_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlGuidU5BU5D_t7B958D75216823CC6FD381B81133477AFD2DE5E2_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlGuidU5BU5D_t7B958D75216823CC6FD381B81133477AFD2DE5E2_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlGuidU5BU5D_t7B958D75216823CC6FD381B81133477AFD2DE5E2_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlGuidU5BU5D_t7B958D75216823CC6FD381B81133477AFD2DE5E2(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlGuidU5BU5D_t7B958D75216823CC6FD381B81133477AFD2DE5E2_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlGuidU5BU5D_t7B958D75216823CC6FD381B81133477AFD2DE5E2_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlInt16[]
struct SqlInt16U5BU5D_tFDBC98064CCDBA5EF1A928770767FF5E428F68B0_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlInt16U5BU5D_tFDBC98064CCDBA5EF1A928770767FF5E428F68B0_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlInt16U5BU5D_tFDBC98064CCDBA5EF1A928770767FF5E428F68B0_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlInt16U5BU5D_tFDBC98064CCDBA5EF1A928770767FF5E428F68B0_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlInt16U5BU5D_tFDBC98064CCDBA5EF1A928770767FF5E428F68B0(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlInt16U5BU5D_tFDBC98064CCDBA5EF1A928770767FF5E428F68B0_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlInt16U5BU5D_tFDBC98064CCDBA5EF1A928770767FF5E428F68B0_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlInt32[]
struct SqlInt32U5BU5D_t4E9A0DCCD18A21ED32AE342EE7288F4722D13002_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlInt32U5BU5D_t4E9A0DCCD18A21ED32AE342EE7288F4722D13002_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlInt32U5BU5D_t4E9A0DCCD18A21ED32AE342EE7288F4722D13002_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlInt32U5BU5D_t4E9A0DCCD18A21ED32AE342EE7288F4722D13002_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlInt32U5BU5D_t4E9A0DCCD18A21ED32AE342EE7288F4722D13002(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlInt32U5BU5D_t4E9A0DCCD18A21ED32AE342EE7288F4722D13002_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlInt32U5BU5D_t4E9A0DCCD18A21ED32AE342EE7288F4722D13002_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlInt64[]
struct SqlInt64U5BU5D_t07215C71C5947E0BE4CF431CB6124BC53ADA28C5_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlInt64U5BU5D_t07215C71C5947E0BE4CF431CB6124BC53ADA28C5_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlInt64U5BU5D_t07215C71C5947E0BE4CF431CB6124BC53ADA28C5_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlInt64U5BU5D_t07215C71C5947E0BE4CF431CB6124BC53ADA28C5_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlInt64U5BU5D_t07215C71C5947E0BE4CF431CB6124BC53ADA28C5(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlInt64U5BU5D_t07215C71C5947E0BE4CF431CB6124BC53ADA28C5_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlInt64U5BU5D_t07215C71C5947E0BE4CF431CB6124BC53ADA28C5_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlMoney[]
struct SqlMoneyU5BU5D_tF5702E9AA3B2D27362711637FFD105D198723C95_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlMoneyU5BU5D_tF5702E9AA3B2D27362711637FFD105D198723C95_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlMoneyU5BU5D_tF5702E9AA3B2D27362711637FFD105D198723C95_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlMoneyU5BU5D_tF5702E9AA3B2D27362711637FFD105D198723C95_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlMoneyU5BU5D_tF5702E9AA3B2D27362711637FFD105D198723C95(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlMoneyU5BU5D_tF5702E9AA3B2D27362711637FFD105D198723C95_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlMoneyU5BU5D_tF5702E9AA3B2D27362711637FFD105D198723C95_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Data.SqlTypes.SqlSingle[]
struct SqlSingleU5BU5D_t2F81D199741A89C70F73D8FAC1385A28379B442F_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<SqlSingleU5BU5D_t2F81D199741A89C70F73D8FAC1385A28379B442F_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8, IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC
{
inline SqlSingleU5BU5D_t2F81D199741A89C70F73D8FAC1385A28379B442F_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<SqlSingleU5BU5D_t2F81D199741A89C70F73D8FAC1385A28379B442F_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, &IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC*>(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] = IBindableVector_tC070A96258CD93818901E9B7808E1A8EFB64B7EC::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 IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED(uint32_t ___index0, Il2CppIInspectable** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetAt_m33D2170810828C01473D9BDC22745A0354FA4FED_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9(uint32_t* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_get_Size_m45347BCD42A1FE180ED2B377BB9C88C7B50CD7D9_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38(IBindableVectorView_tD80A01049DD2609FEA5FACD5E77BF95A875534FA** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_GetView_m9736FE93BC8979E0CBF8ED26090D1FE54C2E1A38_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4(Il2CppIInspectable* ___value0, uint32_t* ___index1, bool* comReturnValue) IL2CPP_OVERRIDE
{
return IBindableVector_IndexOf_m2F1A64750D19C5A03E9B65880F4A04275E6AABF4_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0, ___index1, comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_SetAt_mD4C84EC02EAD7F636873B77E6D48E7132055A213_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5(uint32_t ___index0, Il2CppIInspectable* ___value1) IL2CPP_OVERRIDE
{
return IBindableVector_InsertAt_m19A0C885F7C7A7FFA257A46218D7232317E022B5_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0, ___value1);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0(uint32_t ___index0) IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAt_m1AC6E54165809374E91F456B9922A9B24F8652B0_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___index0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F(Il2CppIInspectable* ___value0) IL2CPP_OVERRIDE
{
return IBindableVector_Append_mCA138F8E4026725AC867B607FA63709B6752BB7F_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), ___value0);
}
virtual il2cpp_hresult_t STDCALL IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3() IL2CPP_OVERRIDE
{
return IBindableVector_RemoveAtEnd_mB3178911995D4CC7BAC0EA43720C1280267E54E3_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
virtual il2cpp_hresult_t STDCALL IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF() IL2CPP_OVERRIDE
{
return IBindableVector_Clear_mEF05B40EFF6D42CBB5A5E336B0946FECE7A4A6EF_ComCallableWrapperProjectedMethod(GetManagedObjectInline());
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_SqlSingleU5BU5D_t2F81D199741A89C70F73D8FAC1385A28379B442F(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(SqlSingleU5BU5D_t2F81D199741A89C70F73D8FAC1385A28379B442F_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) SqlSingleU5BU5D_t2F81D199741A89C70F73D8FAC1385A28379B442F_ComCallableWrapper(obj));
}
| 47.580769
| 600
| 0.841349
|
JBrentJ
|
7a485db2e1678c0e06a1bbfa4a4f9ba6adadb7a9
| 589
|
cpp
|
C++
|
DataStructure/c++/heap/loveBabbarDsSheet/BST-to-Maxheap.cpp
|
subhamengine/DataStructures-and-Algorithm
|
582f2f724a8dd5b42703c9f02d3934a85679c9b7
|
[
"MIT"
] | 17
|
2021-09-13T14:50:29.000Z
|
2022-01-07T10:53:35.000Z
|
DataStructure/c++/heap/loveBabbarDsSheet/BST-to-Maxheap.cpp
|
subhamengine/DataStructures-and-Algorithm
|
582f2f724a8dd5b42703c9f02d3934a85679c9b7
|
[
"MIT"
] | 15
|
2021-10-01T04:13:32.000Z
|
2021-11-05T07:49:55.000Z
|
DataStructure/c++/heap/loveBabbarDsSheet/BST-to-Maxheap.cpp
|
subhamengine/DataStructures-and-Algorithm
|
582f2f724a8dd5b42703c9f02d3934a85679c9b7
|
[
"MIT"
] | 11
|
2021-09-23T14:37:03.000Z
|
2021-11-04T13:22:17.000Z
|
class Solution{
queue<int>q;
public:
void dfs(Node* root){
if(root==NULL)
return;
dfs(root->right);
q.push(root->data); // storing in descending order
dfs(root->left);
}
void solver(Node* root){
if(root==NULL)
return;
int val=q.front();
q.pop();
root->data=val; // putting the values according to defintion of the problem
solver(root->right);
solver(root->left);
}
void convertToMaxHeapUtil(Node* root)
{
dfs(root);
solver(root);
}
| 22.653846
| 83
| 0.519525
|
subhamengine
|
7a4f1987cc45d811df02e14c08a30b9e23a9a866
| 29,931
|
cpp
|
C++
|
inetsrv/iis/svcs/cmp/asp/server.cpp
|
npocmaka/Windows-Server-2003
|
5c6fe3db626b63a384230a1aa6b92ac416b0765f
|
[
"Unlicense"
] | 17
|
2020-11-13T13:42:52.000Z
|
2021-09-16T09:13:13.000Z
|
inetsrv/iis/svcs/cmp/asp/server.cpp
|
sancho1952007/Windows-Server-2003
|
5c6fe3db626b63a384230a1aa6b92ac416b0765f
|
[
"Unlicense"
] | 2
|
2020-10-19T08:02:06.000Z
|
2020-10-19T08:23:18.000Z
|
inetsrv/iis/svcs/cmp/asp/server.cpp
|
sancho1952007/Windows-Server-2003
|
5c6fe3db626b63a384230a1aa6b92ac416b0765f
|
[
"Unlicense"
] | 14
|
2020-11-14T09:43:20.000Z
|
2021-08-28T08:59:57.000Z
|
/*===================================================================
Microsoft Denali
Microsoft Confidential.
Copyright 1996 Microsoft Corporation. All Rights Reserved.
Component: Server object
File: Server.cpp
Owner: CGrant
This file contains the code for the implementation of the Server object.
===================================================================*/
#include "denpre.h"
#pragma hdrstop
#include "Server.h"
#include "tlbcache.h"
#include "memchk.h"
/*
*
* C S e r v e r
*
*/
/*===================================================================
CServer::CServer
Constructor
Parameters:
punkOuter object to ref count (can be NULL)
Returns:
===================================================================*/
CServer::CServer(IUnknown *punkOuter)
:
m_fInited(FALSE),
m_fDiagnostics(FALSE),
m_pUnkFTM(NULL),
m_pData(NULL)
{
CDispatch::Init(IID_IServer);
if (punkOuter)
{
m_punkOuter = punkOuter;
m_fOuterUnknown = TRUE;
}
else
{
m_cRefs = 1;
m_fOuterUnknown = FALSE;
}
#ifdef DBG
m_fDiagnostics = TRUE;
#endif // DBG
}
/*===================================================================
CServer::~CServer
Destructor
Parameters:
Returns:
===================================================================*/
CServer::~CServer()
{
Assert(!m_fInited);
Assert(m_fOuterUnknown || m_cRefs == 0); // must have 0 ref count
if ( m_pUnkFTM != NULL )
{
m_pUnkFTM->Release();
m_pUnkFTM = NULL;
}
}
/*===================================================================
CServer::Init
Allocates m_pData.
Performs any intiailization of a CServer that's prone to failure
that we also use internally before exposing the object outside.
Parameters:
None
Returns:
S_OK on success.
===================================================================*/
HRESULT CServer::Init()
{
HRESULT hr = S_OK;
if (m_fInited)
return S_OK; // already inited
Assert(!m_pData);
// Create the FTM
if (m_pUnkFTM == NULL)
{
hr = CoCreateFreeThreadedMarshaler( (IUnknown*)this, &m_pUnkFTM );
if ( FAILED(hr) )
{
Assert( m_pUnkFTM == NULL );
return (hr);
}
}
Assert( m_pUnkFTM != NULL );
m_pData = new CServerData;
if (!m_pData)
return E_OUTOFMEMORY;
m_pData->m_pIReq = NULL;
m_pData->m_pHitObj = NULL;
m_pData->m_ISupportErrImp.Init(static_cast<IServer *>(this),
static_cast<IServer *>(this),
IID_IServer);
m_fInited = TRUE;
return hr;
}
/*===================================================================
CServer::UnInit
Remove m_pData. Make tombstone (UnInited state).
Parameters:
Returns:
HRESULT (S_OK)
===================================================================*/
HRESULT CServer::UnInit()
{
if (!m_fInited)
return S_OK; // already uninited
Assert(m_pData);
delete m_pData;
m_pData = NULL;
// Disconnect proxies NOW (in case we are in shutdown, or enter shutdown later & a proxy has a ref.)
CoDisconnectObject(static_cast<IServerImpl *>(this), 0);
m_fInited = FALSE;
return S_OK;
}
/*===================================================================
CServer::ReInit
The only need for a re-init here is to update the CIsapiReqInfo
for this request, the CIsapiReqInfo is required to access the
MapPath Method. Ideally this method should be part of the Request
object
Parameters:
CIsapiReqInfo *
CHitObj *
Returns:
S_OK on success.
===================================================================*/
HRESULT CServer::ReInit
(
CIsapiReqInfo * pIReq,
CHitObj *pHitObj
)
{
Assert(m_fInited);
Assert(m_pData);
m_pData->m_pIReq = pIReq;
m_pData->m_pHitObj = pHitObj;
return S_OK;
}
/*===================================================================
CServer::MapPathInternal
Map virtual path BSTR into single char buffer
Used by MapPath(), Execute(), Transfer()
Parameters:
dwContextId for error messages
wszVirtPath path to translate
szPhysPath [out] translate into this buffer (MAX_PATH sized)
szVirtPath [out, optional] mb virtual path buffer (MAX_PATH sized)
Returns:
S_OK on success.
===================================================================*/
HRESULT CServer::MapPathInternal
(
DWORD dwContextId,
WCHAR *wszVirtPath,
TCHAR *szPhysPath,
TCHAR *szVirtPath
)
{
// increment the pointer past leading white spaces
wchar_t *wszLogicalPath = wszVirtPath;
while (iswspace(*wszLogicalPath))
++wszLogicalPath;
unsigned cchLogicalPath = wcslen(wszLogicalPath);
if (cchLogicalPath > MAX_PATH-1)
{
if (dwContextId)
ExceptionId(IID_IServer, dwContextId, IDE_SERVER_EXCEDED_MAX_PATH);
return E_FAIL;
}
else if (cchLogicalPath == 0)
{
if (dwContextId)
ExceptionId(IID_IServer, dwContextId, IDE_SERVER_MAPPATH_INVALID_STR);
return E_FAIL;
}
// Is this a physical path?
if (iswalpha(wszLogicalPath[0]) && wszLogicalPath[1] == L':')
{
if (dwContextId)
ExceptionId(IID_IServer, dwContextId, IDE_SERVER_MAPPATH_PHY_STR);
return E_FAIL;
}
// simple validation: look for invalid characters in string [*?<>,;:'"]
// and multiple slash characters ie "//" or "\\"
//
BOOL fParentPath = FALSE;
BOOL fEnableParentPaths = m_pData->m_pHitObj->QueryAppConfig()->fEnableParentPaths();
BOOL fAnyBackslashes = FALSE;
wchar_t *pwchT = wszLogicalPath;
while (*pwchT != L'\0')
{
switch (*pwchT)
{
case L'*': case L':': case L'?': case L'<':
case L'>': case L',': case L'"':
if (dwContextId)
ExceptionId( IID_IServer, dwContextId, IDE_SERVER_MAPPATH_INVALID_CHR);
return E_FAIL;
case L'.':
if (*++pwchT == L'.')
{
if (!fEnableParentPaths)
{
if (dwContextId)
ExceptionId(IID_IServer, dwContextId, IDE_SERVER_MAPPATH_INVALID_CHR3);
return E_FAIL;
}
else
{
fParentPath = TRUE;
++pwchT;
}
}
break;
case L'\\':
fAnyBackslashes = TRUE;
case L'/':
++pwchT;
if (*pwchT == L'/' || *pwchT == L'\\')
{
if (dwContextId)
ExceptionId(IID_IServer, dwContextId, IDE_SERVER_MAPPATH_INVALID_CHR2);
return E_FAIL;
}
break;
default:
++pwchT;
}
}
// whew! Error handling done!
// Convert wszLogicalPath to multi-byte
TCHAR szLogicalPath[MAX_PATH];
#if UNICODE
wcscpy(szLogicalPath, wszLogicalPath);
#else
HRESULT hr;
CWCharToMBCS convStr;
if (hr = convStr.Init(wszLogicalPath)) {
if ((hr == E_OUTOFMEMORY) && dwContextId)
ExceptionId(IID_IServer, dwContextId, IDE_OOM);
return hr;
}
if (convStr.GetStringLen() > (MAX_PATH-1)) {
if (dwContextId)
ExceptionId(IID_IServer, dwContextId, IDE_SERVER_EXCEDED_MAX_PATH);
return E_FAIL;
}
strcpy(szLogicalPath,convStr.GetString());
#endif
// change all backslashes to forward slashes
if (fAnyBackslashes)
{
TCHAR *pbBackslash = szLogicalPath;
while (pbBackslash = _tcschr(pbBackslash, _T('\\')))
*pbBackslash = _T('/');
}
// is this a Relative path request. I.E. no leading slash
// if so prepend the path_info string to szLogicalPath
BOOL fPathAlreadyIsMapped = FALSE; // Some cases map the path earlier
if (szLogicalPath[0] != _T('/'))
{
if (_tcslen(m_pData->m_pIReq->QueryPszPathInfo()) >= MAX_PATH)
{
if (dwContextId)
ExceptionId(IID_IServer, dwContextId, IDE_SERVER_EXCEDED_MAX_PATH);
return E_FAIL;
}
TCHAR szParentPath[MAX_PATH];
_tcscpy(szParentPath, m_pData->m_pIReq->QueryPszPathInfo());
szParentPath[MAX_PATH-1] = _T('\0');
// Trim off the ASP file name from the PATH_INFO
TCHAR *pchT = _tcsrchr(szParentPath, _T('/'));
if (pchT != NULL) *pchT = '\0';
// If there were parent paths, map the parent now, then append the relative path
// the relative path to the parent path
if (fParentPath)
{
Assert (fEnableParentPaths); // Errors should have been flagged upstairs
DWORD dwPathSize = sizeof(szParentPath);
if (! m_pData->m_pIReq->MapUrlToPath(szParentPath, &dwPathSize))
{
if (dwContextId)
ExceptionId(IID_IServer,
dwContextId,
::GetLastError() == ERROR_INSUFFICIENT_BUFFER? IDE_SERVER_EXCEDED_MAX_PATH : IDE_SERVER_MAPPATH_FAILED);
return E_FAIL;
}
fPathAlreadyIsMapped = TRUE;
}
// Resolve relative paths
if (! DotPathToPath(szLogicalPath, szLogicalPath, szParentPath))
{
if (dwContextId)
ExceptionId(IID_IServer, dwContextId, IDE_SERVER_MAPPATH_FAILED);
return E_FAIL;
}
}
// return virtual path if requested
if (szVirtPath)
_tcscpy(szVirtPath, szLogicalPath);
// Map this to a physical file name (if required)
if (!fPathAlreadyIsMapped)
{
DWORD dwPathSize = sizeof(szLogicalPath);
if (! m_pData->m_pIReq->MapUrlToPath(szLogicalPath, &dwPathSize))
{
if (dwContextId)
ExceptionId(IID_IServer,
dwContextId,
::GetLastError() == ERROR_INSUFFICIENT_BUFFER? IDE_SERVER_EXCEDED_MAX_PATH : IDE_SERVER_MAPPATH_FAILED);
return E_FAIL;
}
}
// remove any ending delimiters (unless it's the root directory. The root always starts with drive letter)
TCHAR *pchT = CharPrev(szLogicalPath, szLogicalPath + _tcslen(szLogicalPath));
if ((*pchT == _T('/') || *pchT == _T('\\')) && pchT[-1] != _T(':'))
{
*pchT = _T('\0');
}
// Replace forward slash with back slash
for (pchT = szLogicalPath; *pchT != _T('\0'); ++pchT)
{
if (*pchT == _T('/'))
*pchT = _T('\\');
}
_tcscpy(szPhysPath, szLogicalPath);
return S_OK;
}
/*===================================================================
CServer::QueryInterface
CServer::AddRef
CServer::Release
IUnknown members for CServer object.
===================================================================*/
STDMETHODIMP CServer::QueryInterface
(
REFIID riid,
PPVOID ppv
)
{
*ppv = NULL;
/*
* The only calls for IUnknown are either in a nonaggregated
* case or when created in an aggregation, so in either case
* always return our IUnknown for IID_IUnknown.
*/
// BUG FIX 683 added IID_IDenaliIntrinsic to prevent the user from
// storing intrinsic objects in the application and session object
if (IID_IUnknown == riid ||
IID_IDispatch == riid ||
IID_IServer == riid ||
IID_IDenaliIntrinsic == riid)
*ppv = static_cast<IServer *>(this);
//Indicate that we support error information
if (IID_ISupportErrorInfo == riid)
{
if (m_pData)
*ppv = & (m_pData->m_ISupportErrImp);
}
if (IID_IMarshal == riid)
{
Assert( m_pUnkFTM != NULL );
if ( m_pUnkFTM == NULL )
{
return E_UNEXPECTED;
}
return m_pUnkFTM->QueryInterface( riid, ppv );
}
//AddRef any interface we'll return.
if (NULL != *ppv)
{
((LPUNKNOWN)*ppv)->AddRef();
return S_OK;
}
return E_NOINTERFACE;
}
STDMETHODIMP_(ULONG) CServer::AddRef()
{
if (m_fOuterUnknown)
return m_punkOuter->AddRef();
return InterlockedIncrement((LPLONG)&m_cRefs);
}
STDMETHODIMP_(ULONG) CServer::Release()
{
if (m_fOuterUnknown)
return m_punkOuter->Release();
DWORD cRefs = InterlockedDecrement((LPLONG)&m_cRefs);
if (cRefs)
return cRefs;
delete this;
return 0;
}
/*===================================================================
CServer::GetIDsOfNames
Special-case implementation for CreateObject, Execute, Transfer
Parameters:
riid REFIID reserved. Must be IID_NULL.
rgszNames OLECHAR ** pointing to the array of names to be mapped.
cNames UINT number of names to be mapped.
lcid LCID of the locale.
rgDispID DISPID * caller allocated array containing IDs
corresponging to those names in rgszNames.
Return Value:
HRESULT S_OK or a general error code.
===================================================================*/
STDMETHODIMP CServer::GetIDsOfNames
(
REFIID riid,
OLECHAR **rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispID
)
{
const DISPID dispidCreateObject = 0x60020002;
const DISPID dispidExecute = 0x60020007;
const DISPID dispidTransfer = 0x60020008;
if (cNames == 1)
{
switch (rgszNames[0][0])
{
case L'C':
case L'c':
if (wcsicmp(rgszNames[0]+1, L"reateobject") == 0)
{
*rgDispID = dispidCreateObject;
return S_OK;
}
break;
case L'E':
case L'e':
if (wcsicmp(rgszNames[0]+1, L"xecute") == 0)
{
*rgDispID = dispidExecute;
return S_OK;
}
break;
case L'T':
case L't':
if (wcsicmp(rgszNames[0]+1, L"ransfer") == 0)
{
*rgDispID = dispidTransfer;
return S_OK;
}
break;
}
}
// default to CDispatch's implementation
return CDispatch::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispID);
}
/*===================================================================
CServer::CheckForTombstone
Tombstone stub for IServer methods. If the object is
tombstone, does ExceptionId and fails.
Parameters:
Returns:
HRESULT E_FAIL if Tombstone
S_OK if not
===================================================================*/
HRESULT CServer::CheckForTombstone()
{
if (m_fInited)
{
// inited - good object
Assert(m_pData); // must be present for inited objects
return S_OK;
}
ExceptionId
(
IID_IServer,
IDE_SERVER,
IDE_INTRINSIC_OUT_OF_SCOPE
);
return E_FAIL;
}
/*===================================================================
CServer::CreateObject
Parameters: BSTR containing ProgID
Variant to fillin with IUknown pointer
Returns: S_OK if successful E_FAIL otherwise
Side effects:
Creates an instance of an ole automation object
===================================================================*/
STDMETHODIMP CServer::CreateObject(BSTR bstrProgID, IDispatch **ppDispObj)
{
if (FAILED(CheckForTombstone()))
return E_FAIL;
if (bstrProgID == NULL)
{
ExceptionId(IID_IServer, IDE_SERVER, IDE_EXPECTING_STR);
return E_FAIL;
}
Assert(m_pData->m_pHitObj);
*ppDispObj = NULL;
HRESULT hr;
CLSID clsid;
if (Glob(fEnableTypelibCache))
{
// Use typelib cache to create the component
hr = g_TypelibCache.CreateComponent
(
bstrProgID,
m_pData->m_pHitObj,
ppDispObj,
&clsid
);
if (FAILED(hr) && clsid == CLSID_NULL)
{
// bad prog id or something
ExceptionId(IID_IServer, IDE_SERVER, IDE_SERVER_CREATEOBJ_FAILED, hr);
return hr;
}
}
else
{
// Don't use typelib cache
hr = CLSIDFromProgID((LPCOLESTR)bstrProgID, &clsid);
if (FAILED(hr))
{
ExceptionId(IID_IServer, IDE_SERVER, IDE_SERVER_CREATEOBJ_FAILED, hr);
return hr;
}
hr = m_pData->m_pHitObj->CreateComponent(clsid, ppDispObj);
}
if (SUCCEEDED(hr))
return S_OK;
// Check if a custom error was already posted
IErrorInfo *pErrInfo = NULL;
if (GetErrorInfo(0, &pErrInfo) == S_OK && pErrInfo)
{
SetErrorInfo(0, pErrInfo);
pErrInfo->Release();
}
// Standard errors
else if (hr == E_ACCESSDENIED)
ExceptionId(IID_IServer, IDE_SERVER, IDE_SERVER_CREATEOBJ_DENIED);
else
{
if (hr == REGDB_E_CLASSNOTREG)
{
BOOL fInProc;
if (SUCCEEDED(CompModelFromCLSID(clsid, NULL, &fInProc)) && !fInProc)
{
ExceptionId(IID_IServer, IDE_SERVER, IDE_SERVER_CREATEOBJ_NOTINPROC);
}
}
else
ExceptionId(IID_IServer, IDE_SERVER, IDE_SERVER_CREATEOBJ_FAILED, hr);
}
return hr;
}
/*===================================================================
CServer::MapPath
Return the physical path translated from a logical path
Parameters:
BSTR bstrLogicalPath
BSTR FAR * pbstrPhysicalPath
Returns:
HRESULT S_OK on success
===================================================================*/
STDMETHODIMP CServer::MapPath(BSTR bstrLogicalPath, BSTR FAR * pbstrPhysicalPath)
{
if (FAILED(CheckForTombstone()))
return E_FAIL;
// Bug 1361: error if no CIsapiReqInfo (presumably called during
// Application_OnEnd or Session_OnEnd)
if (m_pData->m_pIReq == NULL)
{
ExceptionId(IID_IServer, IDE_SERVER_MAPPATH, IDE_SERVER_INVALID_CALL);
return E_FAIL;
}
AssertValid();
Assert (pbstrPhysicalPath != NULL);
*pbstrPhysicalPath = NULL;
// use MapPathInternal() to do the mapping
TCHAR szLogicalPath[MAX_PATH];
HRESULT hr = MapPathInternal(IDE_SERVER_MAPPATH, bstrLogicalPath, szLogicalPath);
if (FAILED(hr))
return hr;
#if UNICODE
*pbstrPhysicalPath = SysAllocString(szLogicalPath);
if (*pbstrPhysicalPath == NULL) {
ExceptionId(IID_IServer, IDE_SERVER_MAPPATH, IDE_OOM);
return E_FAIL;
}
#else
// Convert the path to wide character
if (FAILED(SysAllocStringFromSz(szLogicalPath, 0, pbstrPhysicalPath, CP_ACP))) {
ExceptionId(IID_IServer, IDE_SERVER_MAPPATH, IDE_OOM);
return E_FAIL;
}
#endif
return S_OK;
}
/*===================================================================
CServer::HTMLEncode
Encodes a string to HTML standards
Parameters:
BSTR bstrIn value: string to be encoded
BSTR FAR * pbstrEncoded value: pointer to HTML encoded version of string
Returns:
HRESULT S_OK on success
===================================================================*/
STDMETHODIMP CServer::HTMLEncode ( BSTR bstrIn, BSTR FAR * pbstrEncoded )
{
if (FAILED(CheckForTombstone()))
return E_FAIL;
char* pszstrIn = NULL;
char* pszEncodedstr = NULL;
char* pszStartEncodestr = NULL;
int nbstrLen = 0;
int nstrLen = 0;
HRESULT hr = S_OK;
UINT uCodePage = m_pData->m_pHitObj->GetCodePage();
CWCharToMBCS convIn;
STACK_BUFFER( tempHTML, 2048 );
if (bstrIn)
nbstrLen = wcslen(bstrIn);
else
nbstrLen = 0;
if (nbstrLen <= 0)
return S_OK;
if (FAILED(hr = convIn.Init(bstrIn, uCodePage))) {
if (hr == E_OUTOFMEMORY)
ExceptionId( IID_IServer, IDE_SERVER, IDE_OOM);
goto L_Exit;
}
pszstrIn = convIn.GetString();
nstrLen = HTMLEncodeLen(pszstrIn, uCodePage, bstrIn);
if (nstrLen > 0)
{
//Encode string , NOTE this function returns a pointer to the
// NULL so you need to keep a pointer to the start of the string
//
if (!tempHTML.Resize(nstrLen + 2)) {
ExceptionId( IID_IServer, IDE_SERVER, IDE_OOM);
hr = E_FAIL;
goto L_Exit;
}
pszEncodedstr = (char*)tempHTML.QueryPtr();
pszStartEncodestr = pszEncodedstr;
pszEncodedstr = ::HTMLEncode( pszEncodedstr, pszstrIn, uCodePage, bstrIn);
// convert result to bstr
//
if (FAILED(SysAllocStringFromSz(pszStartEncodestr, 0, pbstrEncoded, uCodePage)))
{
ExceptionId( IID_IServer, IDE_SERVER, IDE_OOM);
hr = E_FAIL;
goto L_Exit;
}
}
L_Exit:
return hr;
}
/*===================================================================
CServer::URLEncode
Encodes a query string to URL standards
Parameters:
BSTR bstrIn value: string to be URL encoded
BSTR FAR * pbstrEncoded value: pointer to URL encoded version of string
Returns:
HRESULT S_OK on success
===================================================================*/
STDMETHODIMP CServer::URLEncode ( BSTR bstrIn, BSTR FAR * pbstrEncoded )
{
if (FAILED(CheckForTombstone()))
return E_FAIL;
char* pszstrIn = NULL;
char* pszEncodedstr = NULL;
char* pszStartEncodestr = NULL;
int nbstrLen = 0;
int nstrLen = 0;
HRESULT hr = S_OK;
CWCharToMBCS convIn;
STACK_BUFFER( tempURL, 256 );
if (bstrIn)
nbstrLen = wcslen(bstrIn);
else
nbstrLen = 0;
if (nbstrLen <= 0)
return S_OK;
if (FAILED(hr = convIn.Init(bstrIn, m_pData->m_pHitObj->GetCodePage()))) {
if (hr == E_OUTOFMEMORY)
ExceptionId( IID_IServer, IDE_SERVER, IDE_OOM);
goto L_Exit;
}
pszstrIn = convIn.GetString();
nstrLen = URLEncodeLen(pszstrIn);
if (nstrLen > 0)
{
//Encode string , NOTE this function returns a pointer to the
// NULL so you need to keep a pointer to the start of the string
//
if (!tempURL.Resize(nstrLen + 2)) {
ExceptionId( IID_IServer, IDE_SERVER, IDE_OOM);
hr = E_FAIL;
goto L_Exit;
}
pszEncodedstr = (char *)tempURL.QueryPtr();
pszStartEncodestr = pszEncodedstr;
pszEncodedstr = ::URLEncode( pszEncodedstr, pszstrIn );
// convert result to bstr
//
if (FAILED(SysAllocStringFromSz(pszStartEncodestr, 0, pbstrEncoded)))
{
ExceptionId( IID_IServer, IDE_SERVER, IDE_OOM);
hr = E_FAIL;
goto L_Exit;
}
}
L_Exit:
return hr;
}
/*===================================================================
CServer::URLPathEncode
Encodes the path portion of a URL or a full URL. All characters
up to the first '?' are encoded with the following rules:
o Charcters that are needed to parse the URL are left alone
o RFC 1630 safe characters are left alone
o Non-foreign alphanumberic characters are left alone
o Anything else is escape encoded
Everything after the '?' is not encoded.
Parameters:
BSTR bstrIn value: string to be URL path encoded
BSTR FAR * pbstrEncoded value: pointer to URL path encoded version of string
Returns:
HRESULT S_OK on success
===================================================================*/
STDMETHODIMP CServer::URLPathEncode ( BSTR bstrIn, BSTR FAR * pbstrEncoded )
{
if (FAILED(CheckForTombstone()))
return E_FAIL;
char* pszstrIn = NULL;
char* pszEncodedstr = NULL;
char* pszStartEncodestr = NULL;
int nbstrLen = 0;
int nstrLen = 0;
HRESULT hr = S_OK;
CWCharToMBCS convIn;
STACK_BUFFER( tempPath, 256 );
if (bstrIn)
nbstrLen = wcslen(bstrIn);
else
nbstrLen = 0;
if (nbstrLen <= 0)
return S_OK;
if (FAILED(hr = convIn.Init(bstrIn, m_pData->m_pHitObj->GetCodePage()))) {
if (hr == E_OUTOFMEMORY)
ExceptionId( IID_IServer, IDE_SERVER, IDE_OOM);
goto L_Exit;
}
pszstrIn = convIn.GetString();
nstrLen = URLPathEncodeLen(pszstrIn);
if (nstrLen > 0)
{
//Encode string , NOTE this function returns a pointer to the
// NULL so you need to keep a pointer to the start of the string
//
if (!tempPath.Resize(nstrLen+2)) {
ExceptionId( IID_IServer, IDE_SERVER, IDE_OOM);
hr = E_FAIL;
goto L_Exit;
}
pszEncodedstr = (char *)tempPath.QueryPtr();
pszStartEncodestr = pszEncodedstr;
pszEncodedstr = ::URLPathEncode( pszEncodedstr, pszstrIn );
// convert result to bstr
//
if (FAILED(SysAllocStringFromSz(pszStartEncodestr, 0, pbstrEncoded)))
{
ExceptionId( IID_IServer, IDE_SERVER, IDE_OOM);
hr = E_FAIL;
goto L_Exit;
}
}
L_Exit:
return hr;
}
/*===================================================================
CServer::get_ScriptTimeout
Will return the script timeout interval (in seconds)
Parameters:
long *plTimeoutSeconds
Returns:
HRESULT S_OK on success
===================================================================*/
STDMETHODIMP CServer::get_ScriptTimeout( long * plTimeoutSeconds )
{
if (FAILED(CheckForTombstone()))
return E_FAIL;
if (m_pData->m_pHitObj == NULL)
{
ExceptionId(IID_IServer, IDE_SERVER_MAPPATH, IDE_SERVER_INVALID_CALL);
return(E_FAIL);
}
*plTimeoutSeconds = m_pData->m_pHitObj->GetScriptTimeout();
return S_OK;
}
/*===================================================================
CServer::put_ScriptTimeout
Allows the user to set the timeout interval for a script (in seconds)
Parameters:
long lTimeoutSeconds
Returns:
HRESULT S_OK on success
===================================================================*/
STDMETHODIMP CServer::put_ScriptTimeout( long lTimeoutSeconds )
{
if (FAILED(CheckForTombstone()))
return E_FAIL;
if ( lTimeoutSeconds < 0 )
{
ExceptionId( IID_IServer, IDE_SERVER, IDE_SERVER_INVALID_TIMEOUT );
return E_FAIL;
}
else
{
if (m_pData->m_pHitObj == NULL)
{
ExceptionId(IID_IServer, IDE_SERVER_MAPPATH, IDE_SERVER_INVALID_CALL);
return(E_FAIL);
}
m_pData->m_pHitObj->SetScriptTimeout(lTimeoutSeconds);
return S_OK;
}
}
/*===================================================================
CServer::Execute
Execute an ASP
Parameters:
bstrURL URL to execute
Returns:
HRESULT S_OK on success
===================================================================*/
STDMETHODIMP CServer::Execute(BSTR bstrURL)
{
if (FAILED(CheckForTombstone()))
return E_FAIL;
if (m_pData->m_pIReq == NULL || m_pData->m_pHitObj == NULL)
{
ExceptionId(IID_IServer, IDE_SERVER, IDE_SERVER_INVALID_CALL);
return E_FAIL;
}
TCHAR szTemplate[MAX_PATH], szVirtTemp[MAX_PATH];
HRESULT hr = MapPathInternal(IDE_SERVER, bstrURL, szTemplate, szVirtTemp);
if (FAILED(hr))
{
ExceptionId(IID_IServer, IDE_SERVER, IDE_SERVER_EXECUTE_INVALID_PATH);
return hr;
}
Normalize(szTemplate);
hr = m_pData->m_pHitObj->ExecuteChildRequest(FALSE, szTemplate, szVirtTemp);
if (FAILED(hr))
{
if (m_pData->m_pHitObj->FHasASPError()) // error already reported
return hr;
ExceptionId(IID_IServer, IDE_SERVER, (hr == E_COULDNT_OPEN_SOURCE_FILE) ?
IDE_SERVER_EXECUTE_CANTLOAD : IDE_SERVER_EXECUTE_FAILED);
return E_FAIL;
}
return S_OK;
}
/*===================================================================
CServer::Transfer
Transfer execution an ASP
Parameters:
bstrURL URL to execute
Returns:
HRESULT S_OK on success
===================================================================*/
STDMETHODIMP CServer::Transfer(BSTR bstrURL)
{
if (FAILED(CheckForTombstone()))
return E_FAIL;
if (m_pData->m_pIReq == NULL || m_pData->m_pHitObj == NULL)
{
ExceptionId(IID_IServer, IDE_SERVER_MAPPATH, IDE_SERVER_INVALID_CALL);
return E_FAIL;
}
TCHAR szTemplate[MAX_PATH], szVirtTemp[MAX_PATH];
HRESULT hr = MapPathInternal(IDE_SERVER, bstrURL, szTemplate, szVirtTemp);
if (FAILED(hr))
{
ExceptionId(IID_IServer, IDE_SERVER, IDE_SERVER_TRANSFER_INVALID_PATH);
return hr;
}
Normalize(szTemplate);
hr = m_pData->m_pHitObj->ExecuteChildRequest(TRUE, szTemplate, szVirtTemp);
if (FAILED(hr))
{
if (m_pData->m_pHitObj->FHasASPError()) // error already reported
return hr;
ExceptionId(IID_IServer, IDE_SERVER, (hr == E_COULDNT_OPEN_SOURCE_FILE) ?
IDE_SERVER_TRANSFER_CANTLOAD : IDE_SERVER_TRANSFER_FAILED);
return E_FAIL;
}
return S_OK;
}
/*===================================================================
CServer::GetLastError
Get ASPError object for the last error
Parameters:
ppASPErrorObject [out] the error object
Returns:
HRESULT S_OK on success
===================================================================*/
STDMETHODIMP CServer::GetLastError(IASPError **ppASPErrorObject)
{
*ppASPErrorObject = NULL;
if (FAILED(CheckForTombstone()))
return E_FAIL;
if (m_pData->m_pIReq == NULL || m_pData->m_pHitObj == NULL)
{
ExceptionId(IID_IServer, IDE_SERVER, IDE_SERVER_INVALID_CALL);
return E_FAIL;
}
HRESULT hr = m_pData->m_pHitObj->GetASPError(ppASPErrorObject);
if (FAILED(hr))
{
ExceptionId(IID_IServer, IDE_SERVER, IDE_UNEXPECTED);
return hr;
}
return S_OK;
}
#ifdef DBG
/*===================================================================
CServer::AssertValid
Test to make sure that the CServer object is currently correctly formed
and assert if it is not.
Returns:
Side effects:
None.
===================================================================*/
void CServer::AssertValid() const
{
Assert(m_fInited);
Assert(m_pData);
Assert(m_pData->m_pIReq);
}
#endif DBG
| 25.494889
| 116
| 0.563062
|
npocmaka
|
7a4f99dbb5cc0b08cdf058310b14b611e46ae0b6
| 36,478
|
hpp
|
C++
|
cpp/common/bypshttp/include/platform/qt/QTHttpClient.hpp
|
teberhardt/byps
|
6587cc804b95404a4fb0e1cd9f0f799388608bfc
|
[
"MIT"
] | 4
|
2018-10-19T08:50:40.000Z
|
2021-03-22T14:39:40.000Z
|
cpp/common/bypshttp/include/platform/qt/QTHttpClient.hpp
|
teberhardt/byps
|
6587cc804b95404a4fb0e1cd9f0f799388608bfc
|
[
"MIT"
] | null | null | null |
cpp/common/bypshttp/include/platform/qt/QTHttpClient.hpp
|
teberhardt/byps
|
6587cc804b95404a4fb0e1cd9f0f799388608bfc
|
[
"MIT"
] | 4
|
2015-07-17T16:31:10.000Z
|
2022-01-28T14:43:07.000Z
|
/* USE THIS FILE ACCORDING TO THE COPYRIGHT RULES IN LICENSE.TXT WHICH IS PART OF THE SOURCE CODE PACKAGE */
#ifndef QTHTTPCLIENT_HPP
#define QTHTTPCLIENT_HPP
#include "QTHttpClient.h"
#include "QTHttpClientI.h"
#include <QStack>
namespace byps { namespace http { namespace qthttp {
using namespace byps;
using namespace byps::http;
#define MAX_STREAM_PART_SIZE (1000 * 1000)
class QTHttpGetStream_ContentStream : public BContentStream {
byps_condition_variable waitRead;
byps_condition_variable waitWrite;
byps_condition_variable waitHeaders;
byps_mutex mutex;
QByteArray bytes;
bool finished;
int32_t readPos;
int32_t readLimit;
std::wstring contentType;
int64_t contentLength;
bool headersAvail;
std::chrono::milliseconds timeout;
BException ex;
static BLogger log;
public:
QTHttpGetStream_ContentStream(int32_t timeoutSeconds)
: finished(false)
, readPos(0)
, readLimit(0)
, contentLength(0)
, headersAvail(false)
, timeout(timeoutSeconds * 1000)
{
l_debug << L"ctor(timeoutSeconds=" << timeoutSeconds << L")";
}
virtual ~QTHttpGetStream_ContentStream() {
l_debug << L"dtor()";
}
bool putBytes(QByteArray nbytes) {
l_debug << L"putBytes(#bytes=" << nbytes.size();
byps_unique_lock lock(this->mutex);
while (readPos != readLimit) {
l_debug << L"wait for write";
if (waitWrite.wait_for(lock, timeout) == std::cv_status::timeout) {
l_debug << L")putBytes=false timeout";
return false;
}
}
l_debug << L"write and notify";
bytes = nbytes;
readPos = 0;
readLimit = nbytes.size();
waitRead.notify_one();
l_debug << L")putBytes=true";
return true;
}
void writeClose() {
l_debug << L"writeClose(";
byps_unique_lock lock(this->mutex);
this->finished = true;
waitRead.notify_one();
l_debug << L")writeClose";
}
void writeError(BException ex) {
l_debug << L"writeError(";
byps_unique_lock lock(this->mutex);
this->ex = ex;
waitRead.notify_one();
l_debug << L")writeError";
}
void applyHeaders(const std::wstring& contentType, int64_t contentLength) {
l_debug << L"applyHeaders(contentType=" << contentType << L", contentLength=" << contentLength;
byps_unique_lock lock(this->mutex);
this->contentType = contentType;
this->contentLength = contentLength;
this->headersAvail = true;
waitHeaders.notify_one();
l_debug << L")applyHeaders";
}
void maybeWaitUntilHeadersAvail() const {
l_debug << L"maybeWaitUntilHeadersAvail(";
QTHttpGetStream_ContentStream* pThis = const_cast<QTHttpGetStream_ContentStream*>(this);
byps_unique_lock lock(pThis->mutex);
while(!ex && !headersAvail) {
if (pThis->waitHeaders.wait_for(lock, timeout) == std::cv_status::timeout) {
l_debug << L"timeout";
pThis->ex = BException(EX_TIMEOUT, L"Timeout while waiting for response headers.");
}
}
if (ex) {
l_debug << L"throw exception=" << ex.toString();
throw ex;
}
l_debug << L")maybeWaitUntilHeadersAvail=" << headersAvail;
}
virtual const std::wstring& getContentType() const {
l_debug << L"getContentType(";
maybeWaitUntilHeadersAvail();
l_debug << L")getContentType=" << contentType;
return contentType;
}
virtual int64_t getContentLength() const {
l_debug << L"getContentLength(";
maybeWaitUntilHeadersAvail();
l_debug << L")getContentLength=" << contentLength;
return contentLength;
}
virtual int32_t read(char* buf, int32_t offs, int32_t len) {
l_debug << L"read(";
byps_unique_lock lock(this->mutex);
while (!ex && !finished && readPos == readLimit) {
if (waitRead.wait_for(lock, timeout) == std::cv_status::timeout) {
l_debug << L"timeout";
ex = BException(EX_TIMEOUT, L"Timeout while waiting for response data.");
}
}
if (ex) throw ex;
if (finished && readPos == readLimit) {
l_debug << L")read=-1";
return -1;
}
int32_t max = std::min(len, readLimit-readPos);
memcpy(buf + offs, bytes.data() + readPos, (size_t)max);
readPos += max;
if (readPos == readLimit) {
waitWrite.notify_one();
}
l_debug << L")read=" << max;
return max;
}
};
class QTHttpClient : public HHttpClient, public byps_enable_shared_from_this<QTHttpClient> {
void* app;
static BLogger log;
QTHttpClientBridge clientBridge;
PHttpCredentials credentials;
public:
QTHttpWorkerThread* worker;
QTHttpClient(void* app)
: app(app)
, worker(new QTHttpWorkerThread())
{
l_debug << L"ctor(";
worker->start();
QObject::connect(&clientBridge, SIGNAL(createGetRequest(QNetworkRequest,int32_t,QTHttpRequestBridge**)),
worker->workerBridge, SLOT(createGetRequest(QNetworkRequest,int32_t,QTHttpRequestBridge**)),
Qt::BlockingQueuedConnection);
QObject::connect(&clientBridge, SIGNAL(createPostRequest(QNetworkRequest,int32_t,QByteArray*,QTHttpRequestBridge**)),
worker->workerBridge, SLOT(createPostRequest(QNetworkRequest,int32_t,QByteArray*,QTHttpRequestBridge**)),
Qt::BlockingQueuedConnection);
QObject::connect(&clientBridge, SIGNAL(createPutRequest(QNetworkRequest,int32_t,QByteArray*,QTHttpRequestBridge**)),
worker->workerBridge, SLOT(createPutRequest(QNetworkRequest,int32_t,QByteArray*,QTHttpRequestBridge**)),
Qt::BlockingQueuedConnection);
QObject::connect(&clientBridge, SIGNAL(createPutStreamRequest(QNetworkRequest,int32_t,QIODevice*,QTHttpRequestBridge**)),
worker->workerBridge, SLOT(createPutStreamRequest(QNetworkRequest,int32_t,QIODevice*,QTHttpRequestBridge**)),
Qt::BlockingQueuedConnection);
l_debug << L")ctor";
}
virtual ~QTHttpClient() {
l_debug << L"dtor()";
}
virtual void init(const std::wstring& , PHttpCredentials creds) {
credentials = creds;
}
virtual void done() {
l_debug << L"done(";
emit worker->quit();
worker->wait();
delete worker;
l_debug << L")done";
}
virtual PHttpGetStream getStream(const std::wstring& url);
virtual PHttpGet get(const std::wstring& url);
virtual PHttpPost post(const std::wstring& url);
virtual PHttpPutStream putStream(const std::wstring& url);
void createGetRequest(PQTHttpRequest req, QNetworkRequest networkRequest, int32_t timeout, QTHttpRequestBridge** ppbridge) {
l_debug << L"createGetRequest(";
if (QThread::currentThread() == worker) {
// This function is called from the worker thread, if an error occurs in a message
// and the message is to be cancelled. Cancelling a message is performed with a
// special GET request in HWireClient::sendCancelMessage.
// see HWireClient_AsyncResultAfterAllRequests::setAsyncResult
worker->workerBridge->createGetRequest(networkRequest, timeout, ppbridge);
}
else {
emit clientBridge.createGetRequest(networkRequest, timeout, ppbridge);
}
l_debug << L"bridge=" << (void*)*ppbridge;
(*ppbridge)->pThis = req;
l_debug << L")createGetRequest";
}
void createPostRequest(PQTHttpRequest req, QNetworkRequest networkRequest, int32_t timeout, QByteArray* bytesToPost, QTHttpRequestBridge** ppbridge) {
l_debug << L"createPostRequest(";
if (QThread::currentThread() == worker) {
// This function is called from the worker thread, if the serverR is
// started in BClient::authenticate
worker->workerBridge->createPostRequest(networkRequest, timeout, bytesToPost, ppbridge);
}
else {
emit clientBridge.createPostRequest(networkRequest, timeout, bytesToPost, ppbridge);
}
l_debug << L"bridge=" << (void*)*ppbridge;
(*ppbridge)->pThis = req;
l_debug << L")createPostRequest";
}
void createPutRequest(PQTHttpRequest req, QNetworkRequest networkRequest, int32_t timeout, QByteArray* bytesToPut, QTHttpRequestBridge** ppbridge) {
l_debug << L"createPutRequest(";
if (QThread::currentThread() == worker) {
// This function is called from the worker thread, if subsequent
// stream parts have to be sent.
worker->workerBridge->createPutRequest(networkRequest, timeout, bytesToPut, ppbridge);
}
else {
emit clientBridge.createPutRequest(networkRequest, timeout, bytesToPut, ppbridge);
}
l_debug << L"bridge=" << (void*)*ppbridge;
(*ppbridge)->pThis = req;
l_debug << L")createPutRequest";
}
void createPutStreamRequest(PQTHttpRequest req, QNetworkRequest networkRequest, int32_t timeout, QIODevice* streamIO, QTHttpRequestBridge** ppbridge) {
l_debug << L"createPutStreamRequest(";
if (QThread::currentThread() == worker) {
// This function is called from the worker thread, if subsequent
// stream parts have to be sent.
worker->workerBridge->createPutStreamRequest(networkRequest, timeout, streamIO, ppbridge);
}
else {
emit clientBridge.createPutStreamRequest(networkRequest, timeout, streamIO, ppbridge);
}
l_debug << L"bridge=" << (void*)*ppbridge;
(*ppbridge)->pThis = req;
l_debug << L")createPutStreamRequest";
}
};
class QTHttpRequest : public virtual HHttpRequest, public byps_enable_shared_from_this<QTHttpRequest> {
protected:
byps_weak_ptr<QTHttpClient> httpClient;
std::wstring surl;
QTHttpRequestBridge* bridge;
int32_t timeoutSeconds;
bool requestAborted;
bool requestFinished;
PBytes respBytes;
size_t respPos;
PAsyncResult asyncBytesReceived;
BVariant result;
static BLogger log;
public:
QTHttpRequest(PQTHttpClient httpClient, const std::wstring& url)
: httpClient(httpClient)
, surl(url)
, bridge(0)
, timeoutSeconds(0)
, requestAborted(false)
, requestFinished(false)
, respPos(0)
, asyncBytesReceived(NULL)
{
l_debug << L"ctor()";
}
virtual ~QTHttpRequest() {
l_debug << L"dtor(";
// bridge is deleted with bridge->reply
l_debug << L")dtor";
}
virtual void setTimeouts(int32_t, int32_t sendrecvTimeoutSeconds) {
timeoutSeconds = sendrecvTimeoutSeconds;
l_debug << L"setTimeouts() timeoutSeconds=" << timeoutSeconds;
}
int32_t getTimeoutSeconds() {
return timeoutSeconds;
}
virtual void done() {
l_debug << L"done(";
PQTHttpRequest keepthis = shared_from_this();
if (!requestFinished) {
requestFinished = true;
if (bridge) {
bridge->done();
}
internalApplyResult();
}
keepthis.reset();
l_debug << L")done";
}
void abort() {
l_debug << L"abort(";
if (bridge && !requestAborted) {
requestAborted = true;
bool alreadyFinished = bridge->reply->isFinished();
if (!alreadyFinished) {
l_debug << L"abort";
bridge->reply->abort();
// reply->abort() will fire httpFinished() which
// calls done and deletes this
}
}
l_debug << L")abort";
}
PQTHttpClient getHttpClient() {
PQTHttpClient httpClient = this->httpClient.lock();
if (!httpClient) {
result = BVariant(BException(EX_CANCELLED, L"HttpClient object already deleted."));
internalApplyResult();
}
return httpClient;
}
virtual void internalApplyResult() {
l_debug << L"internalApplyResult(";
if (asyncBytesReceived) {
l_debug << L"result=" << result.toString();
asyncBytesReceived->setAsyncResult(result);
asyncBytesReceived = NULL;
}
l_debug << L")internalApplyResult";
}
virtual void httpFinished() {
l_debug << L"httpFinished(";
if (bridge) {
QVariant varContentLength = bridge->reply->header(QNetworkRequest::ContentLengthHeader);
qulonglong contentLength = varContentLength.toULongLong();
l_debug << L"contentLength=" << contentLength;
QVariant varContentType = bridge->reply->header(QNetworkRequest::ContentTypeHeader);
QString contentType = varContentType.toString();
l_debug << L"contentType=" << contentType.toStdWString();
}
if (respBytes) {
l_debug << L"#bytes=" << respPos;
respBytes->length = respPos;
if (!result.isException()) {
result = BVariant(respBytes);
}
}
done();
l_debug << L")httpFinished";
}
virtual void httpReadyRead() {
l_debug << L"httpReadReady(";
QByteArray bytes = bridge->reply->readAll();
size_t bsize = bytes.size();
l_debug << L"received #bytes=" << bsize;
if (!respBytes) {
respBytes = BBytes::create(bsize);
}
else if (respPos + bsize > respBytes->length) {
size_t grow = std::min(respBytes->length, (size_t)1000000);
size_t ncapacity = std::max(respBytes->length + grow, respPos + bsize);
l_debug << L"grow buffer to new capacity=" << ncapacity;
respBytes = BBytes::create(respBytes, ncapacity);
}
l_debug << L"copy bytes";
memcpy(respBytes->data + respPos, bytes.data(), bsize);
respPos += bsize;
l_debug << L"received so far: #bytes=" << respPos;
}
virtual void httpTimeout() {
l_debug << L"httpTimeout(";
httpError(BException(EX_TIMEOUT, L"HTTP request timeout"));
l_debug << L")httpTimeout";
}
virtual void httpError(const BException& ex) {
l_debug << L"httpError(" << ex;
if (!requestFinished && !requestAborted) {
result = BVariant(ex);
abort();
}
l_debug << L")httpError";
}
virtual void close() {
l_debug << L"close(";
if (!requestFinished) {
httpError(BException(EX_CANCELLED, L"HTTP request cancelled"));
}
l_debug << L")close";
}
};
class QTHttpGetStream : public HHttpGetStream, public virtual QTHttpRequest {
byps_weak_ptr<QTHttpGetStream_ContentStream> stream_weak_ptr;
bool headersApplied;
static BLogger log;
public:
QTHttpGetStream(PQTHttpClient httpClient, const std::wstring& url)
: QTHttpRequest(httpClient, url)
, headersApplied(false)
{
l_debug << L"ctor()";
}
virtual ~QTHttpGetStream() {
l_debug << L"dtor()";
}
virtual PContentStream send() {
l_debug << L"send(";
byps_ptr<QTHttpGetStream_ContentStream> ret(new QTHttpGetStream_ContentStream(timeoutSeconds));
this->stream_weak_ptr = ret;
PQTHttpClient httpClient = getHttpClient();
if (httpClient) {
l_debug << L"networkManager->get...";
QNetworkRequest networkRequest(QUrl(QString::fromStdWString(surl)));
httpClient->createGetRequest(shared_from_this(), networkRequest, getTimeoutSeconds(), &bridge);
l_debug << L"networkManager->get OK";
}
l_debug << L")send";
return ret;
}
byps_ptr<QTHttpGetStream_ContentStream> getStreamOrAbort() {
l_debug << L"getStreamOrAbort(";
byps_ptr<QTHttpGetStream_ContentStream> stream = stream_weak_ptr.lock();
if (!stream && !bridge->reply->isFinished()) {
abort();
}
l_debug << L")getStreamOrAbort=" << stream.get();
return stream;
}
virtual void internalApplyResult() {
l_debug << L"internalApplyResult(";
byps_ptr<QTHttpGetStream_ContentStream> stream = getStreamOrAbort();
if (stream) {
if (result.isException()) {
l_debug << L"stream->writeError " << result.getException().toString();
stream->writeError(result.getException());
}
else {
l_debug << L"stream->writeClose";
stream->writeClose();
}
}
l_debug << L")internalApplyResult";
}
virtual void httpFinished() {
l_debug << L"httpFinished(";
applyHeadersIfNot();
if (!result.isException()) {
result = BVariant(true);
}
done();
l_debug << L")httpFinished";
}
virtual void httpReadyRead() {
l_debug << L"httpReadyRead(";
applyHeadersIfNot();
byps_ptr<QTHttpGetStream_ContentStream> stream = getStreamOrAbort();
if (stream) {
stream->putBytes(bridge->reply->readAll());
}
l_debug << L")httpReadyRead";
}
void applyHeadersIfNot() {
l_debug << L"applyHeadersIfNot(";
l_debug << L"headersApplied=" << headersApplied;
if (!headersApplied) {
headersApplied = true;
byps_ptr<QTHttpGetStream_ContentStream> stream = getStreamOrAbort();
if (stream) {
QByteArray headerValue = bridge->reply->rawHeader("Content-Type");
std::wstring contentType = BToStdWString(headerValue.data());
headerValue = bridge->reply->rawHeader("Content-Length");
int64_t contentLength = headerValue.size() ? QString(headerValue).toLongLong() : -1;
stream->applyHeaders(contentType, contentLength);
}
}
l_debug << L")applyHeadersIfNot";
}
};
class QTHttpGet : public HHttpGet, public virtual QTHttpRequest {
friend class QTHttpPostWorker;
static BLogger log;
public:
QTHttpGet(PQTHttpClient httpClient, const std::wstring& url)
: QTHttpRequest(httpClient, url)
{
l_debug << L"ctor()";
}
virtual ~QTHttpGet() {
l_debug << L"dtor()";
}
virtual void send(PAsyncResult asyncBytesReceived) {
l_debug << L"send(";
this->asyncBytesReceived = asyncBytesReceived;
PQTHttpClient httpClient = getHttpClient();
if (httpClient) {
l_debug << L"networkManager->post...";
QNetworkRequest networkRequest(QUrl(QString::fromStdWString(surl)));
httpClient->createGetRequest(shared_from_this(), networkRequest, getTimeoutSeconds(), &bridge);
l_debug << L"networkManager->post OK";
}
l_debug << L")send";
}
};
class QTHttpPost : public HHttpPost, public virtual QTHttpRequest {
QByteArray* bytesToPost;
friend class QTHttpPostWorker;
static BLogger log;
public:
QTHttpPost(PQTHttpClient httpClient, const std::wstring& url)
: QTHttpRequest(httpClient, url)
, bytesToPost(NULL)
{
l_debug << L"ctor()";
}
virtual ~QTHttpPost() {
l_debug << L"dtor()";
if (bytesToPost) delete bytesToPost;
}
virtual void send(PBytes bytes, const std::wstring& contentType, PAsyncResult asyncBytesReceived) {
l_debug << L"send(#bytes=" << bytes->length << L", contentType=" << contentType;
this->bytesToPost = new QByteArray((const char*)bytes->data, bytes->length);
this->asyncBytesReceived = asyncBytesReceived;
QNetworkRequest networkRequest(QUrl(QString::fromStdWString(surl)));
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(QString::fromStdWString(contentType)));
networkRequest.setHeader(QNetworkRequest::ContentLengthHeader, QVariant((qulonglong)bytes->length));
PQTHttpClient httpClient = getHttpClient();
if (httpClient) {
l_debug << L"networkManager->post...";
httpClient->createPostRequest(shared_from_this(), networkRequest, getTimeoutSeconds(), bytesToPost, &bridge);
l_debug << L"networkManager->post OK";
}
l_debug << L")send";
}
};
QTPutStreamIODevice::QTPutStreamIODevice(PContentStream strm, QObject* parent)
: QIODevice(parent)
, strm(strm) {
}
QTPutStreamIODevice::~QTPutStreamIODevice() {
strm.reset();
}
bool QTPutStreamIODevice::open(OpenMode mode) {
bool succ = ((mode & ~ReadOnly) != 0);
if (succ) {
setOpenMode(mode);
}
return succ;
}
void QTPutStreamIODevice::close() {
strm.reset();
setOpenMode(NotOpen);
}
bool QTPutStreamIODevice::isSequential() const {
return false;
}
qint64 QTPutStreamIODevice::size() const {
return strm->getContentLength();
}
qint64 QTPutStreamIODevice::bytesAvailable() const {
return size();
}
qint64 QTPutStreamIODevice::readData(char* data, qint64 maxSize) {
int32_t len = (int32_t)(maxSize & 0x7FFFFFFFF);
return strm->read(data, 0, len);
}
qint64 QTPutStreamIODevice::writeData(const char* , qint64 ) {
return -1;
}
class QTHttpPutStream : public HHttpPutStream, public virtual QTHttpRequest {
PContentStream streamToPut;
PAsyncResult asyncBoolFinished;
int64_t partId;
int64_t nbOfParts;
int64_t totalLength;
bool isLastPart;
QTPutStreamIODevice* streamIO;
QByteArray bytesToPut;
void* data; // just for debugging QByteArray, i want to see, whether resize() changes the internal buffer
PQTHttpRequest keepThisUntilLastPart;
std::wstring baseUrl;
friend class QTHttpPutStreamWorker;
static BLogger log;
public:
QTHttpPutStream(PQTHttpClient httpClient, const std::wstring& url)
: QTHttpRequest(httpClient, url)
, streamToPut(NULL)
, asyncBoolFinished(NULL)
, partId(0)
, nbOfParts(0)
, totalLength(0)
, isLastPart(false)
, streamIO(NULL)
, data(NULL)
{
l_debug << L"ctor()";
}
virtual ~QTHttpPutStream() {
l_debug << L"dtor()";
}
virtual void send(PContentStream strm, PAsyncResult asyncBoolFinished) {
internalSendAsByteArray(strm, asyncBoolFinished);
}
void internalSendAsIODevice(PContentStream strm, PAsyncResult asyncBoolFinished) {
int64_t contentLength = strm->getContentLength();
l_debug << L"send(contentLength=" << contentLength << L", contentType=" << strm->getContentType();
PQTHttpClient httpClient = getHttpClient();
if (httpClient) {
this->asyncBoolFinished = asyncBoolFinished;
this->streamToPut = strm;
this->totalLength = contentLength;
this->baseUrl = surl;
this->streamIO = new QTPutStreamIODevice(strm);
l_debug << L"header contentType=" << streamToPut->getContentType();
l_debug << L"header contentLength=" << contentLength;
QNetworkRequest networkRequest(QUrl(QString::fromStdWString(surl)));
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(QString::fromStdWString(streamToPut->getContentType())));
networkRequest.setHeader(QNetworkRequest::ContentLengthHeader, QVariant((qulonglong)contentLength));
networkRequest.setAttribute(QNetworkRequest::DoNotBufferUploadDataAttribute, QVariant(true));
l_debug << L"networkManager->put...";
httpClient->createPutStreamRequest(shared_from_this(), networkRequest, getTimeoutSeconds(), streamIO, &bridge);
l_debug << L"networkManager->put OK";
}
else {
BException ex(EX_CANCELLED, L"HTTP client already deleted.");
httpError(ex);
}
}
void internalSendAsByteArray(PContentStream strm, PAsyncResult asyncBoolFinished) {
int64_t contentLength = strm->getContentLength();
l_debug << L"send(contentLength=" << contentLength << L", contentType=" << strm->getContentType();
this->asyncBoolFinished = asyncBoolFinished;
this->streamToPut = strm;
this->totalLength = contentLength;
this->baseUrl = surl;
if (totalLength >= 0) {
nbOfParts = totalLength / MAX_STREAM_PART_SIZE;
if (totalLength % MAX_STREAM_PART_SIZE) {
nbOfParts++;
}
}
else {
nbOfParts = INT64_MAX;
}
keepThisUntilLastPart = shared_from_this();
sendNextPart(0);
}
void sendNextPart(int64_t nextPartId) {
l_debug << L"sendNextPart(nextPartId=" << nextPartId;
this->partId = nextPartId;
PQTHttpClient httpClient = getHttpClient();
if (httpClient) {
int32_t contentLength = 0;
bytesToPut.clear();
// Read stream part into buffer
if (totalLength >= 0) {
size_t capacity = std::min((size_t)totalLength, (size_t)MAX_STREAM_PART_SIZE);
bytesToPut.resize(capacity);
data = bytesToPut.data();
l_debug << L"read from stream..." << (void*)data;
contentLength = streamToPut->read((char*)data, 0, capacity);
if (contentLength < 0) contentLength = 0; // true, if stream is empty
l_debug << L"read from stream OK, #bytes=" << contentLength;
isLastPart = partId >= nbOfParts-1; // nbOfParts might be 0
l_debug << L"isLastPart=" << isLastPart;
}
else {
size_t capacity = MAX_STREAM_PART_SIZE;
bytesToPut.resize(capacity);
data = bytesToPut.data();
l_debug << L"read from stream..." << (void*)data;
contentLength = streamToPut->read((char*)data, 0, capacity);
l_debug << L"read from stream OK, #bytes=" << contentLength;
if (contentLength < 0) contentLength = 0; // true, if stream is empty or stream size is a multiple of MAX_STREAM_PART_SIZE
isLastPart = contentLength < MAX_STREAM_PART_SIZE;
l_debug << L"isLastPart=" << isLastPart;
}
bytesToPut.resize(contentLength);
data = bytesToPut.data();
l_debug << L"buffer resized to contentLength, " << (void*)data;
// Append partid, totallength to URL
QString partUrl(QString::fromStdWString(baseUrl));
partUrl.append("&partid=").append(QString::number(partId));
partUrl.append("&total=").append(QString::number(totalLength));
partUrl.append("&last=").append(QString::number(isLastPart));
l_debug << L"partUrl=" << partUrl.toStdWString();
l_debug << L"header contentType=" << streamToPut->getContentType();
l_debug << L"header contentLength=" << contentLength;
QNetworkRequest networkRequest(partUrl);
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(QString::fromStdWString(streamToPut->getContentType())));
networkRequest.setHeader(QNetworkRequest::ContentLengthHeader, QVariant((qulonglong)contentLength));
networkRequest.setAttribute(QNetworkRequest::DoNotBufferUploadDataAttribute, QVariant(true));
l_debug << L"networkManager->put...";
httpClient->createPutRequest(shared_from_this(), networkRequest, getTimeoutSeconds(), &bytesToPut, &bridge);
l_debug << L"networkManager->put OK";
}
else {
// httpClient is already released. This should not happend during the HTTP request.
result = BVariant(BException(EX_CANCELLED, L"HTTP client has already been released."));
internalApplyResult();
}
l_debug << L")sendNextPart";
}
virtual void internalApplyResult() {
if (asyncBoolFinished) {
l_debug << L"result=" << result.toString();
asyncBoolFinished->setAsyncResult(result);
asyncBoolFinished = NULL;
}
}
virtual void httpFinished() {
l_debug << L"httpFinished(";
if (streamIO) {
l_debug << L"stream was sent";
}
else {
l_debug << L"isLastPart=" << isLastPart;
if (isLastPart) {
keepThisUntilLastPart.reset();
if (!result.isException()) {
result = BVariant(true);
}
done();
}
else {
sendNextPart(partId+1);
}
}
l_debug << L")httpFinished";
}
virtual void httpError(const BException& ex) {
keepThisUntilLastPart.reset();
QTHttpRequest::httpError(ex);
}
virtual void httpReadyRead() {
l_debug << L"httpReadyRead(";
bridge->reply->readAll();
l_debug << L")httpReadyRead";
}
};
BINLINE QTHttpRequestBridge::QTHttpRequestBridge(QNetworkReply* reply, int32_t timeoutSeconds)
: QObject(reply)
, reply(reply)
{
l_debug << L"ctor(";
l_debug << L"connect signals";
QObject::connect(reply, SIGNAL(finished()),
this, SLOT(httpFinished()));
QObject::connect(reply, SIGNAL(readyRead()),
this, SLOT(httpReadyRead()));
QObject::connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(httpError(QNetworkReply::NetworkError)));
if (timeoutSeconds) {
QObject::connect(&timer, SIGNAL(timeout()),
this, SLOT(httpTimeout()));
l_debug << L"start timer, timeoutSeconds=" << timeoutSeconds;
timer.setSingleShot(true);
timer.start(timeoutSeconds * 1000);
}
l_debug << L")ctor";
}
BINLINE QTHttpRequestBridge::~QTHttpRequestBridge() {
l_debug << L"dtor(";
//reply->deleteLater();
l_debug << L")dtor";
}
BINLINE void QTHttpRequestBridge::httpFinished() {
l_debug << L"httpFinished(";
timer.stop();
if (pThis) {
pThis->httpFinished();
pThis.reset();
}
reply->deleteLater();
l_debug << L")httpFinished";
}
BINLINE void QTHttpRequestBridge::httpReadyRead() {
l_debug << L"httpReadyRead(";
if (pThis) {
int32_t timeoutSeconds = pThis->getTimeoutSeconds();
if (timeoutSeconds) {
l_debug << L"restart timer, timeoutSeconds=" << timeoutSeconds;
timer.stop();
timer.start(timeoutSeconds * 1000);
}
pThis->httpReadyRead();
}
l_debug << L")httpReadyRead";
}
BINLINE void QTHttpRequestBridge::httpTimeout() {
l_debug << L"httpTimeout(";
timer.stop();
if (pThis) {
pThis->httpTimeout();
}
l_debug << L")httpTimeout";
}
BINLINE void QTHttpRequestBridge::httpError(QNetworkReply::NetworkError err) {
l_debug << L"httpError(" << err;
timer.stop();
QString str = reply->errorString();
std::wstring msg = str.toStdWString();
if (pThis) {
pThis->httpError(BException(EX_IOERROR, msg));
}
l_debug << L")httpError";
}
BINLINE void QTHttpRequestBridge::done() {
l_debug << L"done()";
pThis.reset();
}
BINLINE PHttpGetStream QTHttpClient::getStream(const std::wstring& url) {
l_debug << L"getStream(" << url;
QTHttpGetStream* req = new QTHttpGetStream(shared_from_this(), url);
l_debug << L")getStream";
return PHttpGetStream(req);
}
BINLINE PHttpGet QTHttpClient::get(const std::wstring& url) {
l_debug << L"get(" << url;
QTHttpGet* req = new QTHttpGet(shared_from_this(), url);
l_debug << L")get";
return PHttpGet(req);
}
BINLINE PHttpPost QTHttpClient::post(const std::wstring& url) {
l_debug << L"post(" << url;
QTHttpPost* req = new QTHttpPost(shared_from_this(), url);
l_debug << L")post";
return PHttpPost(req);
}
BINLINE PHttpPutStream QTHttpClient::putStream(const std::wstring& url) {
l_debug << L"putStream(" << url;
QTHttpPutStream* req = new QTHttpPutStream(shared_from_this(), url);
l_debug << L")putStream";
return PHttpPutStream(req);
}
BINLINE QTHttpWorkerThread::QTHttpWorkerThread()
: workerBridge(new QTHttpWorkerBridge())
{
l_debug << L"ctor()";
workerBridge->moveToThread(this);
workerBridge->networkManager->moveToThread(this);
}
BINLINE QTHttpWorkerThread::~QTHttpWorkerThread()
{
l_debug << L"dtor()";
delete workerBridge;
}
BINLINE void QTHttpWorkerThread::run() {
l_debug << L"run(";
exec();
l_debug << L")run";
}
BINLINE QTHttpWorkerBridge::QTHttpWorkerBridge()
: networkManager(new QNetworkAccessManager())
{
}
BINLINE void QTHttpWorkerBridge::createGetRequest(QNetworkRequest networkRequest, int32_t timeout, QTHttpRequestBridge ** ppbridge)
{
l_debug << L"createGetRequest(";
QNetworkReply* reply = networkManager->get(networkRequest);
*ppbridge = new QTHttpRequestBridge(reply, timeout);
l_debug << L")createGetRequest";
}
BINLINE void QTHttpWorkerBridge::createPostRequest(QNetworkRequest networkRequest, int32_t timeout, QByteArray* bytesToPost, QTHttpRequestBridge ** ppbridge)
{
l_debug << L"createPostRequest(";
QNetworkReply* reply = networkManager->post(networkRequest, *bytesToPost);
*ppbridge = new QTHttpRequestBridge(reply, timeout);
l_debug << L")createPostRequest";
}
BINLINE void QTHttpWorkerBridge::createPutRequest(QNetworkRequest networkRequest, int32_t timeout, QByteArray* bytesToPut, QTHttpRequestBridge ** ppbridge)
{
l_debug << L"createPutRequest(";
QNetworkReply* reply = networkManager->put(networkRequest, *bytesToPut);
*ppbridge = new QTHttpRequestBridge(reply, timeout);
l_debug << L")createPutRequest";
}
BINLINE void QTHttpWorkerBridge::createPutStreamRequest(QNetworkRequest networkRequest, int32_t timeout, QIODevice* streamIO, QTHttpRequestBridge ** ppbridge)
{
l_debug << L"createPutRequest(";
QNetworkReply* reply = networkManager->put(networkRequest, streamIO);
*ppbridge = new QTHttpRequestBridge(reply, timeout);
l_debug << L")createPutRequest";
}
BLogger QTHttpGetStream_ContentStream::log("QTHttpGetStream_ContentStream");
BLogger QTHttpClient::log("QTHttpClient");
BLogger QTHttpRequest::log("QTHttpRequest");
BLogger QTHttpGetStream::log("QTHttpGetStream");
BLogger QTHttpPost::log("QTHttpPost");
BLogger QTHttpGet::log("QTHttpGet");
BLogger QTHttpPutStream::log("QTHttpPutStream");
BLogger QTHttpWorkerThread::log("QTHttpWorkerThread");
BLogger QTHttpRequestBridge::log("QTHttpRequestBridge");
BLogger QTHttpWorkerBridge::log("QTHttpWorkerBridge");
}}}
namespace byps { namespace http {
BINLINE PHttpClient HttpClient_create(void* app) {
return PHttpClient(new byps::http::qthttp::QTHttpClient(app));
}
}}
#endif // QTHTTPCLIENT_HPP
| 33.964618
| 159
| 0.60409
|
teberhardt
|
7a53aaf90b9f479f1539dc464d81281928ebccff
| 240
|
cpp
|
C++
|
delete/main.cpp
|
mamil/demo
|
32240d95b80175549e6a1904699363ce672a1591
|
[
"MIT"
] | null | null | null |
delete/main.cpp
|
mamil/demo
|
32240d95b80175549e6a1904699363ce672a1591
|
[
"MIT"
] | null | null | null |
delete/main.cpp
|
mamil/demo
|
32240d95b80175549e6a1904699363ce672a1591
|
[
"MIT"
] | null | null | null |
#include <memory>
#include <iostream>
class Man
{
public:
Man() = default;
// ~Man() = delete; // error: use of deleted function ‘Man::~Man()’
int age;
};
int main()
{
{
auto man = std::make_shared<Man>();
}
}
| 13.333333
| 71
| 0.5375
|
mamil
|
7a5b9ac7204db2f5a306c83e336d67510bbb8faf
| 5,711
|
cc
|
C++
|
testdata/fuzzer_binary.cc
|
DaryaShirokova/lldb-eval
|
114625c28f5aa8fafda4d49d9dbb0e6fd2b16d20
|
[
"Apache-2.0"
] | null | null | null |
testdata/fuzzer_binary.cc
|
DaryaShirokova/lldb-eval
|
114625c28f5aa8fafda4d49d9dbb0e6fd2b16d20
|
[
"Apache-2.0"
] | null | null | null |
testdata/fuzzer_binary.cc
|
DaryaShirokova/lldb-eval
|
114625c28f5aa8fafda4d49d9dbb0e6fd2b16d20
|
[
"Apache-2.0"
] | null | null | null |
/*
* Copyright 2020 Google LLC
*
* 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 <limits>
// This file _must not_ access the file system, since the current directory
// is specified in the fuzzer as just `./`.
class MultiInheritBase1 {
public:
int f1 = 10;
};
class MultiInheritBase2 {
public:
int f2 = 20;
};
class MultiInheritDerived : public MultiInheritBase1, public MultiInheritBase2 {
public:
int f3 = 30;
};
class DeadlyDiamondBase {
public:
int f1 = 10;
};
class DeadlyDiamondDerived1 : public DeadlyDiamondBase {
public:
int f2 = 20;
};
class DeadlyDiamondDerived2 : public DeadlyDiamondBase {
public:
int f3 = 30;
};
class DeadlyDiamondSubclass : public DeadlyDiamondDerived1,
public DeadlyDiamondDerived2 {
public:
int f4 = 40;
};
class VirtualDiamondBase {
public:
int f1 = 10;
};
class VirtualDiamondDerived1 : public virtual VirtualDiamondBase {
public:
int f2 = 20;
};
class VirtualDiamondDerived2 : public virtual VirtualDiamondBase {
public:
int f3 = 30;
};
class VirtualDiamondSubclass : public VirtualDiamondDerived1,
public VirtualDiamondDerived2 {
public:
int f4 = 40;
};
class EmptyBase {};
class NonEmptyBase {
public:
int f2 = 10;
};
struct TestStruct {
float flt_field = 0.5f;
int int_field = 20;
unsigned long long ull_field = -1ull;
char ch_field = '/';
};
union TestUnion {
unsigned int uint_field;
unsigned char ch_field;
};
class NonEmptyDerived : public NonEmptyBase, public EmptyBase {
public:
EmptyBase base;
int f1 = 10;
};
int main() {
auto char_min = std::numeric_limits<char>::min();
auto char_max = std::numeric_limits<char>::max();
(void)char_min, (void)char_max;
auto uchar_min = std::numeric_limits<unsigned char>::min();
auto uchar_max = std::numeric_limits<unsigned char>::max();
(void)uchar_min, (void)uchar_max;
auto schar_min = std::numeric_limits<signed char>::min();
auto schar_max = std::numeric_limits<signed char>::max();
(void)schar_min, (void)schar_max;
auto short_min = std::numeric_limits<short>::min();
auto short_max = std::numeric_limits<short>::max();
(void)short_min, (void)short_max;
auto ushort_min = std::numeric_limits<unsigned short>::min();
auto ushort_max = std::numeric_limits<unsigned short>::max();
(void)ushort_min, (void)ushort_max;
auto int_min = std::numeric_limits<int>::min();
auto int_max = std::numeric_limits<int>::max();
(void)int_min, (void)int_max;
auto uint_min = std::numeric_limits<unsigned int>::min();
auto uint_max = std::numeric_limits<unsigned int>::max();
(void)uint_min, (void)uint_max;
auto long_min = std::numeric_limits<long>::min();
auto long_max = std::numeric_limits<long>::max();
(void)long_min, (void)long_max;
auto ulong_min = std::numeric_limits<unsigned long>::min();
auto ulong_max = std::numeric_limits<unsigned long>::max();
(void)ulong_min, (void)ulong_max;
auto llong_min = std::numeric_limits<long long>::min();
auto llong_max = std::numeric_limits<long long>::max();
(void)llong_min, (void)llong_max;
auto ullong_min = std::numeric_limits<unsigned long long>::min();
auto ullong_max = std::numeric_limits<unsigned long long>::max();
(void)ullong_min, (void)ullong_max;
auto finf = std::numeric_limits<float>::infinity();
auto fnan = std::numeric_limits<float>::quiet_NaN();
auto fsnan = std::numeric_limits<float>::signaling_NaN();
auto fmax = std::numeric_limits<float>::max();
// Smallest positive non-zero float denormal
auto fdenorm = 0x0.1p-145f;
(void)finf, (void)fnan, (void)fsnan, (void)fmax, (void)fdenorm;
auto dinf = std::numeric_limits<double>::infinity();
auto dnan = std::numeric_limits<double>::quiet_NaN();
auto dsnan = std::numeric_limits<double>::signaling_NaN();
auto dmax = std::numeric_limits<double>::max();
// Smallest positive non-zero double denormal
auto ddenorm = 0x0.1p-1070;
(void)dinf, (void)dnan, (void)dsnan, (void)dmax, (void)ddenorm;
auto ldinf = std::numeric_limits<long double>::infinity();
auto ldnan = std::numeric_limits<long double>::quiet_NaN();
auto ldsnan = std::numeric_limits<long double>::signaling_NaN();
auto ldmax = std::numeric_limits<long double>::max();
// Smallest positive non-zero long double denormal
#ifdef _WIN32
// On Win32 `long double` is an alias for `double`.
auto lddenorm = 0x0.1p-1070L;
#else
auto lddenorm = 0x0.1p-16440L;
#endif
(void)ldinf, (void)ldnan, (void)ldsnan, (void)ldmax, (void)lddenorm;
int x = 42;
int* p = &x;
int** q = &p;
int& ref = x;
int* const* const& refp = &p;
(void)x, (void)p, (void)q, (void)ref, (void)refp;
int array2d[3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}};
(void)array2d;
MultiInheritDerived multi;
DeadlyDiamondSubclass diamond;
VirtualDiamondSubclass virtual_diamond;
(void)multi, (void)diamond, (void)diamond;
const char* null_char_ptr = nullptr;
const char* test_str = "Hee hee hee";
(void)null_char_ptr, (void)test_str;
NonEmptyDerived empty_base;
(void)empty_base;
TestStruct ts;
TestUnion tu;
tu.uint_field = 65;
(void)ts, (void)tu;
// BREAK HERE
return 0;
}
| 26.938679
| 80
| 0.696726
|
DaryaShirokova
|
7a5e493193012d1eddb6252c4ecdc4ca47989b12
| 824
|
cpp
|
C++
|
841.cpp
|
zfang399/LeetCode-Problems
|
4cb25718a3d1361569f5ee6fde7b4a9a4fde2186
|
[
"MIT"
] | 8
|
2018-10-31T11:00:19.000Z
|
2020-07-31T05:25:06.000Z
|
841.cpp
|
zfang399/LeetCode-Problems
|
4cb25718a3d1361569f5ee6fde7b4a9a4fde2186
|
[
"MIT"
] | null | null | null |
841.cpp
|
zfang399/LeetCode-Problems
|
4cb25718a3d1361569f5ee6fde7b4a9a4fde2186
|
[
"MIT"
] | 2
|
2018-05-31T11:29:22.000Z
|
2019-09-11T06:34:40.000Z
|
class Solution {
public:
bool canVisitAllRooms(vector<vector<int>>& rooms) {
int N = rooms.size();
vector<bool> vis(N, false);
queue<int> tovis;
// start from room #0, until we cannot visit any new room
tovis.push(0);
while(tovis.size()){
int cur_room = tovis.front();
tovis.pop();
// mark as visited
vis[cur_room] = true;
// add the unvisited room to the queue
for(int i = 0; i < rooms[cur_room].size(); i++){
if(vis[rooms[cur_room][i]]) continue;
tovis.push(rooms[cur_room][i]);
vis[rooms[cur_room][i]] = true;
}
}
for(int i = 0; i < N; i++){
if(!vis[i]) return false;
}
return true;
}
};
| 29.428571
| 65
| 0.475728
|
zfang399
|
7a623886125636aeab1f41f9f90e52d5838f8c8d
| 5,112
|
cpp
|
C++
|
B2G/gecko/dom/mobilemessage/src/MobileMessageService.cpp
|
wilebeast/FireFox-OS
|
43067f28711d78c429a1d6d58c77130f6899135f
|
[
"Apache-2.0"
] | 3
|
2015-08-31T15:24:31.000Z
|
2020-04-24T20:31:29.000Z
|
B2G/gecko/dom/mobilemessage/src/MobileMessageService.cpp
|
wilebeast/FireFox-OS
|
43067f28711d78c429a1d6d58c77130f6899135f
|
[
"Apache-2.0"
] | null | null | null |
B2G/gecko/dom/mobilemessage/src/MobileMessageService.cpp
|
wilebeast/FireFox-OS
|
43067f28711d78c429a1d6d58c77130f6899135f
|
[
"Apache-2.0"
] | 3
|
2015-07-29T07:17:15.000Z
|
2020-11-04T06:55:37.000Z
|
/* 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 "SmsMessage.h"
#include "MmsMessage.h"
#include "MobileMessageThread.h"
#include "MobileMessageService.h"
#include "SmsSegmentInfo.h"
#include "jsapi.h"
namespace mozilla {
namespace dom {
namespace mobilemessage {
NS_IMPL_ISUPPORTS1(MobileMessageService, nsIMobileMessageService)
/* static */ StaticRefPtr<MobileMessageService> MobileMessageService::sSingleton;
/* static */ already_AddRefed<MobileMessageService>
MobileMessageService::GetInstance()
{
if (!sSingleton) {
sSingleton = new MobileMessageService();
ClearOnShutdown(&sSingleton);
}
nsRefPtr<MobileMessageService> service = sSingleton.get();
return service.forget();
}
NS_IMETHODIMP
MobileMessageService::CreateSmsMessage(int32_t aId,
uint64_t aThreadId,
const nsAString& aDelivery,
const nsAString& aDeliveryStatus,
const nsAString& aSender,
const nsAString& aReceiver,
const nsAString& aBody,
const nsAString& aMessageClass,
const jsval& aTimestamp,
const bool aRead,
JSContext* aCx,
nsIDOMMozSmsMessage** aMessage)
{
return SmsMessage::Create(aId,
aThreadId,
aDelivery,
aDeliveryStatus,
aSender,
aReceiver,
aBody,
aMessageClass,
aTimestamp,
aRead,
aCx,
aMessage);
}
NS_IMETHODIMP
MobileMessageService::CreateMmsMessage(int32_t aId,
uint64_t aThreadId,
const nsAString& aDelivery,
const JS::Value& aDeliveryStatus,
const nsAString& aSender,
const JS::Value& aReceivers,
const JS::Value& aTimestamp,
bool aRead,
const nsAString& aSubject,
const nsAString& aSmil,
const JS::Value& aAttachments,
const JS::Value& aExpiryDate,
JSContext* aCx,
nsIDOMMozMmsMessage** aMessage)
{
return MmsMessage::Create(aId,
aThreadId,
aDelivery,
aDeliveryStatus,
aSender,
aReceivers,
aTimestamp,
aRead,
aSubject,
aSmil,
aAttachments,
aExpiryDate,
aCx,
aMessage);
}
NS_IMETHODIMP
MobileMessageService::CreateSmsSegmentInfo(int32_t aSegments,
int32_t aCharsPerSegment,
int32_t aCharsAvailableInLastSegment,
nsIDOMMozSmsSegmentInfo** aSegmentInfo)
{
nsCOMPtr<nsIDOMMozSmsSegmentInfo> info =
new SmsSegmentInfo(aSegments, aCharsPerSegment, aCharsAvailableInLastSegment);
info.forget(aSegmentInfo);
return NS_OK;
}
NS_IMETHODIMP
MobileMessageService::CreateThread(uint64_t aId,
const JS::Value& aParticipants,
const JS::Value& aTimestamp,
const nsAString& aBody,
uint64_t aUnreadCount,
const nsAString& aLastMessageType,
JSContext* aCx,
nsIDOMMozMobileMessageThread** aThread)
{
return MobileMessageThread::Create(aId,
aParticipants,
aTimestamp,
aBody,
aUnreadCount,
aLastMessageType,
aCx,
aThread);
}
} // namespace mobilemessage
} // namespace dom
} // namespace mozilla
| 40.251969
| 84
| 0.430751
|
wilebeast
|
7a623faa989e4f1123ac07e2c079ecb7ae20b16c
| 81
|
cpp
|
C++
|
src/SystemQ/Tests/TestString.cpp
|
BclEx/GpuStructs
|
b93acb1c7196477d1d023453a75b480f75cdd29a
|
[
"MIT"
] | null | null | null |
src/SystemQ/Tests/TestString.cpp
|
BclEx/GpuStructs
|
b93acb1c7196477d1d023453a75b480f75cdd29a
|
[
"MIT"
] | null | null | null |
src/SystemQ/Tests/TestString.cpp
|
BclEx/GpuStructs
|
b93acb1c7196477d1d023453a75b480f75cdd29a
|
[
"MIT"
] | null | null | null |
#include "..\..\System\System.h"
using namespace Sys;
void TestString()
{
}
| 13.5
| 33
| 0.62963
|
BclEx
|
7a64a80c254b19d758af298820082f7908506da9
| 2,927
|
hpp
|
C++
|
include/yymp/tuple_traits.hpp
|
surrealwaffle/yymp
|
662def34a298bf2992bf429e26bc35605906897b
|
[
"BSL-1.0"
] | 1
|
2020-04-02T12:37:58.000Z
|
2020-04-02T12:37:58.000Z
|
include/yymp/tuple_traits.hpp
|
surrealwaffle/yymp
|
662def34a298bf2992bf429e26bc35605906897b
|
[
"BSL-1.0"
] | null | null | null |
include/yymp/tuple_traits.hpp
|
surrealwaffle/yymp
|
662def34a298bf2992bf429e26bc35605906897b
|
[
"BSL-1.0"
] | 1
|
2018-11-22T10:36:37.000Z
|
2018-11-22T10:36:37.000Z
|
// SPDX-License-Identifier: BSL-1.0
#ifndef YYMP_TUPLE_TRAITS_HPP
#define YYMP_TUPLE_TRAITS_HPP
#include <type_traits>
#include <utility>
#include <yymp/dtl/piecewise_reinitializable.hpp>
namespace yymp
{
/**
* \brief Determines if all the element types of a \a Tuple have a
* constructor that accepts the elements extracted from a \a Tuple,
* as if synthesized by `std::declval<Tuple>()`.
*/
template<typename Tuple>
struct is_piecewise_reinitializable
: ::yymp::dtl::tuple_traits::is_piecewise_reinitializable<
Tuple
> { };
/**
* \brief Determines if all the element types of a \a Tuple have a
* constructor that accepts the elements extracted from a \a Tuple,
* as if synthesized by `std::declval<Tuple>()`, which is known to
* not throw any exceptions.
*/
template<typename Tuple>
struct is_piecewise_nothrow_reinitializable
: ::yymp::dtl::tuple_traits::is_piecewise_nothrow_reinitializable<
Tuple
> { };
/**
* \brief Constraint for #is_piecewise_reinitializable.
*/
template<typename Tuple>
concept piecewise_reinitializable
= is_piecewise_reinitializable<Tuple>::value;
/**
* \brief Constraint for #is_piecewise_nothrow_reinitializable.
*/
template<typename Tuple>
concept piecewise_nothrow_reinitializable
= is_piecewise_nothrow_reinitializable<Tuple>::value;
// =========================================================================
// The following specializations provide massive improvements in compile
// times when used in certain pathological cases.
// These specializations drastically reduce the quadratic term involved in
// many chained stuple_cats.
template<typename... Types>
struct is_piecewise_reinitializable<const stuple<Types...>&>
: ::std::is_copy_constructible<stuple<Types...>>::type { };
template<typename... Types>
struct is_piecewise_reinitializable<stuple<Types...>&&>
: ::std::is_move_constructible<stuple<Types...>>::type { };
template<typename... Types>
struct is_piecewise_reinitializable<stuple<Types...>>
: ::std::is_move_constructible<stuple<Types...>>::type { };
template<typename... Types>
struct is_piecewise_nothrow_reinitializable<const stuple<Types...>&>
: ::std::is_nothrow_copy_constructible<stuple<Types...>>::type { };
template<typename... Types>
struct is_piecewise_nothrow_reinitializable<stuple<Types...>&&>
: ::std::is_nothrow_move_constructible<stuple<Types...>>::type { };
template<typename... Types>
struct is_piecewise_nothrow_reinitializable<stuple<Types...>>
: ::std::is_nothrow_move_constructible<stuple<Types...>>::type { };
}
#endif // YYMP_TUPLE_TRAITS_HPP
| 36.135802
| 80
| 0.648446
|
surrealwaffle
|
7a64f04ef2624374202d9ca9d502f5ef86067df8
| 2,533
|
cpp
|
C++
|
firmware/remote_logger/src/envsensor.cpp
|
oxullo/envlogger
|
736efd5dfe74fd62bc3ae18a04f73dbf5c4402cf
|
[
"MIT"
] | null | null | null |
firmware/remote_logger/src/envsensor.cpp
|
oxullo/envlogger
|
736efd5dfe74fd62bc3ae18a04f73dbf5c4402cf
|
[
"MIT"
] | null | null | null |
firmware/remote_logger/src/envsensor.cpp
|
oxullo/envlogger
|
736efd5dfe74fd62bc3ae18a04f73dbf5c4402cf
|
[
"MIT"
] | null | null | null |
// Copyright (c) 2020 OXullo Intersecans <x@brainrapers.org>
//
// 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 <stdint.h>
#include <Adafruit_BME680.h>
#include "envsensor.h"
const uint8_t BME680_I2C_ADDRESS = 0x76;
Adafruit_BME680 bme;
void envsensor_init(bool init_vco)
{
while (!bme.begin(BME680_I2C_ADDRESS)) {
Serial.println("Could not find a valid BME680 sensor, check wiring!");
delay(1000);
}
// Slowest filtering, reducing jitters
bme.setTemperatureOversampling(BME680_OS_16X);
bme.setHumidityOversampling(BME680_OS_16X);
bme.setPressureOversampling(BME680_OS_16X);
bme.setIIRFilterSize(BME680_FILTER_SIZE_127);
if (init_vco) {
bme.setGasHeater(320, 150); // 320*C for 150 ms
} else {
bme.setGasHeater(0, 0); // Disable VOC sampling
}
}
void envsensor_update()
{
if (!bme.performReading()) {
Serial.println("BME680: Failed to perform reading");
return;
}
}
void envsensor_dump()
{
String s;
s += "BME680: Ta=" + String(bme.temperature);
s += "C Pa=" + String(bme.pressure / 100.0);
s += "hPa RH=" + String(bme.humidity);
s += "% VCOR=" + String(bme.gas_resistance / 1000.0) + "kOhm";
Serial.println(s);
}
float envsensor_get_ta()
{
return bme.temperature;
}
float envsensor_get_pa()
{
return bme.pressure / 100.0;
}
float envsensor_get_rh()
{
return bme.humidity;
}
float envsensor_get_vocr()
{
return bme.gas_resistance / 1000.0;
}
| 27.532609
| 81
| 0.705488
|
oxullo
|
7a6676d207ea7e25a296d3e59a3aa340d66d3755
| 2,319
|
cpp
|
C++
|
src/c++/test-blackbox/test_grm.cpp
|
vb-wayne/paragraph
|
3f6f6f7a2a3ac209c7dbb21487ca4d9eaed5c14c
|
[
"Apache-2.0"
] | 111
|
2017-11-24T18:22:50.000Z
|
2022-02-25T07:55:31.000Z
|
src/c++/test-blackbox/test_grm.cpp
|
vb-wayne/paragraph
|
3f6f6f7a2a3ac209c7dbb21487ca4d9eaed5c14c
|
[
"Apache-2.0"
] | 61
|
2018-01-01T19:58:06.000Z
|
2022-03-09T12:01:17.000Z
|
src/c++/test-blackbox/test_grm.cpp
|
vb-wayne/paragraph
|
3f6f6f7a2a3ac209c7dbb21487ca4d9eaed5c14c
|
[
"Apache-2.0"
] | 30
|
2018-03-01T04:41:15.000Z
|
2022-03-11T14:52:03.000Z
|
// -*- mode: c++; indent-tabs-mode: nil; -*-
//
// Paragraph
// Copyright (c) 2016-2019 Illumina, 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
//
//
#include "gtest/gtest.h"
#include <iostream>
#include <sstream>
#include <string>
#include "common.hh"
#include "common/BamReader.hh"
#include "grmpy/AlignSamples.hh"
#include "grmpy/CountAndGenotype.hh"
#include "grmpy/Parameters.hh"
#include "json/json.h"
TEST(Grmpy, GenotypesSingleSwap)
{
std::string graph_path
= g_testenv->getBasePath() + "/../share/test-data/paragraph/long-del/chrX_graph_typing.2sample.json";
std::string reference_path
= g_testenv->getBasePath() + "/../share/test-data/paragraph/long-del/chrX_graph_typing.fa";
std::string manifest_path
= g_testenv->getBasePath() + "/../share/test-data/paragraph/long-del/chrX_graph_typing.manifest";
std::string genotype_parameter_path
= g_testenv->getBasePath() + "/../share/test-data/paragraph/long-del/param.json";
grmpy::Parameters parameters;
genotyping::Samples samples = genotyping::loadManifest(manifest_path);
for (auto& sample : samples)
{
common::BamReader reader(sample.filename(), sample.index_filename(), reference_path);
alignSingleSample(parameters, graph_path, reference_path, reader, sample);
}
const Json::Value genotype = grmpy::countAndGenotype(graph_path, reference_path, genotype_parameter_path, samples);
std::stringstream out_stream;
out_stream << genotype;
std::istream* json_stream = &out_stream;
Json::Value result;
(*json_stream) >> result;
EXPECT_EQ("REF", result["samples"]["SAMPLE1"]["gt"]["GT"].asString());
EXPECT_EQ("REF/REF", result["samples"]["SAMPLE2"]["gt"]["GT"].asString());
std::cout << out_stream.str() << std::endl;
}
| 34.61194
| 119
| 0.70332
|
vb-wayne
|
7a67766090afef799d346fdab933e2ea72ebe750
| 5,253
|
cpp
|
C++
|
examples/imageblit/src/main.cpp
|
mmertama/Telex-framework
|
289b04794baaa0c37e909e50bc0989d806797e1c
|
[
"MIT"
] | 1
|
2020-07-01T20:34:34.000Z
|
2020-07-01T20:34:34.000Z
|
examples/imageblit/src/main.cpp
|
mmertama/Telex-framework
|
289b04794baaa0c37e909e50bc0989d806797e1c
|
[
"MIT"
] | null | null | null |
examples/imageblit/src/main.cpp
|
mmertama/Telex-framework
|
289b04794baaa0c37e909e50bc0989d806797e1c
|
[
"MIT"
] | 1
|
2020-03-24T14:12:39.000Z
|
2020-03-24T14:12:39.000Z
|
#include "gempyre_graphics.h"
#include "gempyre_utils.h"
#include "imageblit_resource.h"
#include <iostream>
using namespace std::chrono_literals;
void writeText(int x, int y, const std::string& text, Gempyre::CanvasElement& el) {
el.ui().beginBatch();
const auto width = 1000. / 9.;
const auto height = 1000. / 9.;
auto caret = x;
for(const auto& c : text) {
if(c >= 'a' && c <= 'z') {
const int row = (c - 'a') % 9;
const int col = (c - 'a') / 9;
el.paintImage("salcat", {caret, y, 20, 20}, {
static_cast<int>(row * width),
static_cast<int>(col * height),
static_cast<int>(width),
static_cast<int>(height)});
}
if(c == '\n') {
y += 20;
caret = x;
} else
caret += 20;
}
el.ui().endBatch();
}
int main(int argc, char** argv) {
// Gempyre::setDebug();
const auto args = GempyreUtils::parseArgs(argc, argv, {{"resources", 'r', GempyreUtils::ArgType::REQ_ARG}});
const auto options = std::get<GempyreUtils::Options>(args);
const auto it = options.find("resources");
const auto root = (it != options.end()) ? (it->second + "/") : std::string("");
Gempyre::Ui ui({{"/imageblit.html", Imageblithtml}, {"/owl.png", Owlpng}}, "imageblit.html", "", "", Gempyre::Ui::UseDefaultPort, root);
Gempyre::CanvasElement canvas(ui, "canvas");
//Five ways to load image
//1) external resource using http/https from somewhere
ui.after(2000ms, [&canvas]() {
writeText(0, 40, "the beach\nis place\nto be\npalm to\nstay under\nthe sea\nand sand", canvas);
});
//2) via baked in resource (this image is added in above)
canvas.addImage("/owl.png", [&canvas](const auto id){
canvas.paintImage(id, {200, 0, 200, 200});
});
//3). via page and add as a resources
ui.after(2000ms, [&canvas]() {
canvas.paintImage("some_sceneid", {0, 200, 200, 200});
});
/* This does not work
Gempyre::Element(ui, "some_sceneid").subscribe("load", [&canvas] (const Gempyre::Element::Event&){
canvas.paintImage("some_sceneid", {0, 200, 200, 200});
});
*/
const auto simage1 = root + "free-scenery-7.jpg";
if(GempyreUtils::fileExists(simage1)) {
if(!ui.addFile("/scene.jpg", simage1)) {
std::cerr << "Cannot load " << simage1 << " (try: -r <PATH TO>/Gempyre-framework/test/imageblit/stuff)" << std::endl;
return -1;
}
} else ui.alert(simage1 + " not found!");
//4) add as resource and image
const auto simage2 = root + "tom-hanssens-shot-01.jpg";
if(GempyreUtils::fileExists(simage2)) {
if(!ui.addFile("/scene2.jpg", simage2)) {
std::cerr << "Cannot load " << simage2 << " (try: -r <PATH TO>/Gempyre-framework/test/imageblit/stuff)" << std::endl;
return -1;
}
} else ui.alert(simage2 + " not found!");
canvas.addImage("/scene2.jpg", [&canvas](const auto& scene){
canvas.paintImage(scene, {200, 200, 200, 200});
});
//5) local file - see root parameter in constructor (assuming it is set correctly here to imageblit/stuff folder)
ui.after(3000ms, [&canvas]() {
canvas.paintImage("huld", {0, 400, 200, 200});
});
auto frame = 0U;
canvas.addImage("leigh-kellogg-captainamerica-poseframes-2.jpg", [&canvas, &ui, &frame](const auto& marica){
ui.startPeriodic(50ms, [&canvas, &frame, marica]{
const std::vector<Gempyre::Element::Rect> frames{
{100, 300, 248, 344},
{348, 300, 282, 344},
{616, 300, 278, 344},
{880, 300, 278, 344},
{1200, 300, 300, 344},
{1518, 300, 300, 344},
{100, 806, 248, 344},
{378, 806, 282, 344},
{656, 806, 282, 344},
{944, 806, 286, 344},
{100, 1314, 248, 344},
{378, 1314, 278, 344},
{656, 1314, 278, 344},
{945, 1314, 330, 344},
{1300, 1314, 330, 344},
{100, 1832, 248, 344},
{378, 1832, 278, 344},
{678, 1832, 284, 344},
{964, 1832, 320, 344},
{1295, 1832, 320, 344},
};
/* for(int i = 0; i < 6; i++){
canvas.paintImage(marica, {i * 50, 0, 49, 49}, frames.at(i));
}
for(int i = 0; i < 4; i++){
canvas.paintImage(marica, {i * 50, 50, 49, 49}, frames.at(i + 6));
}
for(int i = 0; i < 5; i++){
canvas.paintImage(marica, {i * 50, 100, 49, 49}, frames.at(i + 10));
}
for(int i = 0; i < 5; i++){
canvas.paintImage(marica, {i * 50, 150, 49, 49}, frames.at(i + 15));
}
*/
if(frame >= frames.size())
frame = 0;
canvas.paintImage(marica, {200, 400, 200, 200}, frames.at(frame));
++frame;
// std::cout << "frame" << frame << std::endl;
});
});
ui.run();
}
| 35.979452
| 140
| 0.50276
|
mmertama
|
7a6ab24202add7216e055b462904e1b4dd699bfb
| 836
|
hpp
|
C++
|
include/md/potential/constant_potential.hpp
|
snsinfu/micromd
|
a886d68d5452800bf342f0db8b477979f9f10a04
|
[
"BSL-1.0"
] | 3
|
2018-12-06T11:45:56.000Z
|
2020-10-09T08:23:03.000Z
|
include/md/potential/constant_potential.hpp
|
snsinfu/micromd
|
a886d68d5452800bf342f0db8b477979f9f10a04
|
[
"BSL-1.0"
] | 14
|
2018-12-02T08:16:16.000Z
|
2020-09-29T18:19:35.000Z
|
include/md/potential/constant_potential.hpp
|
snsinfu/micromd
|
a886d68d5452800bf342f0db8b477979f9f10a04
|
[
"BSL-1.0"
] | null | null | null |
// Copyright snsinfu 2018.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef MD_POTENTIAL_CONSTANT_POTENTIAL_HPP
#define MD_POTENTIAL_CONSTANT_POTENTIAL_HPP
// This module provides constant_potential. Used as defaults and in tests.
#include "../basic_types.hpp"
namespace md
{
// constant_potential is a fixed-value potential energy function:
//
// u(r) = e ,
// F(r) = 0 .
//
struct constant_potential
{
// The constant energy value.
md::scalar energy = 0;
md::scalar evaluate_energy(md::vector) const
{
return energy;
}
md::vector evaluate_force(md::vector) const
{
return {};
}
};
}
#endif
| 22
| 79
| 0.625598
|
snsinfu
|
7a717471d064720669aca5be2b84a34764adc364
| 1,725
|
cpp
|
C++
|
Visual Mercutio/zModel/PSS_SymbolObserverMsg.cpp
|
Jeanmilost/Visual-Mercutio
|
f079730005b6ce93d5e184bb7c0893ccced3e3ab
|
[
"MIT"
] | 1
|
2022-01-31T06:24:24.000Z
|
2022-01-31T06:24:24.000Z
|
Visual Mercutio/zModel/PSS_SymbolObserverMsg.cpp
|
Jeanmilost/Visual-Mercutio
|
f079730005b6ce93d5e184bb7c0893ccced3e3ab
|
[
"MIT"
] | 2
|
2021-04-11T15:50:42.000Z
|
2021-06-05T08:23:04.000Z
|
Visual Mercutio/zModel/PSS_SymbolObserverMsg.cpp
|
Jeanmilost/Visual-Mercutio
|
f079730005b6ce93d5e184bb7c0893ccced3e3ab
|
[
"MIT"
] | 2
|
2021-01-08T00:55:18.000Z
|
2022-01-31T06:24:18.000Z
|
/****************************************************************************
* ==> PSS_SymbolObserverMsg -----------------------------------------------*
****************************************************************************
* Description : Provides a symbol observer message *
* Developer : Processsoft *
****************************************************************************/
#include "stdafx.h"
#include "PSS_SymbolObserverMsg.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#define new DEBUG_NEW
#endif
//---------------------------------------------------------------------------
// Dynamic creation
//---------------------------------------------------------------------------
IMPLEMENT_DYNAMIC(PSS_SymbolObserverMsg, PSS_ObserverMsg)
//---------------------------------------------------------------------------
// PSS_SymbolObserverMsg
//---------------------------------------------------------------------------
PSS_SymbolObserverMsg::PSS_SymbolObserverMsg(IEActionType actionType, CODComponent* pElement) :
PSS_ObserverMsg(),
m_pElement(pElement),
m_ActionType(actionType),
m_SymbolRef(-1)
{}
//---------------------------------------------------------------------------
PSS_SymbolObserverMsg::PSS_SymbolObserverMsg(int symbolRef, IEActionType actionType) :
PSS_ObserverMsg(),
m_pElement(NULL),
m_ActionType(actionType),
m_SymbolRef(symbolRef)
{}
//---------------------------------------------------------------------------
PSS_SymbolObserverMsg::~PSS_SymbolObserverMsg()
{}
//---------------------------------------------------------------------------
| 42.073171
| 95
| 0.364638
|
Jeanmilost
|
7a72a854df113bfab1fc07c9d37e2fe616621124
| 4,648
|
cp
|
C++
|
Win32/Sources/Application/Search/CSearchBase.cp
|
mulberry-mail/mulberry4-client
|
cdaae15c51dd759110b4fbdb2063d0e3d5202103
|
[
"ECL-2.0",
"Apache-2.0"
] | 12
|
2015-04-21T16:10:43.000Z
|
2021-11-05T13:41:46.000Z
|
Win32/Sources/Application/Search/CSearchBase.cp
|
mulberry-mail/mulberry4-client
|
cdaae15c51dd759110b4fbdb2063d0e3d5202103
|
[
"ECL-2.0",
"Apache-2.0"
] | 2
|
2015-11-02T13:32:11.000Z
|
2019-07-10T21:11:21.000Z
|
Win32/Sources/Application/Search/CSearchBase.cp
|
mulberry-mail/mulberry4-client
|
cdaae15c51dd759110b4fbdb2063d0e3d5202103
|
[
"ECL-2.0",
"Apache-2.0"
] | 6
|
2015-01-12T08:49:12.000Z
|
2021-03-27T09:11:10.000Z
|
/*
Copyright (c) 2007 Cyrus Daboo. 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.
*/
// CSearchBase.cp : implementation of the CSearchBase class
//
#include "CSearchBase.h"
#include "CGrayBorder.h"
#include "CMulberryCommon.h"
#include "CSearchCriteriaContainer.h"
/////////////////////////////////////////////////////////////////////////////
// CSearchBase
/////////////////////////////////////////////////////////////////////////////
// CSearchBase construction/destruction
CSearchBase::CSearchBase(bool rules)
{
mRules = rules;
mGroupItems = NULL;
mFilterType = CFilterItem::eLocal;
}
CSearchBase::~CSearchBase()
{
// Always delete criteria items
delete mGroupItems;
}
// Respond to list changes
void CSearchBase::ListenTo_Message(long msg, void* param)
{
// For time being reset entire menu
switch(msg)
{
case CSearchCriteriaContainer::eBroadcast_SearchCriteriaContainerResized:
// Change the size of this one
Resized(*reinterpret_cast<unsigned long*>(param));
break;
default:;
}
}
// Activate search item
void CSearchBase::DoActivate()
{
// Active first criteria that wants to acticate
//if (mGroupItems)
// mGroupItems->DoActivate();
}
void CSearchBase::OnMore()
{
AddCriteria();
}
void CSearchBase::OnFewer()
{
RemoveCriteria();
}
void CSearchBase::OnClear()
{
// Remove all
while(mGroupItems->GetCount() > 0)
RemoveCriteria();
// Reset the first one
AddCriteria();
}
#pragma mark ____________________________Criteria Panels
const int cCriteriaPanelHeight = 46;
const int cCriteriaPanelWidth = 460;
const int cCriteriaHOffset = 4;
const int cCriteriaVInitOffset = 14;
void CSearchBase::MakeGroup()
{
if (mGroupItems != NULL)
return;
mGroupItems = new CSearchCriteriaContainer;
CRect gsize;
gsize.left = cCriteriaHOffset;
gsize.right = gsize.left + cCriteriaPanelWidth;
gsize.top = cCriteriaVInitOffset;
gsize.bottom = gsize.top + cCriteriaPanelHeight;
mGroupItems->SetTopLevel();
mGroupItems->SetRules(mRules);
mGroupItems->Create(gsize, GetContainerWnd());
mGroupItems->InitGroup(mFilterType, NULL);
static_cast<CGrayBorder*>(GetContainerWnd())->AddAlignment(new CWndAlignment(mGroupItems, CWndAlignment::eAlign_TopWidth));
// Get size after init'ing the group
mGroupItems->GetWindowRect(gsize);
// Set group width based on parent
CRect size;
GetContainerWnd()->GetWindowRect(size);
::ResizeWindowBy(mGroupItems, size.Width() - 2 * cCriteriaHOffset - gsize.Width(), 0, false);
// Increase the size of this one
Resized(gsize.Height());
// Position new sub-panel
mGroupItems->ShowWindow(SW_SHOW);
mGroupItems->Add_Listener(this);
}
void CSearchBase::InitCriteria(const CSearchItem* spec)
{
// Always make the group - it will only be done if not done already
MakeGroup();
// Pass to the group
RemoveAllCriteria();
mGroupItems->InitCriteria(spec);
// Do button state
if (mGroupItems->GetCount() > 1)
GetFewerBtn()->ShowWindow(SW_SHOW);
}
void CSearchBase::AddCriteria(const CSearchItem* spec, bool use_or)
{
// Pass to the group
if (mGroupItems)
mGroupItems->AddCriteria(spec, use_or);
// Do button state
if (mGroupItems->GetCount() > 1)
GetFewerBtn()->ShowWindow(SW_SHOW);
}
void CSearchBase::RemoveCriteria()
{
// Pass to the group
if (mGroupItems)
mGroupItems->RemoveCriteria();
// Do button state
if (mGroupItems->GetCount() < 2)
GetFewerBtn()->ShowWindow(SW_HIDE);
}
void CSearchBase::RemoveAllCriteria()
{
// Remove all
if (mGroupItems)
{
while(mGroupItems->GetCount() > 0)
RemoveCriteria();
}
// Do button state
GetFewerBtn()->ShowWindow(SW_HIDE);
}
void CSearchBase::SelectNextCriteria(CSearchCriteria* previous)
{
// Pass to the group
if (mGroupItems)
mGroupItems->SelectNextCriteria(previous);
}
#pragma mark ____________________________Build Search
CSearchItem* CSearchBase::ConstructSearch() const
{
// Pass to the group
return mGroupItems->ConstructSearch();
}
| 24.335079
| 125
| 0.68395
|
mulberry-mail
|
7a7b9a40f3d5ad192a99cd40f36478213ba5e945
| 1,166
|
cpp
|
C++
|
4-Array/06.cpp
|
chshzhe/CppReference
|
f67c50696ad0f4874f23659cab72f25ca989f614
|
[
"Unlicense"
] | 4
|
2021-12-03T06:26:06.000Z
|
2022-01-15T12:15:23.000Z
|
4-Array/06.cpp
|
chshzhe/CppReference
|
f67c50696ad0f4874f23659cab72f25ca989f614
|
[
"Unlicense"
] | null | null | null |
4-Array/06.cpp
|
chshzhe/CppReference
|
f67c50696ad0f4874f23659cab72f25ca989f614
|
[
"Unlicense"
] | null | null | null |
#include <iostream>
using namespace std;
int main()
{
int B;
cin >> B;
for (int i = 1; i <= 200; i++)
{
int temp = i * i;
int top = 0;
int a[20];
while (temp)
{
a[top++] = temp % B;
temp /= B;
}
bool flag = true;
for (int j = 0; j < top; j++)
{
if (a[j] != a[top - 1 - j])
{
flag = false;
break;
}
}
if (flag)
{
int temp = i;
int top_2 = 0;
int b[20];
while (temp)
{
b[top_2++] = temp % B;
temp /= B;
}
for (int j = top_2 - 1; j >= 0; j--)
if (b[j] < 10)
cout << b[j];
else
cout << char(b[j] - 10 + 'A');
cout
<< ' ';
for (int j = top - 1; j >= 0; j--)
if (a[j] < 10)
cout << a[j];
else
cout << char(a[j] - 10 + 'A');
cout << endl;
}
}
}
| 22.423077
| 50
| 0.264151
|
chshzhe
|
7a7b9e35307bee0c3702690909989691ff8058f8
| 438
|
hpp
|
C++
|
src/libs/input/bound/keyboard_button_binding.hpp
|
jdmclark/gorc
|
a03d6a38ab7684860c418dd3d2e77cbe6a6d9fc8
|
[
"Apache-2.0"
] | 97
|
2015-02-24T05:09:24.000Z
|
2022-01-23T12:08:22.000Z
|
src/libs/input/bound/keyboard_button_binding.hpp
|
annnoo/gorc
|
1889b4de6380c30af6c58a8af60ecd9c816db91d
|
[
"Apache-2.0"
] | 8
|
2015-03-27T23:03:23.000Z
|
2020-12-21T02:34:33.000Z
|
src/libs/input/bound/keyboard_button_binding.hpp
|
annnoo/gorc
|
1889b4de6380c30af6c58a8af60ecd9c816db91d
|
[
"Apache-2.0"
] | 10
|
2016-03-24T14:32:50.000Z
|
2021-11-13T02:38:53.000Z
|
#pragma once
#include "input_binding.hpp"
#include "button_bindable_command.hpp"
namespace gorc {
class keyboard_button_binding : public input_binding {
private:
keyboard_key bound_key;
button_bindable_command &command;
public:
keyboard_button_binding(button_bindable_command &command, keyboard_key bound_key);
virtual void handle_keyboard_input(time_delta, keyboard&) override;
};
}
| 21.9
| 90
| 0.73516
|
jdmclark
|
7a7e96866bdfc540dc1382f581a7870b8c8d9a41
| 220
|
cpp
|
C++
|
app/main.cpp
|
ChinYing-Li/OpenGL-cart
|
2625dfb194a65d6b277f6c3c57602319000bce16
|
[
"MIT"
] | 2
|
2021-06-03T03:36:35.000Z
|
2021-09-18T07:25:24.000Z
|
app/main.cpp
|
ChinYing-Li/OpenGL-cart
|
2625dfb194a65d6b277f6c3c57602319000bce16
|
[
"MIT"
] | null | null | null |
app/main.cpp
|
ChinYing-Li/OpenGL-cart
|
2625dfb194a65d6b277f6c3c57602319000bce16
|
[
"MIT"
] | null | null | null |
#include <memory>
#include "app.h"
int main(int argc, char **argv)
{
App application;
bool init_success = application.begin(argc, argv);
if(!init_success) return 1;
application.loop();
return 0;
}
| 15.714286
| 54
| 0.65
|
ChinYing-Li
|
7a8652c4bc66d131a5e3809f07d917a863f956fd
| 3,675
|
cpp
|
C++
|
src/Source/DxbcContainer.cpp
|
tgjones/slimshader-cpp
|
a1833e2eccf32cccfe33aa7613772503eca963ee
|
[
"MIT"
] | 20
|
2015-03-29T02:14:03.000Z
|
2021-11-14T12:27:02.000Z
|
src/Source/DxbcContainer.cpp
|
tgjones/slimshader-cpp
|
a1833e2eccf32cccfe33aa7613772503eca963ee
|
[
"MIT"
] | null | null | null |
src/Source/DxbcContainer.cpp
|
tgjones/slimshader-cpp
|
a1833e2eccf32cccfe33aa7613772503eca963ee
|
[
"MIT"
] | 12
|
2015-05-04T06:39:10.000Z
|
2022-02-23T06:48:04.000Z
|
#include "PCH.h"
#include "DxbcContainer.h"
#include "DxbcChunk.h"
#include "InputSignatureChunk.h"
#include "InterfacesChunk.h"
#include "OutputSignatureChunk.h"
#include "PatchConstantSignatureChunk.h"
#include "ResourceDefinitionChunk.h"
#include "ShaderProgramChunk.h"
#include "StatisticsChunk.h"
using namespace boolinq;
using namespace std;
using namespace SlimShader;
DxbcContainer DxbcContainer::Parse(const vector<char> bytes)
{
const uint8_t* bytesPointer = reinterpret_cast<const uint8_t*>(&bytes[0]);
return Parse(BytecodeReader(bytesPointer, bytes.size()));
}
DxbcContainer DxbcContainer::Parse(BytecodeReader& reader)
{
DxbcContainer container;
BytecodeReader headerReader(reader);
container._header = DxbcContainerHeader::Parse(headerReader);
for (uint32_t i = 0; i < container._header.GetChunkCount(); i++)
{
auto chunkOffset = headerReader.ReadUInt32();
auto chunkReader = reader.CopyAtOffset(chunkOffset);
container._chunks.push_back(DxbcChunk::Parse(chunkReader, container));
}
return container;
}
template <class T>
const shared_ptr<T> FindChunk(vector<shared_ptr<DxbcChunk>> chunks, ChunkType type1, ChunkType type2 = ChunkType::Unknown)
{
// Not quite as nice as chunks.OfType<ResourceDefinitionChunk>().FirstOrDefault(), but never mind...
auto matchingChunks = from(chunks)
.where([type1, type2](shared_ptr<DxbcChunk> chunk) { return chunk->GetChunkType() == type1 || chunk->GetChunkType() == type2; })
.toVector();
if (!matchingChunks.empty())
return dynamic_pointer_cast<T>(matchingChunks[0]);
return nullptr;
}
const shared_ptr<ResourceDefinitionChunk> DxbcContainer::GetResourceDefinition() const
{
return FindChunk<ResourceDefinitionChunk>(_chunks, ChunkType::Rdef);
}
const std::shared_ptr<PatchConstantSignatureChunk> DxbcContainer::GetPatchConstantSignature() const
{
return FindChunk<PatchConstantSignatureChunk>(_chunks, ChunkType::Pcsg);
}
const std::shared_ptr<InputSignatureChunk> DxbcContainer::GetInputSignature() const
{
return FindChunk<InputSignatureChunk>(_chunks, ChunkType::Isgn);
}
const std::shared_ptr<OutputSignatureChunk> DxbcContainer::GetOutputSignature() const
{
return FindChunk<OutputSignatureChunk>(_chunks, ChunkType::Osgn, ChunkType::Osg5);
}
const std::shared_ptr<ShaderProgramChunk> DxbcContainer::GetShader() const
{
return FindChunk<ShaderProgramChunk>(_chunks, ChunkType::Shdr, ChunkType::Shex);
}
const std::shared_ptr<StatisticsChunk> DxbcContainer::GetStatistics() const
{
return FindChunk<StatisticsChunk>(_chunks, ChunkType::Stat);
}
const std::shared_ptr<InterfacesChunk> DxbcContainer::GetInterfaces() const
{
return FindChunk<InterfacesChunk>(_chunks, ChunkType::Ifce);
}
ostream& SlimShader::operator<<(ostream &out, const DxbcContainer &container)
{
out << "// " << endl;
out << "// Generated by SlimShader" << endl;
out << "// " << endl;
out << "// " << endl;
out << "// " << endl;
out << "//" << endl;
out << "//" << endl;
if (container.GetResourceDefinition() != nullptr)
out << *container.GetResourceDefinition();
out << "//" << endl;
if (container.GetPatchConstantSignature() != nullptr)
{
out << *container.GetPatchConstantSignature();
out << "//" << endl;
}
out << *container.GetInputSignature();
out << "//" << endl;
out << *container.GetOutputSignature();
if (container.GetStatistics() != nullptr)
out << *container.GetStatistics();
if (container.GetInterfaces() != nullptr)
out << *container.GetInterfaces();
if (container.GetShader() != nullptr)
out << *container.GetShader();
out << "// Approximately " << container.GetStatistics()->GetInstructionCount() << " instruction slots used";
return out;
}
| 29.166667
| 130
| 0.742041
|
tgjones
|
185205a9384f4ed3f355c5971d862b49d88d9f77
| 283
|
cxx
|
C++
|
src/sort_and_index/ext_sort/mrg_npasses.cxx
|
Caltech-IPAC/libtinyhtm
|
abc3394f3d37b3729a625989d2fc144f14a7d208
|
[
"BSD-3-Clause"
] | 1
|
2019-06-17T21:56:31.000Z
|
2019-06-17T21:56:31.000Z
|
src/sort_and_index/ext_sort/mrg_npasses.cxx
|
Caltech-IPAC/libtinyhtm
|
abc3394f3d37b3729a625989d2fc144f14a7d208
|
[
"BSD-3-Clause"
] | null | null | null |
src/sort_and_index/ext_sort/mrg_npasses.cxx
|
Caltech-IPAC/libtinyhtm
|
abc3394f3d37b3729a625989d2fc144f14a7d208
|
[
"BSD-3-Clause"
] | null | null | null |
/* Computes the number of k-way merge passes required to sort n items,
i.e. the ceiling of the base-k logarithm of n.
*/
#include <cstddef>
int mrg_npasses (size_t n, size_t k)
{
int m = 1;
size_t b = k;
while (b < n)
{
b *= k;
++m;
}
return m;
}
| 15.722222
| 71
| 0.565371
|
Caltech-IPAC
|
185332dd40e3656bccc9b216e5b36d096882b5ad
| 473
|
cpp
|
C++
|
cpp14faqs/code/c++14/product_vector3.cpp
|
ancientscience/ancientscience.github.io
|
2c8e3c6a8017164fd86fabaaa3343257cea54405
|
[
"MIT"
] | null | null | null |
cpp14faqs/code/c++14/product_vector3.cpp
|
ancientscience/ancientscience.github.io
|
2c8e3c6a8017164fd86fabaaa3343257cea54405
|
[
"MIT"
] | null | null | null |
cpp14faqs/code/c++14/product_vector3.cpp
|
ancientscience/ancientscience.github.io
|
2c8e3c6a8017164fd86fabaaa3343257cea54405
|
[
"MIT"
] | null | null | null |
#include <vector>
#include <algorithm>
#include <iostream>
constexpr struct
{
template< class X, class Y >
auto operator () ( X x, Y y )
-> decltype(x*y)
{
return x * y;
}
} multOp{};
int main()
{
std::vector<int> v{1, 2, 3, 4, 5};
auto prod =
std::accumulate(v.begin(), v.end(),
1,
multOp
);
std::cout << "product : " << prod << std::endl;
}
| 18.192308
| 51
| 0.437632
|
ancientscience
|
185775db6e36148ae69ca118bcc60ec1aad7f6b7
| 2,430
|
cpp
|
C++
|
Week02/src/Graph.cpp
|
exp-3/ArtificialIntelligence
|
7edb258a00998181426906c9276afe09ce91ad9d
|
[
"MIT"
] | null | null | null |
Week02/src/Graph.cpp
|
exp-3/ArtificialIntelligence
|
7edb258a00998181426906c9276afe09ce91ad9d
|
[
"MIT"
] | null | null | null |
Week02/src/Graph.cpp
|
exp-3/ArtificialIntelligence
|
7edb258a00998181426906c9276afe09ce91ad9d
|
[
"MIT"
] | null | null | null |
#include "Graph.hpp"
#include <random>
#include <iostream>
Graph::Graph() {
;
}
void Graph::set(vector<Point> &virtices, vector<vector<int>> &adjacency) {
Graph::virtices_num = virtices.size();
Graph::virtices = virtices;
Graph::adjacency = adjacency;
}
void Graph::set_random(int virtices_num) {
Graph::virtices_num = virtices_num;
virtices.resize(virtices_num);
adjacency = vector<vector<int>>(virtices_num, vector<int>(virtices_num, 0));
random_device seed_gen;
default_random_engine engine(seed_gen());
uniform_real_distribution<> dist(-1, 1);
for(int i = 0; i < virtices_num; i++) {
virtices[i].x = dist(engine);
virtices[i].y = dist(engine);
}
// ドロネー三角分割による平面グラフと隣接行列の生成
double epsilon = 1e-6;
for(int i = 0; i < virtices_num - 2; i++) {
Point v1 = virtices[i];
for(int j = i + 1; j < virtices_num - 1; j++) {
Point v2 = virtices[j];
for(int k = j + 1; k < virtices_num; k++) {
Point v3 = virtices[k];
double tmp = 2.0*((v2.x-v1.x)*(v3.y-v1.y)-(v2.y-v1.y)*(v3.x-v1.x));
Point center = {((v3.y-v1.y)*(v2.x*v2.x-v1.x*v1.x+v2.y*v2.y-v1.y*v1.y)+
(v1.y-v2.y)*(v3.x*v3.x-v1.x*v1.x+v3.y*v3.y-v1.y*v1.y))/tmp,
((v1.x-v3.x)*(v2.x*v2.x-v1.x*v1.x+v2.y*v2.y-v1.y*v1.y)+
(v2.x-v1.x)*(v3.x*v3.x-v1.x*v1.x+v3.y*v3.y-v1.y*v1.y))/tmp};
double r = center.distance(v1) - epsilon;
bool flag = true;
for(int l = 0; l < virtices_num; l++) {
if(center.distance(virtices[l]) < r) {
flag = false;
break;
}
}
if(flag) {
adjacency[i][j] = 1;
adjacency[i][k] = 1;
adjacency[j][k] = 1;
adjacency[j][i] = 1;
adjacency[k][i] = 1;
adjacency[k][j] = 1;
}
}
}
}
cout << "==== virtices ====" << endl;
for(int i = 0; i < virtices_num; i++) {
cout << "(" << virtices[i].x << ", " << virtices[i].y << ")" << endl;
}
cout << endl;
cout << "==== adjacency ====" << endl;
for(int i = 0; i < virtices_num; i++) {
cout << adjacency[i][0];
for(int j = 0; j < virtices_num; j++) {
cout << ", " << adjacency[i][j];
}
cout << endl;
}
}
int Graph::get_virtices_num() {
return virtices_num;
}
Point &Graph::get_virtex(int virtex_id) {
return virtices[virtex_id];
}
int Graph::get_adjacency(int m, int n) {
return adjacency[m][n];
}
| 25.851064
| 79
| 0.537037
|
exp-3
|
1857ad89bf1290ff8d86c8522e191f543c622fcd
| 4,643
|
cpp
|
C++
|
CanadianExperience/CanadianExperience/CanadianExperience/HeadTop.cpp
|
NicholsTyler/cse_335
|
b8a46522c15a9881cb681ae94b4a5f737817b05e
|
[
"MIT"
] | null | null | null |
CanadianExperience/CanadianExperience/CanadianExperience/HeadTop.cpp
|
NicholsTyler/cse_335
|
b8a46522c15a9881cb681ae94b4a5f737817b05e
|
[
"MIT"
] | null | null | null |
CanadianExperience/CanadianExperience/CanadianExperience/HeadTop.cpp
|
NicholsTyler/cse_335
|
b8a46522c15a9881cb681ae94b4a5f737817b05e
|
[
"MIT"
] | null | null | null |
#include "pch.h"
#include "HeadTop.h"
#include "Actor.h"
#include "Timeline.h"
#include <sstream>
#include <iomanip>
using namespace Gdiplus;
using namespace std;
/// Constant ratio to convert radians to degrees
const double RtoD = 57.295779513;
/** Constructor for a top of the head object
* \param name The drawable name to use
* \param filename The filename for the image to use
*/
CHeadTop::CHeadTop(const std::wstring &name, const std::wstring &filename) : CImageDrawable(name, filename)
{
}
/**
* Destructor
*/
CHeadTop::~CHeadTop()
{
}
/**
* Set the actor. This is where we set the channel name
* \param actor Actor to set
*/
void CHeadTop::SetActor(CActor *actor)
{
CImageDrawable::SetActor(actor);
// Set the channel name
mPositionChannel.SetName(actor->GetName() + L":" + GetName() + L":position");
}
/**
* Set the timeline. The tells the channel the timeline
* \param timeline Timeline to set
*/
void CHeadTop::SetTimeline(CTimeline *timeline)
{
CImageDrawable::SetTimeline(timeline);
timeline->AddChannel(&mPositionChannel);
}
/** Set the keyframe based on the current status.
*/
void CHeadTop::SetKeyframe()
{
CImageDrawable::SetKeyframe();
mPositionChannel.SetKeyframe(GetPosition());
}
/** Get the current channel from the animation system.
*/
void CHeadTop::GetKeyframe()
{
CImageDrawable::GetKeyframe();
if (mPositionChannel.IsValid())
SetPosition(mPositionChannel.GetPoint());
}
/**
* Draw the head
* \param graphics Graphics context to draw on
*/
void CHeadTop::Draw(Gdiplus::Graphics *graphics)
{
CImageDrawable::Draw(graphics);
// Distance horizontally from each eye center to the center
int d2 = mInterocularDistance / 2;
// Compute a left and right eye center X location
int rightX = mEyesCenter.X - d2;
int leftX = mEyesCenter.X + d2;
// Eye center Y value
int eyeY = mEyesCenter.Y;
DrawEyebrow(graphics, Point(rightX - 10, eyeY - 16), Point(rightX + 4, eyeY - 18));
DrawEyebrow(graphics, Point(leftX - 4, eyeY - 20), Point(leftX + 9, eyeY - 18));
if (mLeftEye.IsLoaded() && mRightEye.IsLoaded())
{
// Determine the point on the screen were we will draw the left eye
Point leye = TransformPoint(Point(leftX, eyeY));
// And draw the bitmap there
mLeftEye.DrawImage(graphics, leye, mPlacedR);
// Repeat the process for the right eye.
Point reye = TransformPoint(Point(rightX, eyeY));
mRightEye.DrawImage(graphics, reye, mPlacedR);
}
else
{
DrawEye(graphics, Point(leftX, eyeY));
DrawEye(graphics, Point(rightX, eyeY));
}
//SolidBrush brush(Color::Black);
//FontFamily fontFamily(L"Arial");
//Gdiplus::Font font(&fontFamily, 30);
//wstringstream str;
//double rotation = GetRotation();
//str << fixed << setprecision(1) << rotation;
//RectF bb;
//graphics->MeasureString(str.str().c_str(), str.str().length(), &font, PointF(0, 0), &bb);
//graphics->DrawString(str.str().c_str(), str.str().length(), &font, PointF((float)(mPlacedPosition.X - bb.Width / 2), (float)mPlacedPosition.Y - 40), &brush);
}
/** Draw an eye using an Ellipse
* \param graphics The graphics context to draw on
* \param p1 Where to draw before transformation */
void CHeadTop::DrawEye(Gdiplus::Graphics *graphics, Gdiplus::Point p1)
{
SolidBrush brush(Color::Black);
Point e1 = TransformPoint(p1);
float wid = 15.0f;
float hit = 20.0f;
auto state = graphics->Save();
graphics->TranslateTransform((float)e1.X, (float)e1.Y);
graphics->RotateTransform((float)(-mPlacedR * RtoD));
graphics->FillEllipse(&brush, -wid/2, -hit/2, wid, hit);
graphics->Restore(state);
}
/**
* Draw an eyebrow, automatically transforming the points
*
* Draw a line from (x1, y1) to (x2, y2) after transformation
* to the local coordinate system.
* \param graphics Graphics context to draw on
* \param p1 First point
* \param p2 Second point
*/
void CHeadTop::DrawEyebrow(Gdiplus::Graphics *graphics, Gdiplus::Point p1, Gdiplus::Point p2)
{
Point eb1 = TransformPoint(p1);
Point eb2 = TransformPoint(p2);
Pen eyebrowPen(Color::Black, 2);
graphics->DrawLine(&eyebrowPen, eb1, eb2);
}
/** Transform a point from a location on the bitmap to
* a location on the screen.
* \param p Point to transform
* \returns Transformed point
*/
Gdiplus::Point CHeadTop::TransformPoint(Gdiplus::Point p)
{
// Make p relative to the image center
p = p - GetCenter();
// Rotate as needed and offset
return RotatePoint(p, mPlacedR) + mPlacedPosition;
}
| 25.938547
| 163
| 0.673702
|
NicholsTyler
|
185ae531b8f50cb0038dac353c219b93ec2a00c1
| 11,858
|
cpp
|
C++
|
src/ngraph/pattern/matcher.cpp
|
pqLee/ngraph
|
ddfa95b26a052215baf9bf5aa1ca5d1f92aa00f7
|
[
"Apache-2.0"
] | null | null | null |
src/ngraph/pattern/matcher.cpp
|
pqLee/ngraph
|
ddfa95b26a052215baf9bf5aa1ca5d1f92aa00f7
|
[
"Apache-2.0"
] | null | null | null |
src/ngraph/pattern/matcher.cpp
|
pqLee/ngraph
|
ddfa95b26a052215baf9bf5aa1ca5d1f92aa00f7
|
[
"Apache-2.0"
] | null | null | null |
//*****************************************************************************
// Copyright 2017-2020 Intel Corporation
//
// 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 <algorithm>
#include <regex>
#include "matcher.hpp"
#include "ngraph/env_util.hpp"
#include "ngraph/graph_util.hpp"
#include "ngraph/log.hpp"
#include "ngraph/op/parameter.hpp"
using namespace std;
using namespace ngraph;
pattern::MatcherState::MatcherState(Matcher* matcher)
: m_matcher(matcher)
, m_pattern_value_map(matcher->m_pattern_map)
, m_watermark(matcher->m_matched_list.size())
, m_capture_size(matcher->m_pattern_value_maps.size())
{
}
pattern::Matcher::Matcher() {}
pattern::Matcher::Matcher(Output<Node>& pattern_node)
: m_pattern_node{pattern_node}
{
}
pattern::Matcher::Matcher(Output<Node>& pattern_node, const std::string& name)
: m_pattern_node(pattern_node)
, m_name{name}
{
}
pattern::Matcher::Matcher(const Output<Node>& pattern_node,
const std::string& name,
bool strict_mode)
: m_pattern_node(pattern_node)
, m_name(name)
, m_strict_mode(strict_mode)
{
}
pattern::Matcher::Matcher(shared_ptr<Node> pattern_node)
: m_pattern_node(pattern_node->output(0))
{
}
pattern::Matcher::Matcher(shared_ptr<Node> pattern_node, const string& name)
: m_pattern_node(pattern_node->output(0))
, m_name(name)
{
}
pattern::Matcher::Matcher(shared_ptr<Node> pattern_node, const string& name, bool strict_mode)
: Matcher(pattern_node->output(0), name, strict_mode)
{
}
pattern::MatcherState::~MatcherState()
{
if (m_restore)
{
if (!m_matcher->m_matched_list.empty())
{
m_matcher->m_matched_list.erase(m_matcher->m_matched_list.begin() + m_watermark,
m_matcher->m_matched_list.end());
}
if (!m_pattern_value_maps.empty())
{
m_matcher->m_pattern_value_maps.erase(m_pattern_value_maps.begin() + m_capture_size,
m_pattern_value_maps.end());
}
m_matcher->m_pattern_map = m_pattern_value_map;
}
}
bool pattern::MatcherState::finish(bool is_successful)
{
m_restore = !is_successful;
return is_successful;
}
pattern::PatternMap pattern::Matcher::get_pattern_map() const
{
return as_pattern_map(m_pattern_map);
}
size_t pattern::Matcher::add_node(Output<Node> value)
{
size_t result = m_matched_list.size();
m_matched_list.push_back(value);
return result;
}
shared_ptr<Node> pattern::Matcher::get_match_root()
{
return m_match_root.get_node_shared_ptr();
}
pattern::MatcherState pattern::Matcher::start_match()
{
return MatcherState(this);
}
Output<Node> pattern::Matcher::get_match_value()
{
return m_match_root;
}
void pattern::Matcher::capture(const set<Node*>& static_nodes)
{
m_pattern_value_maps.push_back(m_pattern_map);
m_pattern_map.clear();
for (auto key_value : m_pattern_value_maps.back())
{
if (static_nodes.count(key_value.first.get()) > 0)
{
m_pattern_map.insert(key_value);
}
}
}
bool pattern::Matcher::is_contained_match(const OutputVector& exclusions, bool ignore_unused)
{
if (exclusions.empty())
{
OutputVector label_exclusions;
for (auto entry : m_pattern_map)
{
// leaf label
if (entry.first->get_input_size() == 0)
{
label_exclusions.push_back(entry.second.get_node_shared_ptr());
}
}
return get_subgraph_outputs(get_matched_values(), label_exclusions, ignore_unused).size() <
2;
}
return get_subgraph_outputs(get_matched_values(), exclusions).size() < 2;
}
bool pattern::Matcher::match_value(const Output<Node>& pattern_value,
const Output<Node>& graph_value)
{
shared_ptr<Node> pattern_node = pattern_value.get_node_shared_ptr();
shared_ptr<Node> graph_node = graph_value.get_node_shared_ptr();
// This env var allows one to specify node name patterns to abort pattern matching
// at particular nodes. The upshot is that one can quickly zero in on an offending
// fusion by disabling individual fusions or optimizations that use Matcher.
static const string node_skip_cregex = getenv_string("NGRAPH_FAIL_MATCH_AT");
if (!node_skip_cregex.empty())
{
static const regex node_skip_regex(node_skip_cregex);
if (regex_match(graph_node->get_name(), node_skip_regex))
{
NGRAPH_DEBUG << "[MATCHER] Aborting at " << *graph_node
<< " due to NGRAPH_MATCHER_SKIP set to " << node_skip_cregex;
return false;
}
}
return pattern_node->match_value(this, pattern_value, graph_value);
}
bool pattern::Matcher::match_permutation(const OutputVector& pattern_args, const OutputVector& args)
{
for (size_t i = 0; i < args.size(); i++)
{
if (!match_value(pattern_args.at(i), args.at(i)))
{
return false;
}
}
return true;
}
bool pattern::Matcher::match_arguments(Node* pattern_node, const shared_ptr<Node>& graph_node)
{
NGRAPH_DEBUG << "[MATCHER] Match arguments at " << *graph_node << " for pattern "
<< *pattern_node;
auto args = graph_node->input_values();
auto pattern_args = pattern_node->input_values();
if (args.size() != pattern_args.size())
{
NGRAPH_DEBUG << "[MATCHER] Aborting at " << *graph_node << " for pattern " << *pattern_node;
return false;
}
if (graph_node->is_commutative())
{
// TODO: [nikolayk] we don't really have to use lexicographically-based perms,
// heap's algo should be faster
sort(begin(pattern_args),
end(pattern_args),
[](const Output<Node>& n1, const Output<Node>& n2) { return n1 < n2; });
do
{
auto saved = start_match();
if (match_permutation(pattern_args, args))
{
return saved.finish(true);
}
} while (next_permutation(
begin(pattern_args),
end(pattern_args),
[](const Output<Node>& n1, const Output<Node>& n2) { return n1 < n2; }));
}
else
{
return match_permutation(pattern_args, args);
}
NGRAPH_DEBUG << "[MATCHER] Aborting at " << *graph_node << " for pattern " << *pattern_node;
return false;
}
bool pattern::Matcher::match(const Output<Node>& graph_value)
{
// clear our state
m_matched_list.clear();
return match(graph_value, PatternValueMap{});
}
bool pattern::Matcher::match(shared_ptr<Node> node)
{
for (Output<Node> output : node->outputs())
{
if (this->match(output))
{
return true;
}
}
return false;
}
bool pattern::Matcher::match(const Output<Node>& graph_value,
const PatternValueMap& previous_matches)
{
// clear our state
m_match_root.reset();
m_pattern_map.clear();
m_matched_list.clear();
// insert previous matches
m_pattern_map.insert(previous_matches.cbegin(), previous_matches.cend());
auto saved = start_match();
bool is_match = saved.finish(match_value(m_pattern_node, graph_value));
if (is_match)
{
m_match_root = graph_value;
}
return is_match;
}
bool pattern::Matcher::match(const Output<Node>& graph_value, const PatternMap& previous_matches)
{
return match(graph_value, as_pattern_value_map(previous_matches));
}
set<shared_ptr<Node>>
pattern::RecurrentMatcher::as_node_set(const set<shared_ptr<op::Label>>& label_set)
{
set<shared_ptr<Node>> result;
for (auto label : label_set)
{
result.insert(label);
}
return result;
}
pattern::RecurrentMatcher::RecurrentMatcher(
const Output<Node>& initial_pattern,
const Output<Node>& pattern,
const std::shared_ptr<Node>& rpattern,
const std::set<std::shared_ptr<Node>>& correlated_patterns)
: m_initial_pattern(initial_pattern)
, m_pattern(pattern)
, m_recurrent_pattern(rpattern)
, m_correlated_patterns(correlated_patterns)
{
}
pattern::RecurrentMatcher::RecurrentMatcher(
const Output<Node>& pattern,
const std::shared_ptr<Node>& rpattern,
const std::set<std::shared_ptr<Node>>& correlated_patterns)
: RecurrentMatcher(pattern, pattern, rpattern, correlated_patterns)
{
}
pattern::RecurrentMatcher::RecurrentMatcher(
const Output<Node>& pattern,
const std::shared_ptr<Node>& rpattern,
const std::set<std::shared_ptr<op::Label>>& correlated_patterns)
: RecurrentMatcher(pattern, pattern, rpattern, correlated_patterns)
{
}
pattern::RecurrentMatcher::RecurrentMatcher(const Output<Node>& initial_pattern,
const Output<Node>& pattern,
const shared_ptr<Node>& rpattern,
const set<shared_ptr<op::Label>>& correlated_patterns)
: RecurrentMatcher(initial_pattern, pattern, rpattern, as_node_set(correlated_patterns))
{
}
bool pattern::RecurrentMatcher::match(std::shared_ptr<Node> graph)
{
for (Output<Node> output : graph->outputs())
{
if (match(output))
{
return true;
}
}
return false;
}
bool pattern::RecurrentMatcher::match(Output<Node> graph)
{
bool matched = false;
Matcher m_initial(m_initial_pattern);
Matcher m_repeat(m_pattern);
Matcher& m = m_initial;
PatternValueMap previous_matches;
m_matches.clear();
m_match_root = graph;
// try to match one cell (i.e. pattern)
while (m.match(graph, previous_matches))
{
matched = true;
// move to the next cell
graph = m.get_pattern_value_map()[m_recurrent_pattern];
// copy bound nodes for the current pattern graph into a global matches map
for (auto cur_match : m.get_pattern_value_map())
{
m_matches[cur_match.first].push_back(cur_match.second);
}
// pre-populate the pattern map for the next cell with the bound nodes
// from the current match. Only bound nodes whose labels are in
// correlated_patterns are pre-populated. Skip other labels are
// unbounded by default
for (auto cor_pat : m_correlated_patterns)
{
previous_matches[cor_pat] = m.get_pattern_value_map()[cor_pat];
}
m = m_repeat;
}
if (!matched)
{
m_match_root.reset();
}
return matched;
}
/// \brief Returns a vector of bound values for a given label (used in a pattern
/// describing an individual cell
OutputVector pattern::RecurrentMatcher::get_bound_values_for_pattern(
const std::shared_ptr<Node>& pattern) const
{
if (m_matches.count(pattern) == 0)
{
throw ngraph_error("No bound nodes for a given label");
}
return m_matches.at(pattern);
}
size_t pattern::RecurrentMatcher::get_number_of_recurrent_matches() const
{
if (m_matches.size() == 0)
{
return 0;
}
return (*m_matches.begin()).second.size();
}
| 29.351485
| 100
| 0.642182
|
pqLee
|
185eb811b951605f459d79fe797e58d3432aedde
| 1,120
|
cpp
|
C++
|
source/orzTest/test_streamconv.cpp
|
poppeman/Pictus
|
0e58285b89292d0b221ab4d09911ef439711cc59
|
[
"MIT"
] | 73
|
2015-01-19T17:38:26.000Z
|
2022-02-15T06:16:08.000Z
|
source/orzTest/test_streamconv.cpp
|
poppeman/Pictus
|
0e58285b89292d0b221ab4d09911ef439711cc59
|
[
"MIT"
] | 75
|
2015-01-01T17:32:24.000Z
|
2018-10-18T08:19:08.000Z
|
source/orzTest/test_streamconv.cpp
|
poppeman/Pictus
|
0e58285b89292d0b221ab4d09911ef439711cc59
|
[
"MIT"
] | 18
|
2015-01-05T04:57:18.000Z
|
2022-03-06T01:35:10.000Z
|
#include "orz/streamconv.h"
#include "main.h"
#include "orz/file_reader.h"
#include "orz/types.h"
#include <UnitTest++/UnitTest++.h>
SUITE(StreamConverter)
{
TEST(Defaults)
{
Util::StreamConverter sc;
// Should default to empty with wordsize 8
CHECK(sc.CurrentWordSize() == 8);
CHECK(sc.IsWordsLeft() == false);
}
TEST(ChangeWordSize)
{
Util::StreamConverter sc;
sc.ChangeWordSize(16);
CHECK(sc.CurrentWordSize() == 16);
}
TEST(IO)
{
const int ReadBuffer=1024;
Util::StreamConverter sc;
// Store an entire file in the stream converter
auto f = std::make_shared<IO::FileReader>(g_datapath+"/data.raw");
CHECK(f->Open());
size_t read;
do
{
uint8_t buf[ReadBuffer];
read=f->Read(buf, 1, ReadBuffer);
sc.AddBytes(buf, read);
}
while(read!=0);
// Increase size to 16 bits and verify with the file contents
sc.ChangeWordSize(16);
f->Seek(0, IO::SeekMethod::Begin);
do
{
uint16_t buf[ReadBuffer];
read = f->Read(buf, 2, ReadBuffer);
for(size_t i = 0; i < read; i++)
{
CHECK((uint16_t)sc.GetWord()==buf[i]);
}
}
while(read != 0);
}
}
| 18.666667
| 68
| 0.644643
|
poppeman
|
185ef91df49a724eb68581351e21b214ebfd9eb1
| 4,109
|
cpp
|
C++
|
src/app/input/input_manager.cpp
|
JacobDomagala/Shady
|
cdb8b07a83d179f58bd70c42957e987ddd201eb4
|
[
"MIT"
] | 2
|
2020-10-27T00:16:18.000Z
|
2021-03-29T12:59:48.000Z
|
src/app/input/input_manager.cpp
|
JacobDomagala/DEngine
|
cdb8b07a83d179f58bd70c42957e987ddd201eb4
|
[
"MIT"
] | 58
|
2020-08-23T21:38:21.000Z
|
2021-08-05T16:12:31.000Z
|
src/app/input/input_manager.cpp
|
JacobDomagala/Shady
|
cdb8b07a83d179f58bd70c42957e987ddd201eb4
|
[
"MIT"
] | null | null | null |
#include "input_manager.hpp"
#include "event.hpp"
#include "trace/logger.hpp"
#include <GLFW/glfw3.h>
#include <iostream>
namespace shady::app::input {
void
InputManager::InternalKeyCallback(GLFWwindow* /* window */, int32_t key, int32_t scancode, int32_t action,
int32_t mods)
{
trace::Logger::Trace("GLFW key {} {} scan code - {}", action, key, scancode);
s_keyMap[key] = action;
BroadcastEvent(KeyEvent{key, scancode, action, mods});
}
void
InputManager::InternalMouseButtonCallback(GLFWwindow* /* window */, int32_t button, int32_t action,
int32_t mods)
{
trace::Logger::Trace("GLFW mouse button {} {} {}", button, action, mods);
s_mouseButtonMap[button] = action;
BroadcastEvent(MouseButtonEvent{button, action, mods});
}
void
InputManager::InternalCursorPositionCallback(GLFWwindow* /* window */, double xpos, double ypos)
{
trace::Logger::Trace("GLFW cursor pos {} {}", xpos, ypos);
auto deltaPosition = glm::dvec2(xpos, ypos) - s_mousePosition;
s_mousePosition = glm::dvec2(xpos, ypos);
BroadcastEvent(CursorPositionEvent{xpos, ypos, deltaPosition.x, deltaPosition.y});
}
void
InputManager::InternalMouseScrollCallback(GLFWwindow* /* window */, double xoffset, double yoffset)
{
trace::Logger::Trace("GLFW scroll {} {}", xoffset, yoffset);
BroadcastEvent(MouseScrollEvent{xoffset, yoffset});
}
void
InputManager::BroadcastEvent(const Event& event)
{
switch (event.m_type)
{
case Event::EventType::KEY: {
for (auto* listener : s_keyListeners)
{
listener->KeyCallback(static_cast< const KeyEvent& >(event));
}
}
break;
case Event::EventType::MOUSE_BUTTON: {
for (auto* listener : s_mouseButtonListeners)
{
listener->MouseButtonCallback(static_cast< const MouseButtonEvent& >(event));
}
}
break;
case Event::EventType::MOUSE_CURSOR: {
for (auto* listener : s_mouseMovementListeners)
{
listener->CursorPositionCallback(static_cast< const CursorPositionEvent& >(event));
}
}
break;
case Event::EventType::MOUSE_SCROLL: {
for (auto* listener : s_mouseScrollListeners)
{
listener->MouseScrollCallback(static_cast< const MouseScrollEvent& >(event));
}
}
break;
default:
break;
}
}
void
InputManager::Init(GLFWwindow* mainWindow)
{
s_windowHandle = mainWindow;
glfwGetCursorPos(s_windowHandle, &s_mousePosition.x, &s_mousePosition.y);
glfwSetKeyCallback(s_windowHandle, InternalKeyCallback);
glfwSetMouseButtonCallback(s_windowHandle, InternalMouseButtonCallback);
glfwSetCursorPosCallback(s_windowHandle, InternalCursorPositionCallback);
glfwSetScrollCallback(s_windowHandle, InternalMouseScrollCallback);
s_keyMap.clear();
}
void
InputManager::RegisterForKeyInput(InputListener* listener)
{
s_keyListeners.push_back(listener);
}
void
InputManager::RegisterForMouseButtonInput(InputListener* listener)
{
s_mouseButtonListeners.push_back(listener);
}
void
InputManager::RegisterForMouseMovementInput(InputListener* listener)
{
s_mouseMovementListeners.push_back(listener);
}
void
InputManager::RegisterForMouseScrollInput(InputListener* listener)
{
s_mouseScrollListeners.push_back(listener);
}
void
InputManager::PollEvents()
{
glfwPollEvents();
}
bool
InputManager::CheckButtonPressed(int32_t button)
{
return s_mouseButtonMap[button];
}
bool
InputManager::CheckKeyPressed(int32_t keyKode)
{
return s_keyMap[keyKode];
}
glm::vec2
InputManager::GetMousePos()
{
return s_mousePosition;
}
void
InputManager::SetMousePos(const glm::vec2& position)
{
glfwSetCursorPos(s_windowHandle, static_cast< double >(position.x),
static_cast< double >(position.y));
}
} // namespace shady::app::input
| 25.364198
| 107
| 0.666099
|
JacobDomagala
|
18612f1a957d88caaaabcca573098411fd17e931
| 2,116
|
cc
|
C++
|
base/parsers/character_set_tests.cc
|
dimhotepus/whitebox
|
03902b15b03ae0bfe6db5dc12d91ce49c576ac97
|
[
"BSD-3-Clause"
] | 1
|
2022-01-16T15:01:42.000Z
|
2022-01-16T15:01:42.000Z
|
base/parsers/character_set_tests.cc
|
dimhotepus/whitebox
|
03902b15b03ae0bfe6db5dc12d91ce49c576ac97
|
[
"BSD-3-Clause"
] | 5
|
2021-08-11T22:04:28.000Z
|
2022-01-10T11:18:56.000Z
|
base/parsers/character_set_tests.cc
|
dimhotepus/whitebox
|
03902b15b03ae0bfe6db5dc12d91ce49c576ac97
|
[
"BSD-3-Clause"
] | null | null | null |
// Copyright (c) 2021 The WhiteBox Authors. All rights reserved.
// Use of this source code is governed by a 3-Clause BSD license that can be
// found in the LICENSE file.
//
// Character set for parsers.
#include "character_set.h"
//
#include "base/deps/googletest/gtest/gtest.h"
// NOLINTNEXTLINE(cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables,cppcoreguidelines-owning-memory)
GTEST_TEST(CharacterSetTest, DefaultConstructor) {
using namespace wb::base::parsers;
constexpr CharacterSet set;
for (auto &&ch : set.set) {
EXPECT_FALSE(ch);
}
}
// NOLINTNEXTLINE(cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables,cppcoreguidelines-owning-memory)
GTEST_TEST(CharacterSetTest, SetConstructor) {
using namespace wb::base::parsers;
constexpr CharacterSet set{"123"};
size_t idx{0};
for (auto &&ch : set.set) {
if (idx == static_cast<CharacterSet::char_type>('1') ||
idx == static_cast<CharacterSet::char_type>('2') ||
idx == static_cast<CharacterSet::char_type>('3')) {
EXPECT_TRUE(ch) << "Char '"
<< static_cast<char>(
static_cast<CharacterSet::char_type>(idx))
<< " should be in set.";
} else {
EXPECT_FALSE(ch) << "Char '"
<< static_cast<char>(
static_cast<CharacterSet::char_type>(idx))
<< " should not be in set.";
}
++idx;
}
}
// NOLINTNEXTLINE(cert-err58-cpp,cppcoreguidelines-avoid-non-const-global-variables,cppcoreguidelines-owning-memory)
GTEST_TEST(CharacterSetTest, HasChar) {
using namespace wb::base::parsers;
constexpr CharacterSet set{"{}()"};
static_assert(set.HasChar('{'));
static_assert(set.HasChar('}'));
static_assert(set.HasChar('('));
static_assert(set.HasChar(')'));
static_assert(!set.HasChar(' '));
static_assert(!set.HasChar('.'));
static_assert(!set.HasChar('a'));
static_assert(!set.HasChar('A'));
static_assert(!set.HasChar('1'));
static_assert(!set.HasChar('\\'));
static_assert(!set.HasChar('\n'));
}
| 32.553846
| 116
| 0.648393
|
dimhotepus
|
186aba9728bc54e6f2236322cde1aad2ddcb639c
| 663
|
cpp
|
C++
|
GameEngine/Sources/GLFW_Init.cpp
|
GPUWorks/OpenGL-Mini-CAD-2D
|
fedb903302f82a1d1ff0ca6776687a60a237008a
|
[
"MIT"
] | 1
|
2021-08-10T02:48:57.000Z
|
2021-08-10T02:48:57.000Z
|
GameEngine/Sources/GLFW_Init.cpp
|
GPUWorks/OpenGL-Mini-CAD-2D
|
fedb903302f82a1d1ff0ca6776687a60a237008a
|
[
"MIT"
] | null | null | null |
GameEngine/Sources/GLFW_Init.cpp
|
GPUWorks/OpenGL-Mini-CAD-2D
|
fedb903302f82a1d1ff0ca6776687a60a237008a
|
[
"MIT"
] | null | null | null |
#include "GLFW_Init.h"
core::GLFW_Init::GLFW_Init()
{
}
core::GLFW_Init::GLFW_Init(int major_version, int minor_version, int opengl_profile, int msaa_factor)
{
this->major_context_version = major_version;
this->minor_context_version = minor_version;
this->opengl_profile = opengl_profile;
this->msaa_factor = msaa_factor;
}
void core::GLFW_Init::init()
{
glfwInit();
glfwWindowHint(GLFW_SAMPLES, msaa_factor);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, this->major_context_version);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, this->minor_context_version);
glfwWindowHint(GLFW_OPENGL_PROFILE, this->opengl_profile);
}
| 22.862069
| 102
| 0.761689
|
GPUWorks
|
186feedf62975ca20b669a846171be662ad04f28
| 1,227
|
cpp
|
C++
|
src/utils/CursorHelper.cpp
|
oclero/luna
|
00bd5736e7bab57daa5d622bcd5379992ca6505c
|
[
"MIT"
] | 5
|
2021-07-19T19:57:41.000Z
|
2021-09-25T01:41:13.000Z
|
src/utils/CursorHelper.cpp
|
chiefstone/luna
|
00bd5736e7bab57daa5d622bcd5379992ca6505c
|
[
"MIT"
] | 2
|
2021-09-25T08:35:49.000Z
|
2021-09-25T11:14:49.000Z
|
src/utils/CursorHelper.cpp
|
chiefstone/luna
|
00bd5736e7bab57daa5d622bcd5379992ca6505c
|
[
"MIT"
] | 3
|
2021-08-20T10:19:12.000Z
|
2021-09-25T10:46:40.000Z
|
#include <luna/utils/CursorHelper.hpp>
#include <QCursor>
#include <QGuiApplication>
namespace luna::utils {
CursorHelper::CursorHelper(QObject* parent)
: QObject(parent) {}
CursorHelper::~CursorHelper() {
QGuiApplication::restoreOverrideCursor();
}
Qt::CursorShape CursorHelper::cursor() const {
return QGuiApplication::overrideCursor()->shape();
}
void CursorHelper::setCursor(const Qt::CursorShape cursor) {
if (cursor != _cursor) {
_cursor = cursor;
// If the cursor is currently overriden, replace it by the new one.
if (_overrideCursor) {
QGuiApplication::changeOverrideCursor(QCursor{ _cursor });
}
emit cursorChanged();
}
}
bool CursorHelper::overrideCursor() const {
return _overrideCursor;
}
void CursorHelper::setOverrideCursor(const bool overrideCursor) {
if (overrideCursor != _overrideCursor) {
_overrideCursor = overrideCursor;
// Do the actual cursor overriding.
if (overrideCursor) {
QGuiApplication::setOverrideCursor(QCursor{ _cursor });
} else {
QGuiApplication::restoreOverrideCursor();
}
emit overrideCursorChanged();
}
}
CursorHelper* CursorHelper::qmlAttachedProperties(QObject* object) {
return new CursorHelper(object);
}
} // namespace luna::utils
| 22.722222
| 69
| 0.742461
|
oclero
|
18712c56bf3e1f0651dd1d542d78f433ce5660e8
| 795
|
hpp
|
C++
|
include/mitama/dimensional/systems/si/derived_units/heat.hpp
|
LoliGothick/mitama-dimensional
|
46b9ae3764bd472da9ed5372afd82e6b5d542543
|
[
"MIT"
] | 34
|
2019-01-18T11:51:02.000Z
|
2021-09-17T02:46:43.000Z
|
include/mitama/dimensional/systems/si/derived_units/heat.hpp
|
LoliGothick/mitama-dimensional
|
46b9ae3764bd472da9ed5372afd82e6b5d542543
|
[
"MIT"
] | 11
|
2019-02-10T23:12:07.000Z
|
2019-05-06T21:05:09.000Z
|
include/mitama/dimensional/systems/si/derived_units/heat.hpp
|
LoliGothick/mitama-dimensional
|
46b9ae3764bd472da9ed5372afd82e6b5d542543
|
[
"MIT"
] | 5
|
2019-02-27T11:53:20.000Z
|
2021-03-20T21:59:59.000Z
|
#ifndef MITAMA_DIMENSIONAL_DERIVED_UNITS_HEAT_HPP
#define MITAMA_DIMENSIONAL_DERIVED_UNITS_HEAT_HPP
#include <mitama/dimensional/systems/si/all.hpp>
#include <mitama/dimensional/quantity.hpp>
#include <mitama/dimensional/io.hpp>
namespace mitama::systems::si {
template<class> struct heat_synonym{};
using heat_t = make_synonym_t<heat_synonym, decltype(kilogram<> * meter<2> * second<-2>)>;
#if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_ENERGY_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_WORK_HPP)
inline constexpr heat_t joule{};
#endif
}
#if !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_ENERGY_HPP) && !defined(MITAMA_DIMENSIONAL_DERIVED_UNITS_WORK_HPP)
namespace mitama {
template <> struct abbreviation_<systems::si::heat_t> { static constexpr char str[] = "J"; };
}
#endif
#endif
| 31.8
| 112
| 0.803774
|
LoliGothick
|
1874ab136870b4eb334cbde189625fd573772ac5
| 5,731
|
cpp
|
C++
|
test/test_list.cpp
|
kophy/TinySTL
|
366c2f585344a249846f4087904d509fa71e419e
|
[
"MIT"
] | 5
|
2017-05-04T12:21:09.000Z
|
2019-03-28T09:29:50.000Z
|
test/test_list.cpp
|
kophy/TinySTL
|
366c2f585344a249846f4087904d509fa71e419e
|
[
"MIT"
] | null | null | null |
test/test_list.cpp
|
kophy/TinySTL
|
366c2f585344a249846f4087904d509fa71e419e
|
[
"MIT"
] | null | null | null |
#include <cstdlib>
#include "list.hpp"
#include "catch.hpp"
using TinySTL::List;
TEST_CASE("front and back") {
SECTION("empty list") {
List<int> l;
CHECK_THROWS_AS(l.front(), std::out_of_range);
CHECK_THROWS_AS(l.back(), std::out_of_range);
}
}
TEST_CASE("push front") {
SECTION("push 1 ~ 5 from front") {
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_front(i);
CHECK(l.front() == 4);
CHECK(l.back() == 0);
}
}
TEST_CASE("pop front") {
SECTION("empty list") {
List<int> l;
CHECK_THROWS_AS(l.pop_front(), std::out_of_range);
}
SECTION("not empty list") {
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_front(i);
l.pop_front();
CHECK(l.front() == 3);
}
}
TEST_CASE("push_back") {
SECTION("push 1 ~ 5 from back") {
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(i);
CHECK(l.front() == 0);
CHECK(l.back() == 4);
}
}
TEST_CASE("pop back") {
SECTION("empty list") {
List<int> l;
CHECK_THROWS_AS(l.pop_back(), std::out_of_range);
}
SECTION("not empty list") {
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(i);
l.pop_back();
CHECK(l.back() == 3);
}
}
TEST_CASE("clear") {
SECTION("clear a list") {
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(i);
CHECK(l.size() == 5);
l.clear();
CHECK(l.size() == 0);
}
}
TEST_CASE("iterator") {
SECTION("empty list") {
List<int> l;
CHECK(l.begin() == l.end());
}
SECTION("not empty list : traverse") {
int data[] = {7, 11, 23, 41, 73};
int cnt;
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(data[i]);
cnt = 0;
for (auto iter = l.begin(); iter != l.end(); ++iter)
CHECK(*iter == data[cnt++]);
CHECK(cnt == 5);
}
SECTION("not empty list : edit") {
int data[] = {7, 11, 23, 41, 73};
int cnt;
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(data[i]);
cnt = 0;
for (auto iter = l.begin(); iter != l.end(); ++iter)
*iter = 3 * data[cnt++];
CHECK(cnt == 5);
cnt = 0;
for (auto iter = l.begin(); iter != l.end(); iter++)
CHECK(*iter == 3 * data[cnt++]);
CHECK(cnt == 5);
}
}
TEST_CASE("reverse iterator") {
SECTION("empty list") {
List<int> l;
CHECK(l.rbegin() == l.rend());
}
SECTION("not empty list : traverse") {
int data[] = {7, 11, 23, 41, 73};
int cnt;
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(data[i]);
cnt = 0;
for (auto iter = l.begin(); iter != l.end(); ++iter)
CHECK(*iter == data[cnt++]);
CHECK(cnt == 5);
cnt = 5;
for (auto iter = l.rbegin(); iter != l.rend(); iter++)
CHECK(*iter == data[--cnt]);
CHECK(cnt == 0);
}
SECTION("not empty list : edit") {
int data[] = {7, 11, 23, 41, 73};
int cnt;
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(data[i]);
cnt = 5;
for (auto iter = l.rbegin(); iter != l.rend(); ++iter)
*iter = 3 * data[--cnt];
CHECK(cnt == 0);
cnt = 5;
for (auto iter = l.rbegin(); iter != l.rend(); iter++)
CHECK(*iter == 3 * data[--cnt]);
CHECK(cnt == 0);
}
}
TEST_CASE("insert") {
SECTION("front") {
List<int> l;
l.insert(l.begin(), 17);
CHECK(l.front() == 17);
l.insert(l.begin(), 233);
CHECK(l.front() == 233);
}
SECTION("back") {
List<int> l;
l.insert(l.end(), 17);
CHECK(l.back() == 17);
l.insert(l.end(), 233);
CHECK(l.back() == 233);
}
SECTION("middle") {
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(i);
auto iter = l.begin();
iter++;
l.insert(iter, 43);
int data[] = {0, 43, 1, 2, 3, 4};
int cnt = 0;
for (iter = l.begin(); iter != l.end(); ++iter)
CHECK(*iter == data[cnt++]);
CHECK(cnt == 6);
}
}
// TODO: add size check
TEST_CASE("erase") {
SECTION("front") {
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(i);
l.erase(l.begin());
CHECK(l.front() == 1);
}
SECTION("back") {
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(i);
l.erase(l.end());
CHECK(l.back() == 4);
}
SECTION("middle") {
List<int> l;
for (int i = 0; i < 5; ++i)
l.push_back(i);
auto iter = l.begin();
++iter;
iter = l.erase(iter);
CHECK(*iter == 2);
int data[] = {0, 2, 3, 4};
int cnt = 0;
for (iter = l.begin(); iter != l.end(); ++iter)
CHECK(*iter == data[cnt++]);
CHECK(cnt == 4);
}
}
TEST_CASE("swap") {
SECTION("swap two lists") {
List<int> l1, l2;
for (int i = 0; i < 3; ++i)
l1.push_back(1);
for (int j = 0; j < 5; ++j)
l2.push_back(2);
l1.swap(l2);
CHECK(l1.size() == 5);
CHECK(l2.size() == 3);
auto iter1 = l1.begin(), iter2 = l2.end();
while (iter1 != l1.end()) {
CHECK(*iter1 == 2);
++iter1;
}
while (iter2 != l2.end()) {
CHECK(*iter2 == 1);
++iter2;
}
}
}
| 24.079832
| 62
| 0.424184
|
kophy
|
1875115aa1c9cadda5ec3c931eeb1c67a5047cda
| 398
|
hpp
|
C++
|
gtk/gtk.hpp
|
klada/online
|
3c1185aca331222fefcc7a55c8d30064e2ef0a58
|
[
"BSD-2-Clause"
] | 1
|
2021-07-25T06:22:35.000Z
|
2021-07-25T06:22:35.000Z
|
gtk/gtk.hpp
|
klada/online
|
3c1185aca331222fefcc7a55c8d30064e2ef0a58
|
[
"BSD-2-Clause"
] | 1
|
2022-02-24T13:46:43.000Z
|
2022-02-24T13:46:43.000Z
|
gtk/gtk.hpp
|
klada/online
|
3c1185aca331222fefcc7a55c8d30064e2ef0a58
|
[
"BSD-2-Clause"
] | 1
|
2022-01-20T03:10:13.000Z
|
2022-01-20T03:10:13.000Z
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
/*
* 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/.
*/
extern int coolwsd_server_socket_fd;
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
| 36.181818
| 97
| 0.68593
|
klada
|
18770ff3124b3f7c22f268506d0dfe3d91497cd2
| 2,774
|
hpp
|
C++
|
citadel_lib/include/citadel/character.hpp
|
myddrin/citadel
|
f7f00e81154b1ac5e0442e1cfcef402f9e92887d
|
[
"MIT"
] | null | null | null |
citadel_lib/include/citadel/character.hpp
|
myddrin/citadel
|
f7f00e81154b1ac5e0442e1cfcef402f9e92887d
|
[
"MIT"
] | null | null | null |
citadel_lib/include/citadel/character.hpp
|
myddrin/citadel
|
f7f00e81154b1ac5e0442e1cfcef402f9e92887d
|
[
"MIT"
] | null | null | null |
/**
* Copyright (c) 2016 Thomas Richard
*
* Following MIT license (see copying.txt)
*
* 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.
*/
#ifndef CITADEL_CHARACTER
#define CITADEL_CHARACTER
#include <string>
#include "citadel/building.hpp"
namespace Citadel {
struct Character
{
/** @brief possible power for characters */
enum Power {
/** @brief Nothing special */
POWER_NONE = 0,
/** @brief Kill another character */
POWER_KILL = 1,
/**
* @brief Steal from another character
*
* Cannot steal from the assassin (lower level of play)
* or a dead character.
*/
POWER_STEAL = POWER_KILL << 1,
/** @brief exchange all cards with another player */
POWER_CARDS_PLAYER = POWER_STEAL << 1,
/** @brief exchange some cards with the deck */
POWER_CARDS_DECK = POWER_CARDS_PLAYER << 1,
/** @brief become the first player to choose a character */
POWER_CROWN = POWER_CARDS_DECK << 1,
/** @brief cannot be attacked by the condotiere */
POWER_IMMUNITY = POWER_CROWN << 1,
/** @brief additional gold each turn */
POWER_RENT = POWER_IMMUNITY << 1,
/** @brief additional cards each turn */
POWER_CARDS = POWER_RENT << 1,
/** @brief can build more buildings per turn */
POWER_BUILD = POWER_CARDS << 1,
/**
* @brief can destroy another building
*
* Unless the character has immunity. Has to pay value-1.
* Cannot attack the 1st player that has enough buildings to win.
*/
POWER_DESTROY = POWER_BUILD << 1,
};
const std::string name;
const std::string description;
/** @brief turn of play - lower first */
const unsigned int level;
/**
* @brief power held - constructed from values @ref enum Power
*/
const unsigned int power;
/** @brief what buildings are taxable */
const enum Building::Type taxing;
/** @brief if dead will not be able to play or be stolen from */
bool dead;
/** @brief at start of turn loose all its money to the thief */
bool stolen;
/**
* @brief character is visible
*
* (i.e. was turned over or has played already)
*/
bool visible;
Character(const std::string &_name, unsigned int _level,
unsigned int _power, enum Building::Type _taxing,
const std::string &_description = "");
void reset();
};
} /* namespace Citadel */
#endif /* CITADEL_CHARACTER */
| 30.483516
| 77
| 0.603461
|
myddrin
|
18771a185896ed2cf4c7b04b0e8bff3abf66617b
| 944
|
cpp
|
C++
|
src/core/platform/Process.cpp
|
TheJelmega/engine
|
39778e153a3214fb54d7c88295289a5128cd248f
|
[
"0BSD"
] | 3
|
2021-09-04T20:36:23.000Z
|
2022-01-20T14:16:43.000Z
|
src/core/platform/Process.cpp
|
TheJelmega/engine
|
39778e153a3214fb54d7c88295289a5128cd248f
|
[
"0BSD"
] | 1
|
2021-11-02T23:26:26.000Z
|
2021-11-02T23:26:26.000Z
|
src/core/platform/Process.cpp
|
TheJelmega/engine
|
39778e153a3214fb54d7c88295289a5128cd248f
|
[
"0BSD"
] | null | null | null |
#include "Process.h"
namespace Core
{
auto Process::GetPath() const noexcept -> const FileSystem::Path&
{
return m_path;
}
auto Process::GetCmdLine() const noexcept -> const String&
{
return m_cmdLine;
}
auto Process::GetEnvironment() const noexcept -> const String&
{
return m_environment;
}
auto Process::GetPriority() const noexcept -> ProcessPriority
{
return m_priority;
}
auto Process::GetMemoryPriority() const noexcept -> ProcessMemoryPriority
{
return m_memPriority;
}
auto Process::GetPowerThrottling() const noexcept -> ProcessPowerThrottling
{
return m_powerThrottling;
}
auto Process::GetProcessId() const noexcept -> ProcessID
{
return m_id;
}
auto Process::GetWorkingDir() const noexcept -> const FileSystem::Path&
{
return m_workingDir;
}
auto Process::GetNativeHandle() const noexcept -> NativeHandle
{
return m_handle;
}
}
| 18.88
| 77
| 0.684322
|
TheJelmega
|
18797a8a106c2dafd1386df0110f53de65436f6c
| 1,991
|
cc
|
C++
|
src/itensor/util/args.h.cc
|
kyungminlee/PiTensor
|
f206fe5a384b52336e9f406c11dc492ff129791b
|
[
"MIT"
] | 10
|
2019-01-25T03:21:49.000Z
|
2020-01-19T04:42:32.000Z
|
src/itensor/util/args.h.cc
|
kyungminlee/PiTensor
|
f206fe5a384b52336e9f406c11dc492ff129791b
|
[
"MIT"
] | null | null | null |
src/itensor/util/args.h.cc
|
kyungminlee/PiTensor
|
f206fe5a384b52336e9f406c11dc492ff129791b
|
[
"MIT"
] | 2
|
2018-04-10T05:11:30.000Z
|
2018-09-14T08:16:07.000Z
|
#include "../../pitensor.h"
#include "itensor/util/args.h"
#include <pybind11/embed.h>
namespace py = pybind11;
using namespace itensor;
// TODO: Implement python version altogether?
static inline
auto
initArgs(pybind11::module& module)
{
py::class_<Args> type(module, "Args");
using namespace pybind11::literals;
type
.def(py::init<>())
.def(py::init(
[](py::kwargs kwargs) {
auto self = new Args();
for (auto const & kv : kwargs) {
auto key = kv.first.cast<std::string>();
auto val = kv.second;
auto typestr = py::str(val.get_type()).cast<std::string>();
if (typestr == "<class 'bool'>") {
self->add(key, val.cast<bool>());
} else if (typestr == "<class 'int'>") {
self->add(key, val.cast<long>());
} else if (typestr == "<class 'float'>") {
self->add(key, val.cast<double>());
} else if (typestr == "<class 'str'>") {
self->add(key, val.cast<std::string>());
} // TODO: Find better way.
}
return self;
})
)
.def("add",
(void (Args::*)(std::string const &, bool)) &Args::add)
.def("add",
(void (Args::*)(std::string const &, long)) &Args::add)
.def("add",
(void (Args::*)(std::string const &, std::string const &)) &Args::add)
.def("add",
(void (Args::*)(std::string const &, Real)) &Args::add)
.def("defined", &Args::defined)
.def("remove", &Args::remove)
// TODO: getBool
// TODO: getString
// TODO: getInt
// TODO: getReal
.def("__repr__",
[](Args const & obj) -> std::string { std::stringstream ss; ss << obj; return ss.str(); })
.def(py::self + py::self)
;
return type;
}
void pitensor::util::args(pybind11::module& module)
{
auto typeArgs = initArgs(module);
}
| 32.112903
| 101
| 0.500753
|
kyungminlee
|
1879f70ef792663254581d4d79df1fb7693ba8ca
| 4,671
|
cpp
|
C++
|
src/plugins/legacy/polygonRoi/polygonRoiPlugin.cpp
|
jnietol/medInria-public
|
727ba130afdc2f5ff046a936e2a24d920a413c77
|
[
"BSD-4-Clause"
] | null | null | null |
src/plugins/legacy/polygonRoi/polygonRoiPlugin.cpp
|
jnietol/medInria-public
|
727ba130afdc2f5ff046a936e2a24d920a413c77
|
[
"BSD-4-Clause"
] | null | null | null |
src/plugins/legacy/polygonRoi/polygonRoiPlugin.cpp
|
jnietol/medInria-public
|
727ba130afdc2f5ff046a936e2a24d920a413c77
|
[
"BSD-4-Clause"
] | null | null | null |
/*=========================================================================
medInria
Copyright (c) INRIA 2013 - 2019. All rights reserved.
See LICENSE.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.
=========================================================================*/
#include "polygonRoiPlugin.h"
#include "polygonRoiToolBox.h"
#include <contoursManagementToolBox.h>
#include <medContours.h>
#include <medContoursReader.h>
#include <medContoursWriters.h>
polygonRoiPlugin::polygonRoiPlugin(QObject *parent) : medPluginLegacy(parent)
{
}
bool polygonRoiPlugin::initialize()
{
if(!polygonRoiToolBox::registered())
{
qDebug() << "Unable to register polygonRoiToolBox";
}
if(!contoursManagementToolBox::registered())
{
qDebug() << "Unable to register contoursManagementToolBox";
}
if (!medContours::registered())
{
qDebug() << "Unable to register medContours type";
}
if (!medContoursReader::registered())
{
qDebug() << "Unable to register medContoursReader type";
}
if (!medContoursWriter::registered())
{
qDebug() << "Unable to register medContoursWriter type";
}
return true;
}
QString polygonRoiPlugin::name() const
{
return "Polygon ROI";
}
QString polygonRoiPlugin::description() const
{
QString description;
description += "<h1>Polygon ROI Tutorial</h1>";
description += "Enter a data in the view and click on 'Activate Toolbox'.";
description += "<h2>Create your first contours</h2>";
description += "To segment a volume using polygons, click on the volume to draw your nodes. ";
description += "Close the contour by clicking on the first node.<br>";
description += "Switch to a new slice and you can draw a new contour.";
description += "<h2>Correct a contour</h2>";
description += "<h3>Repulsor</h3>";
description += "You can adjust your segmentation with the Repulsor tool. It allows you to push your ";
description += "nodes to fit a circle cursor which appears when you click on the volume.";
description += "<h3>Remove node/contour/label</h3>";
description += "To remove a component of the segmentation, put the cursor over it and use 'backspace', ";
description += "or right-lick and choose 'Remove' in the menu.";
description += "<h2>Interpolation</h2>";
description += "Use 'Interpolate' to automatically interpolate contours through several slices of your ";
description += "volume. You have a polygonROI segmentation that covers approximately the body ";
description += "part you want to segment, but 'approximately' is not enough. You don't want to erase ";
description += "all the segmentation (since it's better than nothing) but you want to refine it. You can ";
description += "re-interpolate without removing undesired ROIs beforehand, because ";
description += "interpolation is only done between master ROIs. A master ROI is: a new polygon, or ";
description += "a modified polygon (repulsed or manually modified with handles).";
description += "<h2>Orientations</h2>";
description += "Clicking on one of the 3 orientation buttons split the view in 2 and display the data in ";
description += "a new orientation, allowing you to check your segmentation from an other point of view.";
description += "<h2>Labels</h2>";
description += "To define a new label, click on the '+' button in the Label list.<br>";
description += "You can rename it double-clicking on its name in the list, or right-click on a node and change the name.<br>";
description += "You can change the current label putting the cursor on a node and right-click and choose the 'Change label' menu.";
description += "<h2>Copy-Paste</h2>";
description += "To copy a segmentation in the current slice, use CTRL/CMD + C or put the cursor ";
description += "on a node then right-click and choose menu 'Copy'.<br>";
description += "Paste it on an other slice using CTRL/CMD + V";
description += "<h2>Save</h2>";
description += "Click on 'Mask(s)' or 'Contour(s)' to save your segmentation. ";
description += "You can also right-click on a node and choose the 'Save' menu.";
description += "<br><br>This plugin uses the VTK library: https://vtk.org";
return description;
}
QString polygonRoiPlugin::version() const
{
return POLYGONROIPLUGIN_VERSION;
}
QStringList polygonRoiPlugin::types() const
{
return QStringList() << "polygonRoi" << "medContours";
}
| 40.973684
| 135
| 0.669878
|
jnietol
|
1880424f60d56103a862c1621422485c864059af
| 12,962
|
cpp
|
C++
|
sta-src/Loitering/loiteringTLE.cpp
|
hoehnp/SpaceDesignTool
|
9abd34048274b2ce9dbbb685124177b02d6a34ca
|
[
"IJG"
] | 6
|
2018-09-05T12:41:59.000Z
|
2021-07-01T05:34:23.000Z
|
sta-src/Loitering/loiteringTLE.cpp
|
hoehnp/SpaceDesignTool
|
9abd34048274b2ce9dbbb685124177b02d6a34ca
|
[
"IJG"
] | 2
|
2015-02-07T19:09:21.000Z
|
2015-08-14T03:15:42.000Z
|
sta-src/Loitering/loiteringTLE.cpp
|
hoehnp/SpaceDesignTool
|
9abd34048274b2ce9dbbb685124177b02d6a34ca
|
[
"IJG"
] | 2
|
2015-03-25T15:50:31.000Z
|
2017-12-06T12:16:47.000Z
|
/*
This program is free software; you can redistribute it and/or modify it under
the terms of the European Union Public Licence - EUPL v.1.1 as published by
the European Commission.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the European Union Public Licence - EUPL v.1.1
for more details.
You should have received a copy of the European Union Public Licence - EUPL v.1.1
along with this program.
Further information about the European Union Public Licence - EUPL v.1.1 can
also be found on the world wide web at http://ec.europa.eu/idabc/eupl
*/
/*
------ Copyright (C) 2010 STA Steering Board (space.trajectory.analysis AT gmail.com) ----
*/
/*
------------------ Author: Guillermo Ortega -------------------
------------------ Affiliation: European Space Agency (ESA) -------------------
-----------------------------------------------------------------------------------
*/
#include "Loitering/loiteringTLE.h"
#include "Main/scenariotree.h"
#include "Scenario/scenario.h"
#include "Astro-Core/date.h"
#include "Astro-Core/stacoordsys.h"
#include "Astro-Core/calendarTOjulian.h"
#include "thirdparty/noradtle/norad.h"
#include <QtGui>
#include <iostream>
#include <QTextStream>
#include "ui_loiteringTLE.h"
// The maximum number of steps allowed for a propagation; the user should be allowed
// to adjust this.
static const int MAX_OUTPUT_STEPS = 1000000;
QT_BEGIN_NAMESPACE
class QMimeData;
QT_END_NAMESPACE
class DropArea;
LoiteringTLEDialog::LoiteringTLEDialog(ScenarioTree* parent) :
QDialog(parent)
{
setupUi(this);
// Set up the input validators
QDoubleValidator* angleValidator = new QDoubleValidator(this);
angleValidator->setBottom(0.0);
angleValidator->setTop(360.0);
QDoubleValidator* positiveDoubleValidator = new QDoubleValidator(this);
positiveDoubleValidator->setBottom(0.0);
QDoubleValidator* zeroToOneValidator = new QDoubleValidator(this);
zeroToOneValidator->setBottom(0.0);
zeroToOneValidator->setTop(0.9999);
QDoubleValidator* minusOneToOneValidator = new QDoubleValidator(this);
minusOneToOneValidator->setBottom(-1.0);
minusOneToOneValidator->setTop(1.0);
TimeStepLineEdit->setValidator(positiveDoubleValidator);
// This creates the drop area inside a QFormLayout called "DropTLEhere" in the UI file
dropArea = new DropArea;
dropArea->setMaximumSize(106, 55); dropArea->setMinimumSize(106, 55); // Set the size
DropTLEhere->addWidget(dropArea); //Add the widget into the desired area
// Feeding back what we read as TLE file
connect(dropArea, SIGNAL(changed(const QMimeData *)), this, SLOT(on_TLE_dropped(const QMimeData *)));
}
LoiteringTLEDialog::~LoiteringTLEDialog()
{
}
/////////////////////////////////// FUNCTIONS ///////////////////////////////////
bool LoiteringTLEDialog::loadValues(ScenarioLoiteringTLEType* loiteringTLE)
{
// Loading the time line and the time step
ScenarioTimeLine* timeLine = loiteringTLE->TimeLine().data();
StartDateTimeEdit->setDateTime(timeLine->StartTime());
EndDateTimeEdit->setDateTime(timeLine->EndTime());
TimeStepLineEdit->setText(QString::number(timeLine->StepTime()));
TLEline0Edit->setText(loiteringTLE->tleLine0());
TLEline1Edit->setText(loiteringTLE->tleLine1());
TLEline2Edit->setText(loiteringTLE->tleLine2());
//loiteringAspectTLE.loadValueCentralBody("Earth");
ScenarioElementIdentifierType* arcIdentifier = loiteringTLE->ElementIdentifier().data();
LoiteringTLEDialog::loadValues(arcIdentifier);
return true;
} // End of LoiteringTLEDialog::loadValues
void LoiteringTLEDialog::on_LoadTLEpushButton_clicked()
{
QTextStream out (stdout);
QString TLEFileName;
QString TLE_line_1;
QString TLE_line_2;
// Loading now the TLE file
QString CompleteTLEFileName = QFileDialog::getOpenFileName(this, tr("Select TLE File"),
QString("./TLEs/"),
tr("TLEs (*.tle *.TLE)"));
if (!CompleteTLEFileName.isEmpty())
{
// Strip away the path--we just want the filename
if (CompleteTLEFileName.contains('/'))
{
TLEFileName = CompleteTLEFileName.remove(0, TLEFileName.lastIndexOf('/') + 1);
//out << "TLEFileName: " << TLEFileName << endl;
};
// Reading the TLE file
QFile TLEfile(CompleteTLEFileName);
TLEfile.open(QIODevice::ReadOnly);
QTextStream StreamWithTLEs(&TLEfile);
QString NameOfParticipant = StreamWithTLEs.readLine();
TLE_line_1 = StreamWithTLEs.readLine();
TLE_line_2 = StreamWithTLEs.readLine();
TLEfile.close();
//Updating the GUI
LoiteringTLEDialog::TLEline0Edit->setText(NameOfParticipant);
LoiteringTLEDialog::TLEline1Edit->setText(TLE_line_1);
LoiteringTLEDialog::TLEline2Edit->setText(TLE_line_2);
}
}
bool LoiteringTLEDialog::saveValues(ScenarioLoiteringTLEType* loiteringTLE)
{
// Loading the time line and the time step
ScenarioTimeLine* timeLine = loiteringTLE->TimeLine().data();
// Saving the time line that constains start date, end date and time step
timeLine->setStartTime(StartDateTimeEdit->dateTime());
timeLine->setEndTime(EndDateTimeEdit->dateTime());
timeLine->setStepTime(TimeStepLineEdit->text().toDouble());
// Saving now the TLE parameters
loiteringTLE->setTleLine0(TLEline0Edit->text()); //The name of the vehicle
loiteringTLE->setTleLine1(TLEline1Edit->text()); //The first TLE line
loiteringTLE->setTleLine2(TLEline2Edit->text()); //The second TLE line
ScenarioElementIdentifierType* identifier = loiteringTLE->ElementIdentifier().data();
LoiteringTLEDialog::saveValues(identifier);
return true;
}
void LoiteringTLEDialog::on_TLE_dropped(const QMimeData *mimeData)
{
QTextStream out (stdout);
QString TLE_line_0;
QString TLE_line_1;
QString TLE_line_2;
QString DroppedTLEFileName;
QList<QUrl> urlList = mimeData->urls();
for (int i = 0; i < urlList.size() && i < 32; ++i)
{
QString url = urlList.at(i).path();
DroppedTLEFileName += url;
}
if (!DroppedTLEFileName.isEmpty())
{
// Reading the TLE file
QFile TLEfile(DroppedTLEFileName);
TLEfile.open(QIODevice::ReadOnly);
QTextStream StreamWithTLEs(&TLEfile);
TLE_line_0 = StreamWithTLEs.readLine();
TLE_line_1 = StreamWithTLEs.readLine();
TLE_line_2 = StreamWithTLEs.readLine();
TLEfile.close();
LoiteringTLEDialog::TLEline0Edit->setText(TLE_line_0);
LoiteringTLEDialog::TLEline1Edit->setText(TLE_line_1);
LoiteringTLEDialog::TLEline2Edit->setText(TLE_line_2);
}
}
// This creates a generic drop area
DropArea::DropArea(QWidget *parent)
: QLabel(parent)
{
//setFrameStyle(QFrame::Sunken | QFrame::StyledPanel);
setFrameStyle(QFrame::Sunken);
setAlignment(Qt::AlignCenter);
setAcceptDrops(true);
setAutoFillBackground(true);
clear();
}
void DropArea::dragEnterEvent(QDragEnterEvent *event)
{
setText(tr("drop TLE"));
setBackgroundRole(QPalette::Highlight);
event->acceptProposedAction();
emit changed(event->mimeData());
}
void DropArea::dragMoveEvent(QDragMoveEvent *event)
{
event->acceptProposedAction();
}
// What to do when dropping a file into the drop area
void DropArea::dropEvent(QDropEvent *event)
{
QTextStream out (stdout);
QString DroppedTLEFileName, TLEFileName;
QString TLE_line_0;
QString TLE_line_1;
QString TLE_line_2;
const QMimeData *mimeData = event->mimeData();
QList<QUrl> urlList = mimeData->urls();
for (int i = 0; i < urlList.size() && i < 32; ++i)
{
QString url = urlList.at(i).path();
DroppedTLEFileName += url;
}
// Strip away the path--we just want the filename
if (DroppedTLEFileName.contains('/'))
{
TLEFileName = DroppedTLEFileName.remove(0, DroppedTLEFileName.lastIndexOf('/') + 1);
//out << "TLEFileName: " << TLEFileName << endl;
};
setText(TLEFileName);
setBackgroundRole(QPalette::Dark);
event->acceptProposedAction();
}
void DropArea::dragLeaveEvent(QDragLeaveEvent *event)
{
clear();
event->accept();
}
void DropArea::clear()
{
setText(tr("drop TLE"));
setBackgroundRole(QPalette::Dark);
emit changed();
}
/////////////////////////////////////// PropagateLoiteringTLETrajectory /////////////////////////////
bool
PropagateLoiteringTLETrajectory(ScenarioLoiteringTLEType* loiteringTLE,
QList<double>& sampleTimes,
QList<sta::StateVector>& samples,
PropagationFeedback& propFeedback)
{
double timelineDuration = loiteringTLE->TimeLine()->StartTime().secsTo(loiteringTLE->TimeLine()->EndTime());
if (timelineDuration < 0)
{
propFeedback.raiseError(QObject::tr("End time before initial time"));
return true;
}
double dt = loiteringTLE->TimeLine()->StepTime();
tle_t tle;
int tleError = parse_elements(loiteringTLE->tleLine1().toAscii().data(), loiteringTLE->tleLine2().toAscii().data(), &tle);
if (tleError != 0)
{
if (tleError == 3)
propFeedback.raiseError(QObject::tr("TLE is not parseable."));
else
propFeedback.raiseError(QObject::tr("Checksum error in TLE.\n"));
//return initialState;
return true;
}
if (dt == 0.0)
{
propFeedback.raiseError(QObject::tr("Time step is zero!"));
//return initialState;
return true;
}
if (timelineDuration / dt > MAX_OUTPUT_STEPS)
{
propFeedback.raiseError(QObject::tr("Number of propagation steps exceeds %1. Try increasing the simulation time step.").arg(MAX_OUTPUT_STEPS));
//return initialState;
return true;
}
int ephemeris = TLE_EPHEMERIS_TYPE_SGP4;
bool isDeep = select_ephemeris(&tle) != 0;
if (isDeep)
{
ephemeris = TLE_EPHEMERIS_TYPE_SDP4;
}
else
{
ephemeris = TLE_EPHEMERIS_TYPE_SGP4;
}
double satelliteParams[N_SAT_PARAMS];
switch (ephemeris)
{
case TLE_EPHEMERIS_TYPE_SGP:
SGP_init(satelliteParams, &tle);
break;
case TLE_EPHEMERIS_TYPE_SGP4:
SGP4_init(satelliteParams, &tle);
break;
case TLE_EPHEMERIS_TYPE_SGP8:
SGP8_init(satelliteParams, &tle);
break;
case TLE_EPHEMERIS_TYPE_SDP4:
SDP4_init(satelliteParams, &tle);
break;
case TLE_EPHEMERIS_TYPE_SDP8:
SDP8_init(satelliteParams, &tle);
break;
}
double startTimeJd = sta::CalendarToJd(loiteringTLE->TimeLine()->StartTime());
double timeBase = (startTimeJd - tle.epoch) * 1440.0;
sta::StateVector state;
// Loop written to ensure that we always sample right to the end of the
// requested span.
for (double t = 0.0; t < timelineDuration + dt; t += dt)
{
double tclamp = std::min(t, timelineDuration);
// Time since epoch
double t1 = timeBase + tclamp / 60.0;
switch (ephemeris)
{
case TLE_EPHEMERIS_TYPE_SGP:
SGP(t1, &tle, satelliteParams, state.position.data(), state.velocity.data());
break;
case TLE_EPHEMERIS_TYPE_SGP4:
SGP4(t1, &tle, satelliteParams, state.position.data(), state.velocity.data());
break;
case TLE_EPHEMERIS_TYPE_SGP8:
SGP8(t1, &tle, satelliteParams, state.position.data(), state.velocity.data());
break;
case TLE_EPHEMERIS_TYPE_SDP4:
SDP4(t1, &tle, satelliteParams, state.position.data(), state.velocity.data());
break;
case TLE_EPHEMERIS_TYPE_SDP8:
SDP8(t1, &tle, satelliteParams, state.position.data(), state.velocity.data());
break;
}
// SGP output velocities are in km/minute; convert to km/sec.
state.velocity /= 60.0;
//sampleTimes << m_timeline->startTime() + sta::secsToDays(tclamp);
sampleTimes << sta::JdToMjd(startTimeJd) + sta::secsToDays(tclamp);
samples << state;
}
return true;
}
bool LoiteringTLEDialog::loadValues(ScenarioElementIdentifierType* arcIdentifier)
{
QString theArcName = arcIdentifier->Name();
loiteringAspectTLE.loadValueArcName(theArcName);
QString theArcColor = arcIdentifier->colorName();
loiteringAspectTLE.loadValueArcColor(theArcColor);
QString theArcModel = arcIdentifier->modelName();
loiteringAspectTLE.loadValueArcModel(theArcModel);
}
bool LoiteringTLEDialog::saveValues(ScenarioElementIdentifierType* arcIdentifier)
{
// The arc name
QString theArcName = loiteringAspectTLE.saveValueArcName();
arcIdentifier->setName(theArcName);
// The color
QString theColorName = loiteringAspectTLE.saveValueArcColor();
arcIdentifier->setColorName(theColorName);
// The model
QString theModelName = loiteringAspectTLE.saveValueArcModel();
arcIdentifier->setModelName(theModelName);
}
void LoiteringTLEDialog::on_pushButtonAspectTLE_clicked()
{
// loiteringAspectTLE.removePlanetsFromComboBoxForTLEs();
// loiteringAspectTLE.removePlanetsFromComboBoxForTLEs();
// loiteringAspectTLE.removePlanetsFromComboBoxForTLEs();
// loiteringAspectTLE.removePlanetsFromComboBoxForTLEs();
loiteringAspectTLE.exec();
}
| 27.935345
| 145
| 0.704212
|
hoehnp
|
1881eee331797c9274dd9381422225cbcb31e705
| 1,913
|
hpp
|
C++
|
lib/dmitigr/net/client.hpp
|
dmitigr/pgfe
|
c5dd21c0f4949cf6ea2e71368e3c6025c3daf69a
|
[
"Zlib"
] | 121
|
2018-05-23T19:51:00.000Z
|
2022-03-12T13:05:34.000Z
|
lib/dmitigr/net/client.hpp
|
dmitigr/pgfe
|
c5dd21c0f4949cf6ea2e71368e3c6025c3daf69a
|
[
"Zlib"
] | 36
|
2019-11-11T03:25:10.000Z
|
2022-03-28T21:54:07.000Z
|
lib/dmitigr/net/client.hpp
|
dmitigr/pgfe
|
c5dd21c0f4949cf6ea2e71368e3c6025c3daf69a
|
[
"Zlib"
] | 17
|
2018-05-24T04:01:28.000Z
|
2022-01-16T13:22:26.000Z
|
// -*- C++ -*-
// Copyright (C) Dmitry Igrishin
// For conditions of distribution and use, see files LICENSE.txt or net.hpp
#ifndef DMITIGR_NET_CLIENT_HPP
#define DMITIGR_NET_CLIENT_HPP
#include "dmitigr/net/descriptor.hpp"
#include "dmitigr/net/endpoint.hpp"
#include "dmitigr/net/socket.hpp"
#include <cassert>
#include <memory>
#include <utility>
namespace dmitigr::net {
/**
* @brief Client options.
*/
class Client_options final {
public:
#ifdef _WIN32
/// wnp.
explicit Client_options(std::string pipe_name)
: endpoint_{std::move(pipe_name)}
{}
#else
/// uds.
Client_options(std::filesystem::path path)
: endpoint_{std::move(path)}
{}
#endif
/// net.
Client_options(std::string address, int port)
: endpoint_{std::move(address), port}
{}
/// @return The endpoint.
const net::Endpoint& endpoint() const
{
return endpoint_;
}
private:
Endpoint endpoint_;
};
/**
* @returns A newly created descriptor connected over TCP (or Named Pipe)
* to `remote` endpoint.
*/
inline std::unique_ptr<Descriptor> make_tcp_connection(const Client_options& opts)
{
using Sockdesc = detail::socket_Descriptor;
static const auto make_tcp_connection = [](const Socket_address& addr)
{
auto result = make_tcp_socket(addr.family());
connect_socket(result, addr);
return result;
};
const auto& remote = opts.endpoint();
switch (remote.communication_mode()) {
#ifdef _WIN32
case Communication_mode::wnp: {
throw std::logic_error{"not implemented"};
return nullptr;
}
#else
case Communication_mode::uds:
return std::make_unique<Sockdesc>(make_tcp_connection({remote.uds_path().value()}));
#endif
case Communication_mode::net:
return std::make_unique<Sockdesc>(make_tcp_connection({remote.net_address().value(), remote.net_port().value()}));
}
assert(false);
}
} // namespace dmitigr::net
#endif // DMITIGR_NET_CLIENT_HPP
| 22.77381
| 118
| 0.70413
|
dmitigr
|
18832373562193ffa9ddb902e43c611ce75a84dc
| 6,186
|
cpp
|
C++
|
packages/Adapters/C_API/src/DTK_POD_PointCloudEntityImpl.cpp
|
chiao45/DataTransferKit
|
51923eb08ccd4c12c5a5ea5f136f5ccbbbeb6243
|
[
"BSD-3-Clause"
] | 1
|
2020-07-26T03:50:31.000Z
|
2020-07-26T03:50:31.000Z
|
packages/Adapters/C_API/src/DTK_POD_PointCloudEntityImpl.cpp
|
chiao45/DataTransferKit
|
51923eb08ccd4c12c5a5ea5f136f5ccbbbeb6243
|
[
"BSD-3-Clause"
] | null | null | null |
packages/Adapters/C_API/src/DTK_POD_PointCloudEntityImpl.cpp
|
chiao45/DataTransferKit
|
51923eb08ccd4c12c5a5ea5f136f5ccbbbeb6243
|
[
"BSD-3-Clause"
] | 1
|
2018-07-09T18:39:38.000Z
|
2018-07-09T18:39:38.000Z
|
//---------------------------------------------------------------------------//
/*
Copyright (c) 2012, Stuart R. Slattery
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
*: Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
*: Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
*: Neither the name of the University of Wisconsin - Madison nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
//---------------------------------------------------------------------------//
/*!
* \brief DTK_POD_PointCloudEntityImpl.cpp
* \author Stuart R. Slattery
* \brief Point cloud entity implementation.
*/
//---------------------------------------------------------------------------//
#include <limits>
#include "DTK_DBC.hpp"
#include "DTK_POD_PointCloudEntityImpl.hpp"
namespace DataTransferKit
{
//---------------------------------------------------------------------------//
// Constructor.
POD_PointCloudEntityImpl::POD_PointCloudEntityImpl(
const double *cloud_coords, const unsigned num_points, const int space_dim,
const DataLayout layout, const EntityId global_id, const int local_id,
const int owner_rank )
: d_cloud_coords( cloud_coords )
, d_offsets( space_dim, -1 )
, d_global_id( global_id )
, d_owner_rank( owner_rank )
{
DTK_REQUIRE( INTERLEAVED == layout || BLOCKED == layout );
// Calculate the offsets into the coordinates array.
for ( int d = 0; d < space_dim; ++d )
{
d_offsets[d] = ( INTERLEAVED == layout ) ? space_dim * local_id + d
: d * num_points + local_id;
}
}
//---------------------------------------------------------------------------//
// Get the coordinates of the point in a given dimension.
double POD_PointCloudEntityImpl::coord( const int dim ) const
{
DTK_REQUIRE( dim < physicalDimension() );
return d_cloud_coords[d_offsets[dim]];
}
//---------------------------------------------------------------------------//
// Get the unique global identifier for the entity.
EntityId POD_PointCloudEntityImpl::id() const { return d_global_id; }
//---------------------------------------------------------------------------//
// Get the parallel rank that owns the entity.
int POD_PointCloudEntityImpl::ownerRank() const { return d_owner_rank; }
//---------------------------------------------------------------------------//
// Get the topological dimension of the entity.
int POD_PointCloudEntityImpl::topologicalDimension() const { return 0; }
//---------------------------------------------------------------------------//
// Return the physical dimension of the entity.
int POD_PointCloudEntityImpl::physicalDimension() const
{
return d_offsets.size();
}
//---------------------------------------------------------------------------//
// Return the Cartesian bounding box around an entity.
void POD_PointCloudEntityImpl::boundingBox(
Teuchos::Tuple<double, 6> &bounds ) const
{
for ( int d = 0; d < physicalDimension(); ++d )
{
bounds[d] = d_cloud_coords[d_offsets[d]];
bounds[d + 3] = bounds[d];
}
for ( int d = physicalDimension(); d < 3; ++d )
{
bounds[d] = 0.0;
bounds[d + 3] = bounds[d];
}
}
//---------------------------------------------------------------------------//
// Determine if an entity is in the block with the given id.
bool POD_PointCloudEntityImpl::inBlock( const int block_id ) const
{
return false;
}
//---------------------------------------------------------------------------//
// Determine if an entity is on the boundary with the given id.
bool POD_PointCloudEntityImpl::onBoundary( const int boundary_id ) const
{
return false;
}
//---------------------------------------------------------------------------//
// Get the extra data on the entity.
Teuchos::RCP<EntityExtraData> POD_PointCloudEntityImpl::extraData() const
{
return Teuchos::rcp( const_cast<POD_PointCloudEntityImpl *>( this ),
false );
}
//---------------------------------------------------------------------------//
// Provide a verbose description of the object.
void POD_PointCloudEntityImpl::describe(
Teuchos::FancyOStream &out,
const Teuchos::EVerbosityLevel /*verb_level*/ ) const
{
out << std::endl;
out << "---" << std::endl;
out << "POD Point Cloud Entity" << std::endl;
out << "Id: " << id() << std::endl;
out << "Owner rank: " << ownerRank() << std::endl;
out << "Point coords: ";
for ( int d = 0; d < physicalDimension(); ++d )
{
out << d_cloud_coords[d_offsets[d]] << " ";
}
out << std::endl;
}
//---------------------------------------------------------------------------//
} // end namespace DataTransferKit
//---------------------------------------------------------------------------//
// end DTK_POD_PointCloudEntityImpl.cpp
//---------------------------------------------------------------------------//
| 37.26506
| 79
| 0.54882
|
chiao45
|
1884a96f39c161d0349b994cbd34a098c2a047f4
| 21,721
|
cpp
|
C++
|
cvrin.cpp
|
AlexeyAkhunov/espresso
|
5c7a57ad6fde2fb3af46171ca1a5c78d250716e9
|
[
"MIT"
] | null | null | null |
cvrin.cpp
|
AlexeyAkhunov/espresso
|
5c7a57ad6fde2fb3af46171ca1a5c78d250716e9
|
[
"MIT"
] | null | null | null |
cvrin.cpp
|
AlexeyAkhunov/espresso
|
5c7a57ad6fde2fb3af46171ca1a5c78d250716e9
|
[
"MIT"
] | null | null | null |
/*
module: cvrin.c
purpose: cube and cover input routines
*/
#include <iostream>
#include <cmath>
#include "espresso.h"
static bool line_length_error;
static int lineno;
void skip_line(std::istream& fpin, std::ostream& fpout, bool echo)
{
int ch;
while ((ch=fpin.get()) != EOF && ch != '\n')
if (echo)
fpout.put(ch);
if (echo)
fpout.put('\n');
lineno++;
}
char *get_word(std::istream& fp, char* word)
{
int ch, i = 0;
while ((ch = fp.get()) != EOF && isspace(ch))
;
word[i++] = ch;
while ((ch = fp.get()) != EOF && ! isspace(ch))
word[i++] = ch;
word[i++] = '\0';
return word;
}
/*
* Yes, I know this routine is a mess
*/
void read_cube(std::istream& fp, pPLA PLA)
{
int var, i;
pcube cf = cube.temp[0], cr = cube.temp[1], cd = cube.temp[2];
bool savef = FALSE, saved = FALSE, saver = FALSE;
char token[256]; /* for kiss read hack */
int varx, first, last, offset; /* for kiss read hack */
set_clear(cf, cube.size);
/* Loop and read binary variables */
for(var = 0; var < cube.num_binary_vars; var++)
switch(fp.get()) {
case EOF:
goto bad_char;
case '\n':
if (! line_length_error)
fprintf(stderr, "product term(s) %s, line %d\n",
"span more than one line (warning only)", lineno);
line_length_error = FALSE;
lineno++;
var--;
break;
case ' ': case '|': case '\t':
var--;
break;
case '2': case '-':
set_insert(cf, var*2+1);
case '0':
set_insert(cf, var*2);
break;
case '1':
set_insert(cf, var*2+1);
break;
case '?':
break;
default:
goto bad_char;
}
/* Loop for the all but one of the multiple-valued variables */
for(var = cube.num_binary_vars; var < cube.num_vars-1; var++)
/* Read a symbolic multiple-valued variable */
if (cube.part_size[var] < 0) {
fp >> token;
if (equal(token, "-") || equal(token, "ANY")) {
if (kiss && var == cube.num_vars - 2) {
/* leave it empty */
} else {
/* make it full */
set_or(cf, cf, cube.var_mask[var]);
}
} else if (equal(token, "~")) {
;
/* leave it empty ... (?) */
} else {
if (kiss && var == cube.num_vars - 2)
varx = var - 1, offset = abs(cube.part_size[var-1]);
else
varx = var, offset = 0;
/* Find the symbolic label in the label table */
first = cube.first_part[varx];
last = cube.last_part[varx];
for(i = first; i <= last; i++)
if (PLA->label[i] == (char *) NULL) {
PLA->label[i] = strcpy(new char[strlen(token)+1], token); /* add new label */
set_insert(cf, i+offset);
break;
} else if (equal(PLA->label[i], token)) {
set_insert(cf, i+offset); /* use column i */
break;
}
if (i > last) {
fprintf(stderr,
"declared size of variable %d (counting from variable 0) is too small\n", var);
exit(-1);
}
}
} else for(i = cube.first_part[var]; i <= cube.last_part[var]; i++)
switch (fp.get()) {
case EOF:
goto bad_char;
case '\n':
if (! line_length_error)
fprintf(stderr, "product term(s) %s, line %d\n",
"span more than one line (warning only)", lineno);
line_length_error = FALSE;
lineno++;
i--;
break;
case ' ': case '|': case '\t':
i--;
break;
case '1':
set_insert(cf, i);
case '0':
break;
default:
goto bad_char;
}
/* Loop for last multiple-valued variable */
if (kiss) {
saver = savef = TRUE;
(void) set_xor(cr, cf, cube.var_mask[cube.num_vars - 2]);
} else
set_copy(cr, cf);
set_copy(cd, cf);
for(i = cube.first_part[var]; i <= cube.last_part[var]; i++)
switch (fp.get()) {
case EOF:
goto bad_char;
case '\n':
if (! line_length_error)
fprintf(stderr, "product term(s) %s, line %d\n",
"span more than one line (warning only)", lineno);
line_length_error = FALSE;
lineno++;
i--;
break;
case ' ': case '|': case '\t':
i--;
break;
case '4': case '1':
if (PLA->pla_type & F_type)
set_insert(cf, i), savef = TRUE;
break;
case '3': case '0':
if (PLA->pla_type & R_type)
set_insert(cr, i), saver = TRUE;
break;
case '2': case '-':
if (PLA->pla_type & D_type)
set_insert(cd, i), saved = TRUE;
case '~':
break;
default:
goto bad_char;
}
if (savef) PLA->F = sf_addset(PLA->F, cf);
if (saved) PLA->D = sf_addset(PLA->D, cd);
if (saver) PLA->R = sf_addset(PLA->R, cr);
return;
bad_char:
fprintf(stderr, "(warning): input line #%d ignored\n", lineno);
skip_line(fp, std::cout, true);
return;
}
void parse_pla(std::istream& fp, pPLA PLA)
{
int i, var, ch, np, last;
char word[256];
lineno = 1;
line_length_error = FALSE;
loop:
switch(ch = fp.get()) {
case EOF:
return;
case '\n':
lineno++;
case ' ': case '\t': case '\f': case '\r':
break;
case '#':
(void) fp.unget();
skip_line(fp, std::cout, echo_comments);
break;
case '.':
/* .i gives the cube input size (binary-functions only) */
if (equal(get_word(fp, word), "i")) {
if (cube.fullset != NULL) {
fprintf(stderr, "extra .i ignored\n");
skip_line(fp, std::cout, /* echo */ false);
} else {
fp >> cube.num_binary_vars;
if (!fp.good()) {
fatal("error reading .i");
}
cube.num_vars = cube.num_binary_vars + 1;
cube.part_size = new int[cube.num_vars];
}
/* .o gives the cube output size (binary-functions only) */
} else if (equal(word, "o")) {
if (cube.fullset != NULL) {
fprintf(stderr, "extra .o ignored\n");
skip_line(fp, std::cout, /* echo */ false);
} else {
if (cube.part_size == NULL) {
fatal(".o cannot appear before .i");
}
fp >> cube.part_size[cube.num_vars-1];
if (!fp.good())
fatal("error reading .o");
cube_setup();
PLA_labels(PLA);
}
/* .mv gives the cube size for a multiple-valued function */
} else if (equal(word, "mv")) {
if (cube.fullset != NULL) {
fprintf(stderr, "extra .mv ignored\n");
skip_line(fp, std::cout, /* echo */ false);
} else {
if (cube.part_size != nullptr)
fatal("cannot mix .i and .mv");
fp >> cube.num_vars >> cube.num_binary_vars;
if (!fp.good())
fatal("error reading .mv");
if (cube.num_binary_vars < 0)
fatal("num_binary_vars (second field of .mv) cannot be negative");
if (cube.num_vars < cube.num_binary_vars)
fatal(
"num_vars (1st field of .mv) must exceed num_binary_vars (2nd field of .mv)");
cube.part_size = new int[cube.num_vars];
for(var=cube.num_binary_vars; var < cube.num_vars; var++) {
fp >> cube.part_size[var];
if (!fp.good()) {
fatal("error reading .mv");
}
}
cube_setup();
PLA_labels(PLA);
}
/* .p gives the number of product terms -- we ignore it */
} else if (equal(word, "p")) {
fp >> np;
}
/* .e and .end specify the end of the file */
else if (equal(word, "e") || equal(word,"end")) {
return;
}
/* .kiss turns on the kiss-hack option */
else if (equal(word, "kiss")) {
kiss = true;
}
/* .type specifies a logical type for the PLA */
else if (equal(word, "type")) {
(void) get_word(fp, word);
for(i = 0; pla_types[i].key != 0; i++)
if (equal(pla_types[i].key + 1, word)) {
PLA->pla_type = pla_types[i].value;
break;
}
if (pla_types[i].key == 0)
fatal("unknown type in .type command");
/* parse the labels */
} else if (equal(word, "ilb")) {
if (cube.fullset == NULL)
fatal("PLA size must be declared before .ilb or .ob");
if (PLA->label == NULL)
PLA_labels(PLA);
for(var = 0; var < cube.num_binary_vars; var++) {
(void) get_word(fp, word);
i = cube.first_part[var];
PLA->label[i+1] = strcpy(new char[strlen(word)+1], word);
PLA->label[i] = new char[strlen(word) + 6];
(void) sprintf(PLA->label[i], "%s.bar", word);
}
} else if (equal(word, "ob")) {
if (cube.fullset == NULL)
fatal("PLA size must be declared before .ilb or .ob");
if (PLA->label == NULL)
PLA_labels(PLA);
var = cube.num_vars - 1;
for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
(void) get_word(fp, word);
PLA->label[i] = strcpy(new char[strlen(word)+1], word);
}
/* .label assigns labels to multiple-valued variables */
} else if (equal(word, "label")) {
if (cube.fullset == nullptr) {
fatal("PLA size must be declared before .label");
}
if (PLA->label == nullptr) {
PLA_labels(PLA);
}
char vstr[5];
fp.getline(vstr, 4);
fp >> var;
if (strcmp("var=",vstr) || !fp.good()) {
fatal("Error reading labels");
}
for(i = cube.first_part[var]; i <= cube.last_part[var]; i++) {
(void) get_word(fp, word);
PLA->label[i] = strcpy(new char[strlen(word)+1], word);
}
} else if (equal(word, "symbolic")) {
symbolic_t *newlist, *p1;
if (read_symbolic(fp, PLA, word, &newlist)) {
if (PLA->symbolic == nullptr) {
PLA->symbolic = newlist;
} else {
for(p1=PLA->symbolic;p1->next!=nullptr;p1=p1->next);
p1->next = newlist;
}
} else {
fatal("error reading .symbolic");
}
} else if (equal(word, "symbolic-output")) {
symbolic_t *newlist, *p1;
if (read_symbolic(fp, PLA, word, &newlist)) {
if (PLA->symbolic_output == nullptr) {
PLA->symbolic_output = newlist;
} else {
for(p1=PLA->symbolic_output;p1->next!=nullptr;p1=p1->next);
p1->next = newlist;
}
} else {
fatal("error reading .symbolic-output");
}
/* .phase allows a choice of output phases */
} else if (equal(word, "phase")) {
if (cube.fullset == NULL)
fatal("PLA size must be declared before .phase");
if (PLA->phase != NULL) {
fprintf(stderr, "extra .phase ignored\n");
skip_line(fp, std::cout, /* echo */ false);
} else {
do ch = fp.get(); while (ch == ' ' || ch == '\t');
(void) fp.unget();
PLA->phase = set_save(cube.fullset);
last = cube.last_part[cube.num_vars - 1];
for(i=cube.first_part[cube.num_vars - 1]; i <= last; i++)
if ((ch = fp.get()) == '0')
set_remove(PLA->phase, i);
else if (ch != '1')
fatal("only 0 or 1 allowed in phase description");
}
/* .pair allows for bit-pairing input variables */
} else if (equal(word, "pair")) {
int j;
if (PLA->pair != NULL) {
fprintf(stderr, "extra .pair ignored\n");
} else {
ppair pair;
PLA->pair = pair = new pair_t();
fp >> pair->cnt;
if (!fp.good()) {
fatal("syntax error in .pair");
}
pair->var1 = new int[pair->cnt];
pair->var2 = new int[pair->cnt];
for(i = 0; i < pair->cnt; i++) {
(void) get_word(fp, word);
if (word[0] == '(') (void) strcpy(word, word+1);
if (label_index(PLA, word, &var, &j)) {
pair->var1[i] = var+1;
} else {
fatal("syntax error in .pair");
}
(void) get_word(fp, word);
if (word[strlen(word)-1] == ')') {
word[strlen(word)-1]='\0';
}
if (label_index(PLA, word, &var, &j)) {
pair->var2[i] = var+1;
} else {
fatal("syntax error in .pair");
}
}
}
} else {
if (echo_unknown_commands) {
printf("%c%s ", ch, word);
}
skip_line(fp, std::cout, echo_unknown_commands);
}
break;
default:
(void) fp.unget();
if (cube.fullset == NULL) {
/* fatal("unknown PLA size, need .i/.o or .mv");*/
if (echo_comments) {
putchar('#');
}
skip_line(fp, std::cout, echo_comments);
break;
}
if (PLA->F == NULL) {
PLA->F = new_cover(10);
PLA->D = new_cover(10);
PLA->R = new_cover(10);
}
read_cube(fp, PLA);
}
goto loop;
}
/*
read_pla -- read a PLA from a file
Input stops when ".e" is encountered in the input file, or upon reaching
end of file.
Returns the PLA in the variable PLA after massaging the "symbolic"
representation into a positional cube notation of the ON-set, OFF-set,
and the DC-set.
needs_dcset and needs_offset control the computation of the OFF-set
and DC-set (i.e., if either needs to be computed, then it will be
computed via complement only if the corresponding option is TRUE.)
pla_type specifies the interpretation to be used when reading the
PLA.
The phase of the output functions is adjusted according to the
global option "pos" or according to an imbedded .phase option in
the input file. Note that either phase option implies that the
OFF-set be computed regardless of whether the caller needs it
explicitly or not.
Bit pairing of the binary variables is performed according to an
imbedded .pair option in the input file.
The global cube structure also reflects the sizes of the PLA which
was just read. If these fields have already been set, then any
subsequent PLA must conform to these sizes.
The global flags trace and summary control the output produced
during the read.
Returns a status code as a result:
EOF (-1) : End of file reached before any data was read
> 0 : Operation successful
*/
int read_pla(std::istream& fp, bool needs_dcset, bool needs_offset, int pla_type, pPLA * PLA_return)
{
pPLA PLA;
int i, second, third;
cost_t cost;
/* Allocate and initialize the PLA structure */
PLA = *PLA_return = new_PLA();
PLA->pla_type = pla_type;
/* Read the pla */
auto time = ptime();
parse_pla(fp, PLA);
/* Check for nothing on the file -- implies reached EOF */
if (PLA->F == NULL) {
return EOF;
}
/* This hack merges the next-state field with the outputs */
for(i = 0; i < cube.num_vars; i++) {
cube.part_size[i] = abs(cube.part_size[i]);
}
if (kiss) {
third = cube.num_vars - 3;
second = cube.num_vars - 2;
if (cube.part_size[third] != cube.part_size[second]) {
fprintf(stderr," with .kiss option, third to last and second\n");
fprintf(stderr, "to last variables must be the same size.\n");
return EOF;
}
for(i = 0; i < cube.part_size[second]; i++) {
PLA->label[i + cube.first_part[second]] = strcpy(new char[strlen(PLA->label[i + cube.first_part[third]])+1], PLA->label[i + cube.first_part[third]]);
}
cube.part_size[second] += cube.part_size[cube.num_vars-1];
cube.num_vars--;
setdown_cube();
cube_setup();
}
if (trace) {
totals(time, READ_TIME, PLA->F, &cost);
}
/* Decide how to break PLA into ON-set, OFF-set and DC-set */
time = ptime();
if (pos || PLA->phase != nullptr || PLA->symbolic_output != nullptr) {
needs_offset = true;
}
if (needs_offset && (PLA->pla_type==F_type || PLA->pla_type==FD_type)) {
free_cover(PLA->R);
PLA->R = complement(cube2list(PLA->F, PLA->D));
} else if (needs_dcset && PLA->pla_type == FR_type) {
pcover X;
free_cover(PLA->D);
/* hack, why not? */
X = d1merge(sf_join(PLA->F, PLA->R), cube.num_vars - 1);
PLA->D = complement(cube1list(X));
free_cover(X);
} else if (PLA->pla_type == R_type || PLA->pla_type == DR_type) {
free_cover(PLA->F);
PLA->F = complement(cube2list(PLA->D, PLA->R));
}
if (trace) {
totals(time, COMPL_TIME, PLA->R, &cost);
}
/* Check for phase rearrangement of the functions */
if (pos) {
pcover onset = PLA->F;
PLA->F = PLA->R;
PLA->R = onset;
PLA->phase = new_cube();
set_diff(PLA->phase, cube.fullset, cube.var_mask[cube.num_vars-1]);
} else if (PLA->phase != NULL) {
(void) set_phase(PLA);
}
/* Setup minimization for two-bit decoders */
if (PLA->pair != (ppair) NULL) {
set_pair(PLA);
}
if (PLA->symbolic != nullptr) {
EXEC(map_symbolic(PLA), "MAP-INPUT ", PLA->F);
}
if (PLA->symbolic_output != nullptr) {
EXEC(map_output_symbolic(PLA), "MAP-OUTPUT ", PLA->F);
if (needs_offset) {
free_cover(PLA->R);
EXECUTE(PLA->R=complement(cube2list(PLA->F,PLA->D)), COMPL_TIME, PLA->R, cost);
}
}
std::cout << "After reading PLA\n";
//fprint_pla(std::cout, PLA, F_type);
return 1;
}
void PLA_summary(pPLA PLA)
{
int var, i;
symbolic_list_t *p2;
symbolic_t *p1;
printf("# PLA is %s", PLA->filename);
if (cube.num_binary_vars == cube.num_vars - 1)
printf(" with %d inputs and %d outputs\n",
cube.num_binary_vars, cube.part_size[cube.num_vars - 1]);
else {
printf(" with %d variables (%d binary, mv sizes",
cube.num_vars, cube.num_binary_vars);
for(var = cube.num_binary_vars; var < cube.num_vars; var++)
printf(" %d", cube.part_size[var]);
printf(")\n");
}
printf("# ON-set cost is %s\n", print_cost(PLA->F));
printf("# OFF-set cost is %s\n", print_cost(PLA->R));
printf("# DC-set cost is %s\n", print_cost(PLA->D));
if (PLA->phase != NULL)
printf("# phase is %s\n", pc1(PLA->phase));
if (PLA->pair != NULL) {
printf("# two-bit decoders:");
for(i = 0; i < PLA->pair->cnt; i++)
printf(" (%d %d)", PLA->pair->var1[i], PLA->pair->var2[i]);
printf("\n");
}
if (PLA->symbolic != nullptr) {
for(p1 = PLA->symbolic; p1 != nullptr; p1 = p1->next) {
printf("# symbolic: ");
for(p2=p1->symbolic_list; p2!=nullptr; p2=p2->next) {
printf(" %d", p2->variable);
}
printf("\n");
}
}
if (PLA->symbolic_output != nullptr) {
for(p1 = PLA->symbolic_output; p1 != nullptr; p1 = p1->next) {
printf("# output symbolic: ");
for(p2=p1->symbolic_list; p2!=nullptr; p2=p2->next) {
printf(" %d", p2->pos);
}
printf("\n");
}
}
(void) fflush(stdout);
}
pPLA new_PLA()
{
pPLA PLA;
PLA = new PLA_t();
PLA->F = PLA->D = PLA->R = (pcover) NULL;
PLA->phase = (pcube) NULL;
PLA->pair = (ppair) NULL;
PLA->label = (char **) NULL;
PLA->filename = (char *) NULL;
PLA->pla_type = 0;
PLA->symbolic = nullptr;
PLA->symbolic_output = nullptr;
return PLA;
}
void PLA_labels(pPLA PLA)
{
int i;
PLA->label = new char*[cube.size];
for(i = 0; i < cube.size; i++)
PLA->label[i] = (char *) NULL;
}
void free_PLA(pPLA PLA)
{
symbolic_list_t *p2, *p2next;
symbolic_t *p1, *p1next;
int i;
if (PLA->F != (pcover) NULL)
free_cover(PLA->F);
if (PLA->R != (pcover) NULL)
free_cover(PLA->R);
if (PLA->D != (pcover) NULL)
free_cover(PLA->D);
if (PLA->phase != (pcube) NULL)
free_cube(PLA->phase);
if (PLA->pair != (ppair) NULL) {
delete PLA->pair->var1;
delete PLA->pair->var2;
delete PLA->pair;
}
if (PLA->label != NULL) {
for(i = 0; i < cube.size; i++)
if (PLA->label[i] != NULL)
delete PLA->label[i];
delete PLA->label;
}
if (PLA->filename != NULL) {
delete PLA->filename;
}
for(p1 = PLA->symbolic; p1 != nullptr; p1 = p1next) {
for(p2 = p1->symbolic_list; p2 != nullptr; p2 = p2next) {
p2next = p2->next;
delete p2;
}
p1next = p1->next;
delete p1;
}
PLA->symbolic = nullptr;
for(p1 = PLA->symbolic_output; p1 != nullptr; p1 = p1next) {
for(p2 = p1->symbolic_list; p2 != nullptr; p2 = p2next) {
p2next = p2->next;
delete p2;
}
p1next = p1->next;
delete p1;
}
PLA->symbolic_output = nullptr;
delete PLA;
}
int read_symbolic(std::istream& fp, pPLA PLA, char* word /* scratch string for words */, symbolic_t ** retval)
{
symbolic_list_t *listp, *prev_listp;
symbolic_label_t *labelp, *prev_labelp;
symbolic_t *newlist;
int i, var;
newlist = new symbolic_t();
newlist->next = nullptr;
newlist->symbolic_list = nullptr;
newlist->symbolic_list_length = 0;
newlist->symbolic_label = nullptr;
newlist->symbolic_label_length = 0;
prev_listp = nullptr;
prev_labelp = nullptr;
for(;;) {
(void) get_word(fp, word);
if (equal(word, ";"))
break;
if (label_index(PLA, word, &var, &i)) {
listp = new symbolic_list_t();
listp->variable = var;
listp->pos = i;
listp->next = nullptr;
if (prev_listp == nullptr) {
newlist->symbolic_list = listp;
} else {
prev_listp->next = listp;
}
prev_listp = listp;
newlist->symbolic_list_length++;
} else {
return false;
}
}
for(;;) {
(void) get_word(fp, word);
if (equal(word, ";"))
break;
labelp = new symbolic_label_t();
labelp->label = strcpy(new char[strlen(word)+1], word);
labelp->next = nullptr;
if (prev_labelp == nullptr) {
newlist->symbolic_label = labelp;
} else {
prev_labelp->next = labelp;
}
prev_labelp = labelp;
newlist->symbolic_label_length++;
}
*retval = newlist;
return TRUE;
}
int label_index(pPLA PLA, char * word, int * varp, int * ip)
{
int var, i;
if (PLA->label == nullptr || PLA->label[0] == nullptr) {
if (sscanf(word, "%d", varp) == 1) {
*ip = *varp;
return TRUE;
}
} else {
for(var = 0; var < cube.num_vars; var++) {
for(i = 0; i < cube.part_size[var]; i++) {
if (equal(PLA->label[cube.first_part[var]+i], word)) {
*varp = var;
*ip = i;
return TRUE;
}
}
}
}
return FALSE;
}
| 27.494937
| 157
| 0.560471
|
AlexeyAkhunov
|
1887c9c86d79dc7f4ae0b85942b5592702355350
| 595
|
cpp
|
C++
|
test/typelist/reverse_test.cpp
|
matrixjoeq/candy
|
53fe18d8b68d2f131c8e1c8f76c7d9b7f752bbdc
|
[
"MIT"
] | null | null | null |
test/typelist/reverse_test.cpp
|
matrixjoeq/candy
|
53fe18d8b68d2f131c8e1c8f76c7d9b7f752bbdc
|
[
"MIT"
] | null | null | null |
test/typelist/reverse_test.cpp
|
matrixjoeq/candy
|
53fe18d8b68d2f131c8e1c8f76c7d9b7f752bbdc
|
[
"MIT"
] | null | null | null |
#include <type_traits>
#include "typelist/reverse.hpp"
namespace candy {
namespace test {
namespace {
struct FirstType;
struct SecondType;
using EmptyTL = Typelist<>;
using FirstTL = Typelist<FirstType>;
using SecondTL = Typelist<FirstType, SecondType>;
using ReverseTL = Typelist<SecondType, FirstType>;
static_assert(std::is_same<Reverse<EmptyTL>, EmptyTL>::value == true, "");
static_assert(std::is_same<Reverse<FirstTL>, FirstTL>::value == true, "");
static_assert(std::is_same<Reverse<SecondTL>, ReverseTL>::value == true, "");
} // namespace
} // namespace test
} // namespace candy
| 24.791667
| 77
| 0.736134
|
matrixjoeq
|
188bc5cba1cf322fc84b0d05875369ffe79abcc6
| 2,772
|
cpp
|
C++
|
Source/Scene/node_layer.cpp
|
neonkingfr/wildogcad
|
6d9798daa672d3ab293579439f38bb279fa376c7
|
[
"BSD-3-Clause"
] | null | null | null |
Source/Scene/node_layer.cpp
|
neonkingfr/wildogcad
|
6d9798daa672d3ab293579439f38bb279fa376c7
|
[
"BSD-3-Clause"
] | null | null | null |
Source/Scene/node_layer.cpp
|
neonkingfr/wildogcad
|
6d9798daa672d3ab293579439f38bb279fa376c7
|
[
"BSD-3-Clause"
] | null | null | null |
/*******************************************************************************
* Copyright (c) 2007, 2008, CerroKai Development
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of CerroKai Development 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 CerroKai Development ``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 CerroKai Development 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.
********************************************************************************/
/*** Included Header Files ***/
#include <Scene/node_layer.h>
/*** Locally Defined Values ***/
//None
/***********************************************~***************************************************/
WCNodeLayer::WCNodeLayer(WCScene *scene, std::string name) : ::WCLayer(scene, name) {
}
WCNodeLayer::~WCNodeLayer() {
}
void WCNodeLayer::AddLayer(void) {
}
void WCNodeLayer::RemoveLayer(void) {
}
WCAlignedBoundingBox WCNodeLayer::BoundingBox(void) {
return WCAlignedBoundingBox();
}
bool WCNodeLayer::OnIdle(void) {
return false;
}
bool WCNodeLayer::OnMouseMove(const WPFloat x, const WPFloat y) {
return false;
}
bool WCNodeLayer::OnMouseDown(const WCMouseButton &button) {
return false;
}
bool WCNodeLayer::OnMouseUp(const WCMouseButton &button) {
return false;
}
bool WCNodeLayer::OnReshape(const WPFloat width, const WPFloat height) {
return false;
}
void WCNodeLayer::Render(WCRenderState *state) {
}
/***********************************************~***************************************************/
| 30.130435
| 101
| 0.650072
|
neonkingfr
|
188c09ac36619ddff05d88bd1808e911fc078ed1
| 7,356
|
cpp
|
C++
|
Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsMaskProcessingView.cpp
|
zhaomengxiao/MITK
|
a09fd849a4328276806008bfa92487f83a9e2437
|
[
"BSD-3-Clause"
] | 1
|
2022-03-03T12:03:32.000Z
|
2022-03-03T12:03:32.000Z
|
Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsMaskProcessingView.cpp
|
zhaomengxiao/MITK
|
a09fd849a4328276806008bfa92487f83a9e2437
|
[
"BSD-3-Clause"
] | 1
|
2021-12-22T10:19:02.000Z
|
2021-12-22T10:19:02.000Z
|
Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsMaskProcessingView.cpp
|
zhaomengxiao/MITK_lancet
|
a09fd849a4328276806008bfa92487f83a9e2437
|
[
"BSD-3-Clause"
] | 1
|
2020-11-27T09:41:18.000Z
|
2020-11-27T09:41:18.000Z
|
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkRadiomicsMaskProcessingView.h"
// QT includes (GUI)
#include <qlabel.h>
#include <qspinbox.h>
#include <qpushbutton.h>
#include <qcheckbox.h>
#include <qgroupbox.h>
#include <qradiobutton.h>
#include <qmessagebox.h>
// Berry includes (selection service)
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// MITK includes (GUI)
#include <QmitkDataStorageComboBox.h>
#include "QmitkDataNodeSelectionProvider.h"
#include "mitkDataNodeObject.h"
// MITK includes (general
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateAnd.h>
#include <mitkProperties.h>
#include <mitkTransformationOperation.h>
#include <mitkLabelSetImage.h>
// Specific GUI Includes
#include <mitkMaskCleaningOperation.h>
QmitkRadiomicsMaskProcessing::QmitkRadiomicsMaskProcessing()
: QmitkAbstractView(),
m_Controls(nullptr)
{
}
QmitkRadiomicsMaskProcessing::~QmitkRadiomicsMaskProcessing()
{
//berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
//if(s)
// s->RemoveSelectionListener(m_SelectionListener);
}
void QmitkRadiomicsMaskProcessing::CreateQtPartControl(QWidget *parent)
{
if (m_Controls == nullptr)
{
m_Controls = new Ui::QmitkRadiomicsMaskProcessingViewControls;
m_Controls->setupUi(parent);
QLabel * label1 = new QLabel("Image: ");
QLabel * label2 = new QLabel("Mask: ");
QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
QmitkDataStorageComboBox * cb_maskimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
m_Controls->m_InputImageGroup->layout()->addWidget(label1);
m_Controls->m_InputImageGroup->layout()->addWidget(cb_inputimage);
m_Controls->m_InputImageGroup->layout()->addWidget(label2);
m_Controls->m_InputImageGroup->layout()->addWidget(cb_maskimage);
this->CreateConnections();
}
}
void QmitkRadiomicsMaskProcessing::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->maskBasedExecutionButton), SIGNAL(clicked() ), this, SLOT(executeButtonIntervalBasedMaskClearning() ) );
connect((QObject*)(m_Controls->outlierRemoveButton), SIGNAL(clicked()), this, SLOT(executeButtonMaskOutlierRemoval()));
}
}
void QmitkRadiomicsMaskProcessing::executeButtonIntervalBasedMaskClearning()
{
QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(3)->widget());
mitk::BaseData* baseDataRawImage = nullptr;
mitk::BaseData* baseDataMaskImage = nullptr;
mitk::Image::Pointer raw_image;
mitk::Image::Pointer mask_image;
std::string nodeName;
if ((cb_image->GetSelectedNode().IsNotNull()) && (cb_maskimage->GetSelectedNode().IsNotNull()))
{
baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
baseDataMaskImage = (cb_maskimage->GetSelectedNode()->GetData());
nodeName = cb_maskimage->GetSelectedNode()->GetName();
}
if ((baseDataRawImage != nullptr) && (baseDataMaskImage != nullptr))
{
raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
mask_image = dynamic_cast<mitk::Image *>(baseDataMaskImage);
}
else {
QMessageBox msgBox;
msgBox.setText("Please specify the images that shlould be used.");
msgBox.exec();
return;
}
if (raw_image.IsNull() || mask_image.IsNull())
{
QMessageBox msgBox;
msgBox.setText("Error during processing the specified images.");
msgBox.exec();
return;
}
bool lowerLimitOn = m_Controls->lowerOn->isChecked();
bool upperLimitOn = m_Controls->upperOn->isChecked();
double lowerLimit = m_Controls->lowerLimitSpinbox->value();
double upperLimit = m_Controls->spinboxUpperValue->value();
auto image = mitk::MaskCleaningOperation::RangeBasedMasking(raw_image, mask_image, lowerLimitOn, lowerLimit, upperLimitOn, upperLimit);
mitk::LabelSetImage::Pointer labelResult = mitk::LabelSetImage::New();
labelResult->InitializeByLabeledImage(image);
mitk::LabelSetImage::Pointer oldLabelSet = dynamic_cast<mitk::LabelSetImage *>(mask_image.GetPointer());
labelResult->AddLabelSetToLayer(labelResult->GetActiveLayer(), oldLabelSet->GetLabelSet());
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetProperty("name", mitk::StringProperty::New(nodeName+"::MaskRange"));
result->SetData(labelResult);
GetDataStorage()->Add(result, cb_image->GetSelectedNode());
}
void QmitkRadiomicsMaskProcessing::executeButtonMaskOutlierRemoval()
{
QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(3)->widget());
mitk::BaseData* baseDataRawImage = nullptr;
mitk::BaseData* baseDataMaskImage = nullptr;
mitk::Image::Pointer raw_image;
mitk::Image::Pointer mask_image;
std::string nodeName;
if ((cb_image->GetSelectedNode().IsNotNull()) && (cb_maskimage->GetSelectedNode().IsNotNull()))
{
baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
baseDataMaskImage = (cb_maskimage->GetSelectedNode()->GetData());
nodeName = cb_maskimage->GetSelectedNode()->GetName();
}
if ((baseDataRawImage != nullptr) && (baseDataMaskImage != nullptr))
{
raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
mask_image = dynamic_cast<mitk::Image *>(baseDataMaskImage);
}
else {
QMessageBox msgBox;
msgBox.setText("Please specify the images that shlould be used.");
msgBox.exec();
return;
}
if (raw_image.IsNull() || mask_image.IsNull())
{
QMessageBox msgBox;
msgBox.setText("Error during processing the specified images.");
msgBox.exec();
return;
}
auto image = mitk::MaskCleaningOperation::MaskOutlierFiltering(raw_image, mask_image);
mitk::LabelSetImage::Pointer labelResult = mitk::LabelSetImage::New();
labelResult->InitializeByLabeledImage(image);
mitk::LabelSetImage::Pointer oldLabelSet = dynamic_cast<mitk::LabelSetImage *>(mask_image.GetPointer());
labelResult->AddLabelSetToLayer(labelResult->GetActiveLayer(), oldLabelSet->GetLabelSet());
mitk::DataNode::Pointer result = mitk::DataNode::New();
result->SetProperty("name", mitk::StringProperty::New(nodeName + "::MaskOutlier"));
result->SetData(labelResult);
GetDataStorage()->Add(result, cb_image->GetSelectedNode());
}
void QmitkRadiomicsMaskProcessing::SetFocus()
{
}
//datamanager selection changed
void QmitkRadiomicsMaskProcessing::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
{
//any nodes there?
if (!nodes.empty())
{
}
}
| 36.415842
| 157
| 0.73192
|
zhaomengxiao
|