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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
215f1f5ebc9379f7692d4b410d57bb03c65910bb | 785 | cpp | C++ | Dataset/Leetcode/train/112/347.cpp | kkcookies99/UAST | fff81885aa07901786141a71e5600a08d7cb4868 | [
"MIT"
] | null | null | null | Dataset/Leetcode/train/112/347.cpp | kkcookies99/UAST | fff81885aa07901786141a71e5600a08d7cb4868 | [
"MIT"
] | null | null | null | Dataset/Leetcode/train/112/347.cpp | kkcookies99/UAST | fff81885aa07901786141a71e5600a08d7cb4868 | [
"MIT"
] | null | null | null | class Solution {
public:
bool XXX(TreeNode* root, int targetSum) {
if(root==NULL)return false;
if(dfs(root,targetSum,0)){
return true;
}
return false;
}
bool dfs(TreeNode* root, int targetSum,int sum){
if(root!=NULL && root->left==NULL && root->right==NULL &&sum+root->val==targetSum){
return true;
}
sum+=root->val;
bool r1,r2;
if(root->left){
r1=dfs(root->left,targetSum,sum);
}
if(root->right){
r2=dfs(root->right,targetSum,sum);
}
return r1|r2;
}
};
undefined
for (i = 0; i < document.getElementsByTagName("code").length; i++) { console.log(document.getElementsByTagName("code")[i].innerText); }
| 25.322581 | 139 | 0.532484 | kkcookies99 |
2163e2ca54a2843b4ff01a6e6583dae9ee2f58d4 | 145 | cpp | C++ | func/demo/sleep_short.cpp | J-Heinemann/faasm | 6a7472d73ef7cc18e63617c72715c8775afd11a9 | [
"Apache-2.0"
] | 1 | 2020-04-21T07:33:42.000Z | 2020-04-21T07:33:42.000Z | func/demo/sleep_short.cpp | J-Heinemann/faasm | 6a7472d73ef7cc18e63617c72715c8775afd11a9 | [
"Apache-2.0"
] | 4 | 2020-02-03T18:54:32.000Z | 2020-05-13T18:28:28.000Z | func/demo/sleep_short.cpp | J-Heinemann/faasm | 6a7472d73ef7cc18e63617c72715c8775afd11a9 | [
"Apache-2.0"
] | null | null | null | #include "faasm/faasm.h"
#include <unistd.h>
#define SLEEP_TIME_SECONDS 25
FAASM_MAIN_FUNC() {
sleep(SLEEP_TIME_SECONDS);
return 0;
}
| 13.181818 | 30 | 0.710345 | J-Heinemann |
2166639b89d5e8b22d1e0af575d4381c2ecc93c9 | 7,774 | cpp | C++ | Encodings/src/Windows1255Encoding.cpp | astlin/poco | b878152e9034b89c923bc3c97e16ae1b92c09bf4 | [
"BSL-1.0"
] | 5,766 | 2015-01-01T01:27:15.000Z | 2022-03-31T09:27:29.000Z | Encodings/src/Windows1255Encoding.cpp | astlin/poco | b878152e9034b89c923bc3c97e16ae1b92c09bf4 | [
"BSL-1.0"
] | 2,345 | 2015-01-01T20:43:10.000Z | 2022-03-31T19:45:02.000Z | Encodings/src/Windows1255Encoding.cpp | astlin/poco | b878152e9034b89c923bc3c97e16ae1b92c09bf4 | [
"BSL-1.0"
] | 1,963 | 2015-01-01T01:29:44.000Z | 2022-03-31T06:41:54.000Z | //
// Windows1255Encoding.cpp
//
// Library: Encodings
// Package: Encodings
// Module: Windows1255Encoding
//
// Copyright (c) 2018, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#include "Poco/Windows1255Encoding.h"
namespace Poco {
const char* Windows1255Encoding::_names[] =
{
"windows-1255",
"Windows-1255",
"cp1255",
"CP1255",
NULL
};
const TextEncoding::CharacterMap Windows1255Encoding::_charMap =
{
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
0x20AC, -1, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, 0x02C6, 0x2030, -1, 0x2039, -1, -1, -1, -1,
-1, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0x02DC, 0x2122, -1, 0x203A, -1, -1, -1, -1,
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AA, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7, 0x05B8, 0x05B9, -1, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3, 0x05F4, -1, -1, -1, -1, -1, -1, -1,
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA, -1, -1, 0x200E, 0x200F, -1,
};
const DoubleByteEncoding::Mapping Windows1255Encoding::_mappingTable[] = {
{ 0x0000, 0x0000 } // dummy entry
};
const DoubleByteEncoding::Mapping Windows1255Encoding::_reverseMappingTable[] = {
{ 0x0000, 0x0000 }, { 0x0001, 0x0001 }, { 0x0002, 0x0002 }, { 0x0003, 0x0003 }, { 0x0004, 0x0004 }, { 0x0005, 0x0005 }, { 0x0006, 0x0006 }, { 0x0007, 0x0007 },
{ 0x0008, 0x0008 }, { 0x0009, 0x0009 }, { 0x000A, 0x000A }, { 0x000B, 0x000B }, { 0x000C, 0x000C }, { 0x000D, 0x000D }, { 0x000E, 0x000E }, { 0x000F, 0x000F },
{ 0x0010, 0x0010 }, { 0x0011, 0x0011 }, { 0x0012, 0x0012 }, { 0x0013, 0x0013 }, { 0x0014, 0x0014 }, { 0x0015, 0x0015 }, { 0x0016, 0x0016 }, { 0x0017, 0x0017 },
{ 0x0018, 0x0018 }, { 0x0019, 0x0019 }, { 0x001A, 0x001A }, { 0x001B, 0x001B }, { 0x001C, 0x001C }, { 0x001D, 0x001D }, { 0x001E, 0x001E }, { 0x001F, 0x001F },
{ 0x0020, 0x0020 }, { 0x0021, 0x0021 }, { 0x0022, 0x0022 }, { 0x0023, 0x0023 }, { 0x0024, 0x0024 }, { 0x0025, 0x0025 }, { 0x0026, 0x0026 }, { 0x0027, 0x0027 },
{ 0x0028, 0x0028 }, { 0x0029, 0x0029 }, { 0x002A, 0x002A }, { 0x002B, 0x002B }, { 0x002C, 0x002C }, { 0x002D, 0x002D }, { 0x002E, 0x002E }, { 0x002F, 0x002F },
{ 0x0030, 0x0030 }, { 0x0031, 0x0031 }, { 0x0032, 0x0032 }, { 0x0033, 0x0033 }, { 0x0034, 0x0034 }, { 0x0035, 0x0035 }, { 0x0036, 0x0036 }, { 0x0037, 0x0037 },
{ 0x0038, 0x0038 }, { 0x0039, 0x0039 }, { 0x003A, 0x003A }, { 0x003B, 0x003B }, { 0x003C, 0x003C }, { 0x003D, 0x003D }, { 0x003E, 0x003E }, { 0x003F, 0x003F },
{ 0x0040, 0x0040 }, { 0x0041, 0x0041 }, { 0x0042, 0x0042 }, { 0x0043, 0x0043 }, { 0x0044, 0x0044 }, { 0x0045, 0x0045 }, { 0x0046, 0x0046 }, { 0x0047, 0x0047 },
{ 0x0048, 0x0048 }, { 0x0049, 0x0049 }, { 0x004A, 0x004A }, { 0x004B, 0x004B }, { 0x004C, 0x004C }, { 0x004D, 0x004D }, { 0x004E, 0x004E }, { 0x004F, 0x004F },
{ 0x0050, 0x0050 }, { 0x0051, 0x0051 }, { 0x0052, 0x0052 }, { 0x0053, 0x0053 }, { 0x0054, 0x0054 }, { 0x0055, 0x0055 }, { 0x0056, 0x0056 }, { 0x0057, 0x0057 },
{ 0x0058, 0x0058 }, { 0x0059, 0x0059 }, { 0x005A, 0x005A }, { 0x005B, 0x005B }, { 0x005C, 0x005C }, { 0x005D, 0x005D }, { 0x005E, 0x005E }, { 0x005F, 0x005F },
{ 0x0060, 0x0060 }, { 0x0061, 0x0061 }, { 0x0062, 0x0062 }, { 0x0063, 0x0063 }, { 0x0064, 0x0064 }, { 0x0065, 0x0065 }, { 0x0066, 0x0066 }, { 0x0067, 0x0067 },
{ 0x0068, 0x0068 }, { 0x0069, 0x0069 }, { 0x006A, 0x006A }, { 0x006B, 0x006B }, { 0x006C, 0x006C }, { 0x006D, 0x006D }, { 0x006E, 0x006E }, { 0x006F, 0x006F },
{ 0x0070, 0x0070 }, { 0x0071, 0x0071 }, { 0x0072, 0x0072 }, { 0x0073, 0x0073 }, { 0x0074, 0x0074 }, { 0x0075, 0x0075 }, { 0x0076, 0x0076 }, { 0x0077, 0x0077 },
{ 0x0078, 0x0078 }, { 0x0079, 0x0079 }, { 0x007A, 0x007A }, { 0x007B, 0x007B }, { 0x007C, 0x007C }, { 0x007D, 0x007D }, { 0x007E, 0x007E }, { 0x007F, 0x007F },
{ 0x00A0, 0x00A0 }, { 0x00A1, 0x00A1 }, { 0x00A2, 0x00A2 }, { 0x00A3, 0x00A3 }, { 0x00A5, 0x00A5 }, { 0x00A6, 0x00A6 }, { 0x00A7, 0x00A7 }, { 0x00A8, 0x00A8 },
{ 0x00A9, 0x00A9 }, { 0x00AB, 0x00AB }, { 0x00AC, 0x00AC }, { 0x00AD, 0x00AD }, { 0x00AE, 0x00AE }, { 0x00AF, 0x00AF }, { 0x00B0, 0x00B0 }, { 0x00B1, 0x00B1 },
{ 0x00B2, 0x00B2 }, { 0x00B3, 0x00B3 }, { 0x00B4, 0x00B4 }, { 0x00B5, 0x00B5 }, { 0x00B6, 0x00B6 }, { 0x00B7, 0x00B7 }, { 0x00B8, 0x00B8 }, { 0x00B9, 0x00B9 },
{ 0x00BB, 0x00BB }, { 0x00BC, 0x00BC }, { 0x00BD, 0x00BD }, { 0x00BE, 0x00BE }, { 0x00BF, 0x00BF }, { 0x00D7, 0x00AA }, { 0x00F7, 0x00BA }, { 0x0192, 0x0083 },
{ 0x02C6, 0x0088 }, { 0x02DC, 0x0098 }, { 0x05B0, 0x00C0 }, { 0x05B1, 0x00C1 }, { 0x05B2, 0x00C2 }, { 0x05B3, 0x00C3 }, { 0x05B4, 0x00C4 }, { 0x05B5, 0x00C5 },
{ 0x05B6, 0x00C6 }, { 0x05B7, 0x00C7 }, { 0x05B8, 0x00C8 }, { 0x05B9, 0x00C9 }, { 0x05BB, 0x00CB }, { 0x05BC, 0x00CC }, { 0x05BD, 0x00CD }, { 0x05BE, 0x00CE },
{ 0x05BF, 0x00CF }, { 0x05C0, 0x00D0 }, { 0x05C1, 0x00D1 }, { 0x05C2, 0x00D2 }, { 0x05C3, 0x00D3 }, { 0x05D0, 0x00E0 }, { 0x05D1, 0x00E1 }, { 0x05D2, 0x00E2 },
{ 0x05D3, 0x00E3 }, { 0x05D4, 0x00E4 }, { 0x05D5, 0x00E5 }, { 0x05D6, 0x00E6 }, { 0x05D7, 0x00E7 }, { 0x05D8, 0x00E8 }, { 0x05D9, 0x00E9 }, { 0x05DA, 0x00EA },
{ 0x05DB, 0x00EB }, { 0x05DC, 0x00EC }, { 0x05DD, 0x00ED }, { 0x05DE, 0x00EE }, { 0x05DF, 0x00EF }, { 0x05E0, 0x00F0 }, { 0x05E1, 0x00F1 }, { 0x05E2, 0x00F2 },
{ 0x05E3, 0x00F3 }, { 0x05E4, 0x00F4 }, { 0x05E5, 0x00F5 }, { 0x05E6, 0x00F6 }, { 0x05E7, 0x00F7 }, { 0x05E8, 0x00F8 }, { 0x05E9, 0x00F9 }, { 0x05EA, 0x00FA },
{ 0x05F0, 0x00D4 }, { 0x05F1, 0x00D5 }, { 0x05F2, 0x00D6 }, { 0x05F3, 0x00D7 }, { 0x05F4, 0x00D8 }, { 0x200E, 0x00FD }, { 0x200F, 0x00FE }, { 0x2013, 0x0096 },
{ 0x2014, 0x0097 }, { 0x2018, 0x0091 }, { 0x2019, 0x0092 }, { 0x201A, 0x0082 }, { 0x201C, 0x0093 }, { 0x201D, 0x0094 }, { 0x201E, 0x0084 }, { 0x2020, 0x0086 },
{ 0x2021, 0x0087 }, { 0x2022, 0x0095 }, { 0x2026, 0x0085 }, { 0x2030, 0x0089 }, { 0x2039, 0x008B }, { 0x203A, 0x009B }, { 0x20AA, 0x00A4 }, { 0x20AC, 0x0080 },
{ 0x2122, 0x0099 },
};
Windows1255Encoding::Windows1255Encoding():
DoubleByteEncoding(_names, _charMap, _mappingTable, sizeof(_mappingTable)/sizeof(Mapping), _reverseMappingTable, sizeof(_reverseMappingTable)/sizeof(Mapping))
{
}
Windows1255Encoding::~Windows1255Encoding()
{
}
} // namespace Poco
| 75.475728 | 161 | 0.635709 | astlin |
2168d655b057510ad187d6e787408f95ad9dc382 | 1,270 | cpp | C++ | Cpp/Lambdas/lambda.cpp | DirtbagDrew/Lectures | 275d0884771b6e59bd1b732639e950651e922d9e | [
"MIT"
] | null | null | null | Cpp/Lambdas/lambda.cpp | DirtbagDrew/Lectures | 275d0884771b6e59bd1b732639e950651e922d9e | [
"MIT"
] | null | null | null | Cpp/Lambdas/lambda.cpp | DirtbagDrew/Lectures | 275d0884771b6e59bd1b732639e950651e922d9e | [
"MIT"
] | null | null | null | #include <iostream>
#include <functional>
using std::cout;
using std::endl;
std::function<int(int)> ReturnFunc();
int main() {
auto f = []() {
cout << "Hello from an anonymous function!" << endl;
};
// Examine the type of f
f();
auto g = [](int a) {
return a + 13;
};
// What is the return type of g? How is that determined?
cout << g(5) << endl;
// So what's with the square brackets?
int outer1 = 10, outer2 = 50;
auto h = [outer1](int a) {
return a + outer1;
};
cout << h(5) << endl;
// The brackets define a "capture list": explicitly listing which variables
// from the outer scope should be available inside the lambda.
// "outer2" cannot be used because it is not captured.
// What happens if I change outer1 now?
outer1 = 100;
cout << h(5) << endl;
// Still prints 15... why? Think about where outer1 lives, and where h could
// be returned to (another scope?). So what was actually captured?
auto i = ReturnFunc();
cout << i(5) << endl;
}
std::function<int(int)> ReturnFunc() {
int local = 10;
auto func = [&local](int param) {
return local * param;
};
local = 100;
return func;
} | 22.280702 | 80 | 0.568504 | DirtbagDrew |
217032cf78f0dadd8cf0245bc17d62e53dc0a148 | 2,640 | cpp | C++ | ojcpp/leetcode/300/337_houserobber3.cpp | softarts/oj | 2f51f360a7a6c49e865461755aec2f3a7e721b9e | [
"Apache-2.0"
] | 3 | 2019-05-04T03:26:02.000Z | 2019-08-29T01:20:44.000Z | ojcpp/leetcode/300/337_houserobber3.cpp | softarts/oj | 2f51f360a7a6c49e865461755aec2f3a7e721b9e | [
"Apache-2.0"
] | null | null | null | ojcpp/leetcode/300/337_houserobber3.cpp | softarts/oj | 2f51f360a7a6c49e865461755aec2f3a7e721b9e | [
"Apache-2.0"
] | null | null | null | //
// Created by rui.zhou on 4/12/2019.
//
/*
* The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the "root." Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that "all houses in this place forms a binary tree". It will automatically contact the police if two directly-linked houses were broken into on the same night.
Determine the maximum amount of money the thief can rob tonight without alerting the police.
Example 1:
Input: [3,2,3,null,3,null,1]
3
/ \
2 3
\ \
3 1
Output: 7
Explanation: Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
Example 2:
Input: [3,4,5,1,3,null,1]
3
/ \
4 5
/ \ \
1 3 1
Output: 9
Explanation: Maximum amount of money the thief can rob = 4 + 5 = 9.
*/
#include <codech/codech_def.h>
using namespace std;
using namespace CODECH;
namespace {
class Solution0 {
public:
int maxVal = INT_MIN;
int rob(TreeNode* root) {
int amount=0;
dfs(root, amount, false);
return maxVal;
}
void dfs(TreeNode *node, int &amount, bool skip) {
if (!node)
return;
if (!skip) {
amount+=node->val;
dfs(node->left,amount,true);
dfs(node->right,amount,true);
maxVal=max(amount,maxVal);
amount-=node->val;
}
dfs(node->left,amount,false);
dfs(node->right,amount,false);
maxVal=max(amount,maxVal);
}
};
//
class Solution {
public:
int rob(TreeNode* root) {
auto pr=dfs(root);
return pr.second;
}
pair<int,int> dfs(TreeNode *node) {
if (!node)
return make_pair(0,0);
int val = node->val;
//pair->first => take this node
//pair->second => not take this node
auto pl = dfs(node->left);
auto pr = dfs(node->right);
int temp=max(val+pl.first+pr.first,pl.second+pr.second);
int first = pl.second+pr.second; //
int second = temp;
return make_pair(first,second);
}
};
}
DEFINE_CODE_TEST(337_rob_house3)
{
Solution obj;
{
TreeNode *root=LCREATE_TREENODE({4,1,null,2,null,3,null,null,null});
VERIFY_CASE(obj.rob(root),7);
}
{
TreeNode *root=LCREATE_TREENODE({3,4,5,1,3,null,1,null,null,null,null,null,null});
VERIFY_CASE(obj.rob(root),9);
}
} | 26.666667 | 389 | 0.554167 | softarts |
21726313a39d0d825a1bae95c70cc94c51a17b7e | 1,214 | cpp | C++ | src/crypto/hash.cpp | g-ongetta/CCF | 190b3ca4c41d83719df6aa37c6493cff976ed163 | [
"Apache-2.0"
] | null | null | null | src/crypto/hash.cpp | g-ongetta/CCF | 190b3ca4c41d83719df6aa37c6493cff976ed163 | [
"Apache-2.0"
] | null | null | null | src/crypto/hash.cpp | g-ongetta/CCF | 190b3ca4c41d83719df6aa37c6493cff976ed163 | [
"Apache-2.0"
] | null | null | null | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the Apache 2.0 License.
#include "hash.h"
#include <mbedtls/sha256.h>
#include <stdexcept>
extern "C"
{
#include <evercrypt/EverCrypt_Hash.h>
}
using namespace std;
void crypto::Sha256Hash::mbedtls_sha256(
initializer_list<CBuffer> il, uint8_t* h)
{
mbedtls_sha256_context ctx;
mbedtls_sha256_starts_ret(&ctx, 0);
for (auto data : il)
{
mbedtls_sha256_update_ret(&ctx, data.p, data.rawSize());
}
mbedtls_sha256_finish_ret(&ctx, h);
mbedtls_sha256_free(&ctx);
}
void crypto::Sha256Hash::evercrypt_sha256(
initializer_list<CBuffer> il, uint8_t* h)
{
EverCrypt_Hash_state_s* state =
EverCrypt_Hash_create(Spec_Hash_Definitions_SHA2_256);
EverCrypt_Hash_init(state);
for (auto data : il)
{
EverCrypt_Hash_update_multi(
state, const_cast<uint8_t*>(data.p), data.rawSize());
EverCrypt_Hash_update_last(
state, const_cast<uint8_t*>(data.p), data.rawSize());
}
EverCrypt_Hash_finish(state, h);
EverCrypt_Hash_free(state);
}
crypto::Sha256Hash::Sha256Hash() : h{0} {}
crypto::Sha256Hash::Sha256Hash(initializer_list<CBuffer> il) : h{0}
{
evercrypt_sha256(il, h.data());
} | 22.481481 | 67 | 0.724053 | g-ongetta |
2173bf7c03e21a2684a03cddbff9954f8583e0b7 | 5,917 | cpp | C++ | shore/shore-mt/src/fc/w_debug.cpp | anshsarkar/TailBench | 25845756aee9a892229c25b681051591c94daafd | [
"MIT"
] | 4 | 2019-01-24T02:00:23.000Z | 2021-03-17T11:56:59.000Z | shore/shore-mt/src/fc/w_debug.cpp | anshsarkar/TailBench | 25845756aee9a892229c25b681051591c94daafd | [
"MIT"
] | 1 | 2021-11-25T18:08:22.000Z | 2021-11-25T18:08:22.000Z | shore/shore-mt/src/fc/w_debug.cpp | anshsarkar/TailBench | 25845756aee9a892229c25b681051591c94daafd | [
"MIT"
] | 4 | 2019-01-22T10:35:55.000Z | 2021-03-17T11:57:23.000Z | /*<std-header orig-src='shore'>
$Id: w_debug.cpp,v 1.1.2.1 2010/01/28 04:53:07 nhall Exp $
SHORE -- Scalable Heterogeneous Object REpository
Copyright (c) 1994-99 Computer Sciences Department, University of
Wisconsin -- Madison
All Rights Reserved.
Permission to use, copy, modify and distribute this software and its
documentation is hereby granted, provided that both the copyright
notice and this permission notice appear in all copies of the
software, derivative works or modified versions, and any portions
thereof, and that both notices appear in supporting documentation.
THE AUTHORS AND THE COMPUTER SCIENCES DEPARTMENT OF THE UNIVERSITY
OF WISCONSIN - MADISON ALLOW FREE USE OF THIS SOFTWARE IN ITS
"AS IS" CONDITION, AND THEY DISCLAIM ANY LIABILITY OF ANY KIND
FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
This software was developed with support by the Advanced Research
Project Agency, ARPA order number 018 (formerly 8230), monitored by
the U.S. Army Research Laboratory under contract DAAB07-91-C-Q518.
Further funding for this work was provided by DARPA through
Rome Research Laboratory Contract No. F30602-97-2-0247.
*/
#include "w_defines.h"
/* -- do not edit anything above this line -- </std-header>*/
#ifdef __GNUG__
#pragma implementation
#endif
#include <w_debug.h>
#ifdef __ERRLOG_C__
// gcc implementation in errlog.cpp since it is in #included there
/* compile this stuff even if -UDEBUG because
* other layers might be using -DDEBUG
* and we want to be able to link, in any case
*/
#include <w_stream.h>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include "w_debug.h"
#ifdef W_TRACE
w_debug _w_debug("debug", getenv("DEBUG_FILE"));
#endif
#ifdef USE_REGEX
bool _w_debug::re_ready = false;
regex_t _w_debug::re_posix_re;
char* _w_debug::re_error_str = "Bad regular expression";
#endif /* USE_REGEX */
// I'm ambivalent about making this thread-safe.
// To do so would require moving this and all related tests into
// sthread/.
// The disadvantage is that it would that much more change the
// timing of things.
// The errlog and such is most useful for debugging single-threaded
// tests anyway, and still somewhat useful for mt stuff despite this
// being not-safe; it would clearly change the timing for mt situations
// we're trying to debug; I think it's probably more useful to
// decipher mixed-up debugging output for those cases.
//
w_debug::w_debug(const char *n, const char *f) :
ErrLog(n, log_to_unix_file, f?f:"-")
{
#ifdef USE_REGEX
//re_ready = false;
//re_error_str = "Bad regular expression";
re_syntax_options = RE_NO_BK_VBAR;
#endif /* USE_REGEX */
mask = 0;
const char *temp_flags = getenv("DEBUG_FLAGS");
// malloc the flags so it can be freed
if(!temp_flags) {
temp_flags = "";
mask = _none;
}
// make a copy of the flags so we can delete it later
_flags = new char[strlen(temp_flags)+1];
strcpy(_flags, temp_flags);
assert(_flags != NULL);
if(!strcmp(_flags,"all")) {
mask |= _all;
#ifdef USE_REGEX
} else if(!none()) {
char *s;
if((s=re_comp_debug(_flags)) != 0) {
if(strstr(s, "No previous regular expression")) {
// this is ok
} else {
cerr << "Error in regex, flags not set: " << s << endl;
}
mask = _none;
}
#endif /* USE_REGEX */
}
assert( !( none() && all() ) );
}
w_debug::~w_debug()
{
if(_flags) delete [] _flags;
_flags = NULL;
}
void
w_debug::setflags(const char *newflags)
{
if(!newflags) return;
#ifdef USE_REGEX
{
char *s;
if((s=re_comp_debug(newflags)) != 0) {
cerr << "Error in regex, flags not set: " << s << endl;
mask = _none;
return;
}
}
#endif /* USE_REGEX */
mask = 0;
if(_flags) delete [] _flags;
_flags = new char[strlen(newflags)+1];
strcpy(_flags, newflags);
if(strlen(_flags)==0) {
mask |= _none;
} else if(!strcmp(_flags,"all")) {
mask |= _all;
}
assert( !( none() && all() ) );
}
#ifdef USE_REGEX
int
w_debug::re_exec_debug(const char* string)
{
if (!re_ready) {
cerr << __LINE__
<< " " << __FILE__
<< ": No compiled string." <<endl;
return 0;
}
int match = (re_exec_posix(string)==1);
return match;
}
char*
w_debug::re_comp_debug(const char* pattern)
{
if (re_ready)
regfree(&re_posix_re);
char *res;
res = re_comp_posix(pattern);
if(res) {
cerr << __LINE__
<< " " << __FILE__
<< " Error in re_comp_debug: " << res << endl;
}
re_ready = true;
return NULL;
}
#endif /* USE_REGEX */
int
w_debug::flag_on(
const char *fn,
const char *file
)
{
int res = 0;
assert( !( none() && all() ) );
if(_flags==NULL) {
res = 0; // another constructor called this
// before this's constructor got called.
} else if(none()) {
res = 0;
} else if(all()) {
res = 1;
#ifdef USE_REGEX
} else if(file && re_exec_debug(file)) {
res = 1;
} else if(fn && re_exec_debug(fn)) {
res = 1;
#endif /* USE_REGEX */
} else
// if the regular expression didn't match,
// try searching the strings
if(file && strstr(_flags,file)) {
res = 1;
} else if(fn && strstr(_flags,fn)) {
res = 1;
}
return res;
}
/* This function prints a hex dump of (len) bytes at address (p) */
void
w_debug::memdump(void *p, int len)
{
register int i;
char *c = (char *)p;
clog << "x";
for(i=0; i< len; i++) {
W_FORM2(clog,("%2.2x", (*(c+i))&0xff));
if(i%32 == 31) {
clog << endl << "x";
} else if(i%4 == 3) {
clog << " x";
}
}
clog << "--done" << endl;
}
#endif /* __ERRLOG_C__ */
| 24.861345 | 71 | 0.618726 | anshsarkar |
21752185978bfe99310a7581b4c2c2cf6c0a85cf | 11,749 | cpp | C++ | Source/Catastrophe_VS/Characters/PlayerCharacter/PlayerCharacter.cpp | Enderderder/Catastrophe_VerticalSlice | 679a04e86db363c3bca642512b86f5b2a8cca1be | [
"MIT"
] | null | null | null | Source/Catastrophe_VS/Characters/PlayerCharacter/PlayerCharacter.cpp | Enderderder/Catastrophe_VerticalSlice | 679a04e86db363c3bca642512b86f5b2a8cca1be | [
"MIT"
] | null | null | null | Source/Catastrophe_VS/Characters/PlayerCharacter/PlayerCharacter.cpp | Enderderder/Catastrophe_VerticalSlice | 679a04e86db363c3bca642512b86f5b2a8cca1be | [
"MIT"
] | null | null | null | // Fill out your copyright notice in the Description page of Project Settings.
#include "PlayerCharacter.h"
#include "Camera/CameraComponent.h"
#include "Camera/CameraActor.h"
#include "Components/CapsuleComponent.h"
#include "Components/InputComponent.h"
#include "Components/StaticMeshComponent.h"
#include "Components/SkeletalMeshComponent.h"
#include "GameFramework/Controller.h"
#include "GameFramework/SpringArmComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "Math/UnrealMathUtility.h"
#include "Kismet/GameplayStatics.h"
#include "GameFramework/PlayerController.h"
#include "Interactable/InteractActor.h"
#include "Interactable/BaseClasses/InteractableObject.h"
#include "Interactable/BaseClasses/InteractableComponent.h"
//#include "Engine.h"
// Sets default values
APlayerCharacter::APlayerCharacter()
{
// Set this character to call Tick() every frame.
// You can turn this off to improve performance if you don't need it.
//PrimaryActorTick.bCanEverTick = true;
// Set the tomato that will show inside players hand
TomatoInHandMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("TomatoInHandMesh"));
TomatoInHandMesh->SetupAttachment(GetMesh(), TEXT("TomatoSocket"));
// set our turn rates for input
BaseTurnRate = 45.f;
BaseLookUpRate = 45.f;
// Don't rotate when the controller rotates. Let that just affect the camera.
bUseControllerRotationPitch = false;
bUseControllerRotationYaw = false;
bUseControllerRotationRoll = false;
// Configure character movement
GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...
GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate
GetCharacterMovement()->JumpZVelocity = 600.f;
GetCharacterMovement()->AirControl = 0.2f;
// Create a camera boom (pulls in towards the player if there is a collision)
FollowCameraFocusPoint = CreateDefaultSubobject<USceneComponent>(TEXT("FollowCameraFocusPoint"));
FollowCameraFocusPoint->SetupAttachment(GetMesh());
CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
CameraBoom->SetupAttachment(RootComponent);
CameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character
CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller
// Create a follow camera
FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm
// // Create a stationary camera that sits high above the player
// BirdEyeCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("BirdCamera"));
TomatoSpawnPoint = CreateDefaultSubobject<USceneComponent>(TEXT("TomatoSpawnPoint"));
TomatoSpawnPoint->SetupAttachment(GetMesh());
AimDownSightFocusPoint = CreateDefaultSubobject<USceneComponent>(TEXT("AimDownSightFocusPoint"));
AimDownSightFocusPoint->SetupAttachment(GetMesh());
FishToCarry = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FishToCarry"));
FishToCarry->SetupAttachment(GetMesh(), TEXT("FishBackSocket"));
}
// Called when the game starts or when spawned
void APlayerCharacter::BeginPlay()
{
Super::BeginPlay();
// Attach the camera to the focus point
CameraBoom->AttachToComponent(FollowCameraFocusPoint, FAttachmentTransformRules::KeepRelativeTransform);
// Make sure the bird eye camera is not being use at the beignning
bIsBirdEyeCamera = false;
// Default Interaction state
bAbleToShootTomato = true;
CheckTomatoInHand();
}
// Called every frame
void APlayerCharacter::Tick(float DeltaTime)
{
/// To use the tick function, go to the constructor
/// and uncomment the " PrimaryActorTick.bCanEverTick = true; "
Super::Tick(DeltaTime);
}
// Called to bind functionality to input
void APlayerCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
Super::SetupPlayerInputComponent(PlayerInputComponent);
// Set up gameplay key bindings
check(PlayerInputComponent);
PlayerInputComponent->BindAxis("MoveForward", this, &APlayerCharacter::MoveForward);
PlayerInputComponent->BindAxis("MoveRight", this, &APlayerCharacter::MoveRight);
PlayerInputComponent->BindAction("Crouch", IE_Pressed, this, &APlayerCharacter::StartCrouch);
PlayerInputComponent->BindAction("Crouch", IE_Released, this, &APlayerCharacter::EndCrouch);
// We have 2 versions of the rotation bindings to handle different kinds of devices differently
// "turn" handles devices that provide an absolute delta, such as a mouse.
// "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
PlayerInputComponent->BindAxis("TurnRate", this, &APlayerCharacter::TurnAtRate);
PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
PlayerInputComponent->BindAxis("LookUpRate", this, &APlayerCharacter::LookUpAtRate);
// Player other action (Interactions and Functionalities)
PlayerInputComponent->BindAction("Interact", IE_Pressed, this, &APlayerCharacter::InteractAction);
PlayerInputComponent->BindAction("Interact", IE_Released, this, &APlayerCharacter::InteractActionEnd);
PlayerInputComponent->BindAction("BirdViewToggle", IE_Pressed, this, &APlayerCharacter::CameraToggle);
PlayerInputComponent->BindAction("AimDownSight", IE_Pressed, this, &APlayerCharacter::AimDownSight);
PlayerInputComponent->BindAction("AimDownSight", IE_Released, this, &APlayerCharacter::ExitAimDownSight);
PlayerInputComponent->BindAction("Shoot", IE_Pressed, this, &APlayerCharacter::ShootTomato);
}
void APlayerCharacter::TurnAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}
void APlayerCharacter::LookUpAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}
void APlayerCharacter::StartCrouch()
{
Crouch();
}
void APlayerCharacter::EndCrouch()
{
UnCrouch();
}
void APlayerCharacter::CheckTomatoInHand()
{
if (TomatoCurrentCount > 0)
{
TomatoInHandMesh->SetVisibility(true);
}
else
{
TomatoInHandMesh->SetVisibility(false);
}
}
void APlayerCharacter::MoveForward(float Value)
{
if ((Controller != NULL) && (Value != 0.0f))
{
// find out which way is forward
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get forward vector
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
AddMovementInput(Direction, Value);
}
}
void APlayerCharacter::MoveRight(float Value)
{
if ((Controller != nullptr) && (Value != 0.0f))
{
// find out which way is right
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get right vector
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
// add movement in that direction
AddMovementInput(Direction, Value);
}
}
void APlayerCharacter::CameraToggle()
{
// Blueprint implement event
ReceiveCameraToggle();
// Do the flip flop
bIsBirdEyeCamera = !bIsBirdEyeCamera;
if (bIsBirdEyeCamera)
{
// Disable the movement
GetCharacterMovement()->SetMovementMode(MOVE_None);
bAbleToShootTomato = false;
APlayerController* playerController = UGameplayStatics::GetPlayerController(this, 0);
if (playerController)
{
AActor* birdViewCameraAcrtor;
TArray<AActor*> resultActorArray;
UGameplayStatics::GetAllActorsOfClass(this, BirdViewCameraClass, resultActorArray);
if (resultActorArray.Num() != 0)
{
birdViewCameraAcrtor = resultActorArray[0];
playerController->SetViewTargetWithBlend(birdViewCameraAcrtor, 1.0f);
}
}
}
else
{
// Re-enable the movement
GetCharacterMovement()->SetMovementMode(MOVE_Walking);
bAbleToShootTomato = true;
APlayerController* playerController = UGameplayStatics::GetPlayerController(this, 0);
if (playerController)
{
playerController->SetViewTargetWithBlend(this, 1.0f);
}
}
}
void APlayerCharacter::AimDownSight()
{
// Abort when player cant shoot tomato
if (!bAbleToShootTomato)
return;
// Change the ADS state to true
AimDownSightState = true;
// Let the character follow camera rotation
bUseControllerRotationYaw = true;
CameraBoom->AttachToComponent(AimDownSightFocusPoint, FAttachmentTransformRules::KeepRelativeTransform);
//CameraBoom->TargetArmLength *= CameraZoomRatio;
// Call the blueprint implemented event
Receive_AimDownSight();
}
void APlayerCharacter::ExitAimDownSight()
{
// Abort when ads state is not even set
if (!AimDownSightState)
return;
// Change the ADS state to false
AimDownSightState = false;
// Let the character not follow camera rotation
bUseControllerRotationYaw = false;
CameraBoom->AttachToComponent(FollowCameraFocusPoint, FAttachmentTransformRules::KeepRelativeTransform);
//CameraBoom->TargetArmLength /= CameraZoomRatio;
// Call the blueprint implemented event
Receive_ExitAimDownSight();
}
void APlayerCharacter::ShootTomato()
{
// Validate the obejct pointer
// Check if the player is ADSing
// Check if there is enough tomato to shoot
if (TomatoObject
&& AimDownSightState == true
&& bAbleToShootTomato == true
&& TomatoCurrentCount > 0)
{
// Set the parameter for spawning the shuriken
FVector tomatoSpawnLocation;
FRotator tomatoSpawnRotation;
FActorSpawnParameters tomatoSpawnInfo;
tomatoSpawnInfo.Owner = this;
tomatoSpawnInfo.SpawnCollisionHandlingOverride = ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
tomatoSpawnLocation = TomatoSpawnPoint->GetComponentLocation();
tomatoSpawnRotation = FollowCamera->GetComponentRotation();
// Spawn the tomato
APawn* SpawnedTomato;
SpawnedTomato = GetWorld()->SpawnActor<APawn>(TomatoObject, tomatoSpawnLocation, tomatoSpawnRotation, tomatoSpawnInfo);
// Lower the ammo
TomatoCurrentCount--;
// Check if theres tomato left in the hand
CheckTomatoInHand();
}
}
void APlayerCharacter::InteractAction()
{
if (InteractTarget && !InteractTarget->IsPendingKill())
{
if (InteractTarget->GetClass()->ImplementsInterface(
UInteractableObject::StaticClass()))
{
IInteractableObject::Execute_OnInteract(InteractTarget, this);
RemoveInteractionTarget(InteractTarget);
}
else if (UInteractableComponent* interactableComp =
InteractTarget->FindComponentByClass<UInteractableComponent>())
{
interactableComp->Interact(this);
}
}
}
void APlayerCharacter::InteractActionEnd()
{
}
void APlayerCharacter::RestoreAllTomatos()
{
TomatoCurrentCount = TomatoTotalCount;
CheckTomatoInHand();
}
void APlayerCharacter::RestoreTomato(int _count)
{
TomatoCurrentCount = FMath::Min(TomatoTotalCount, TomatoCurrentCount + _count);
CheckTomatoInHand();
}
void APlayerCharacter::GrabbingFish()
{
// Set the visibility of the fish to visible
FishToCarry->SetVisibility(true);
}
void APlayerCharacter::SetInteractionTarget(class AActor* _interactTarget)
{
if (auto interactableInterface = Cast<IInteractableObject>(_interactTarget)
|| _interactTarget->FindComponentByClass<UInteractableComponent>())
{
InteractTarget = _interactTarget;
}
}
void APlayerCharacter::RemoveInteractionTarget(class AActor* _interactTarget)
{
if (_interactTarget == InteractTarget)
{
InteractTarget = nullptr;
}
}
| 32.366391 | 180 | 0.779471 | Enderderder |
21780b5deb5965454673038016d281c8618c23e2 | 924 | cpp | C++ | cli/gflag/src/module.cpp | ArcticNature/extentions | 386b6cc88fd9b05ca1c94190e882a0a18f55a898 | [
"BSD-3-Clause"
] | null | null | null | cli/gflag/src/module.cpp | ArcticNature/extentions | 386b6cc88fd9b05ca1c94190e882a0a18f55a898 | [
"BSD-3-Clause"
] | null | null | null | cli/gflag/src/module.cpp | ArcticNature/extentions | 386b6cc88fd9b05ca1c94190e882a0a18f55a898 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2015 Stefano Pogliani <stefano@spogliani.net>
#include <string>
#include "core/interface/lifecycle.h"
#include "core/lifecycle/process.h"
#include "core/registry/cli-parser.h"
#include "ext/cli/gflags.h"
using sf::core::interface::BaseLifecycleArg;
using sf::core::interface::BaseLifecycleHandler;
using sf::core::interface::Lifecycle;
using sf::core::interface::LifecycleHandlerRef;
using sf::core::lifecycle::Process;
using sf::core::model::CLIParser;
using sf::core::registry::CLIParsers;
sf::core::model::CLIParser* gflags_factory() {
return new sf::ext::cli::GFlagsCLI();
}
//! Module initialiser for the GFlags module.
class CliGFlagsInitHandler : public BaseLifecycleHandler {
public:
void handle(std::string event, BaseLifecycleArg*) {
CLIParsers::RegisterFactory("gflags", gflags_factory);
}
};
// Register the initialiser.
LifecycleStaticOn("process::init", CliGFlagsInitHandler);
| 26.4 | 58 | 0.756494 | ArcticNature |
2178596a209e969d49d86c8c8c24bf273129f7a4 | 364 | cpp | C++ | Bit Algorithm/Count Number of Set Bits in A Number/SolutionByAbhay.cpp | Mdanish777/Programmers-Community | b5ca9582fc1cd4337baa7077ff62130a1052583f | [
"MIT"
] | 261 | 2019-09-30T19:47:29.000Z | 2022-03-29T18:20:07.000Z | Bit Algorithm/Count Number of Set Bits in A Number/SolutionByAbhay.cpp | Mdanish777/Programmers-Community | b5ca9582fc1cd4337baa7077ff62130a1052583f | [
"MIT"
] | 647 | 2019-10-01T16:51:29.000Z | 2021-12-16T20:39:44.000Z | Bit Algorithm/Count Number of Set Bits in A Number/SolutionByAbhay.cpp | Mdanish777/Programmers-Community | b5ca9582fc1cd4337baa7077ff62130a1052583f | [
"MIT"
] | 383 | 2019-09-30T19:32:07.000Z | 2022-03-24T16:18:26.000Z | #include <bits/stdc++.h>
using namespace std;
int setBits(int number)
{
int count = 0;
while (number != 0) {
if (number & 1 == 1) {
++count;
}
number = number >> 1;
}
return count;
}
int main(int argc, char const* argv[])
{
int number;
cin >> number;
cout << setBits(number) << endl;
return 0;
} | 17.333333 | 38 | 0.508242 | Mdanish777 |
2178de00e32fa4fe8f39f55dd10e6fcd455becfd | 4,154 | cpp | C++ | engine/graphics/Private/PipelineDesc.cpp | azhirnov/AE | 31a42b9bf3bdd86304d565d66e4710e7d89d7392 | [
"MIT"
] | 2 | 2019-11-14T17:55:26.000Z | 2022-01-12T09:38:29.000Z | engine/graphics/Private/PipelineDesc.cpp | azhirnov/AE | 31a42b9bf3bdd86304d565d66e4710e7d89d7392 | [
"MIT"
] | null | null | null | engine/graphics/Private/PipelineDesc.cpp | azhirnov/AE | 31a42b9bf3bdd86304d565d66e4710e7d89d7392 | [
"MIT"
] | 1 | 2020-04-11T16:04:31.000Z | 2020-04-11T16:04:31.000Z | // Copyright (c) 2018-2020, Zhirnov Andrey. For more information see 'LICENSE'
#include "graphics/Public/PipelineDesc.h"
namespace AE::Graphics
{
/*
=================================================
GraphicsPipelineDesc::operator ==
=================================================
*/
bool GraphicsPipelineDesc::operator == (const GraphicsPipelineDesc &rhs) const
{
return (renderPassId == rhs.renderPassId) &
(subpassIndex == rhs.subpassIndex) &
(viewportCount == rhs.viewportCount) &
(vertexInput == rhs.vertexInput) &
(renderState == rhs.renderState) &
(dynamicState == rhs.dynamicState) &
(specialization == rhs.specialization);
}
/*
=================================================
GraphicsPipelineDesc::CalcHash
=================================================
*/
HashVal GraphicsPipelineDesc::CalcHash () const
{
HashVal result;
result << HashOf( renderPassId );
result << HashOf( subpassIndex );
result << HashOf( viewportCount );
result << vertexInput.CalcHash();
result << renderState.CalcHash();
result << HashOf( dynamicState );
result << HashOf( specialization );
return result;
}
//-----------------------------------------------------------------------------
/*
=================================================
MeshPipelineDesc::operator ==
=================================================
*/
bool MeshPipelineDesc::operator == (const MeshPipelineDesc &rhs) const
{
return (renderPassId == rhs.renderPassId) &
(subpassIndex == rhs.subpassIndex) &
(viewportCount == rhs.viewportCount) &
(renderState == rhs.renderState) &
(dynamicState == rhs.dynamicState) &
(taskGroupSize.has_value() == rhs.taskGroupSize.has_value()) &
(taskGroupSize.has_value() ?
All( *taskGroupSize == *rhs.taskGroupSize ) : true) &
(meshGroupSize.has_value() == rhs.meshGroupSize.has_value()) &
(meshGroupSize.has_value() ?
All( *meshGroupSize == *rhs.meshGroupSize ) : true) &
(specialization == rhs.specialization);
}
/*
=================================================
MeshPipelineDesc::CalcHash
=================================================
*/
HashVal MeshPipelineDesc::CalcHash () const
{
HashVal result;
result << HashOf( renderPassId );
result << HashOf( subpassIndex );
result << HashOf( viewportCount );
result << renderState.CalcHash();
result << HashOf( dynamicState );
result << HashOf( taskGroupSize );
result << HashOf( meshGroupSize );
result << HashOf( specialization );
return result;
}
//-----------------------------------------------------------------------------
/*
=================================================
ComputePipelineDesc::operator ==
=================================================
*/
bool ComputePipelineDesc::operator == (const ComputePipelineDesc &rhs) const
{
return (localGroupSize.has_value() == rhs.localGroupSize.has_value()) &
(localGroupSize.has_value() ?
All( *localGroupSize == *rhs.localGroupSize ) : true) &
(specialization == rhs.specialization) &
(dispatchBase == rhs.dispatchBase);
}
/*
=================================================
ComputePipelineDesc::CalcHash
=================================================
*/
HashVal ComputePipelineDesc::CalcHash () const
{
HashVal result;
result << HashOf( localGroupSize );
result << HashOf( specialization );
result << HashOf( dispatchBase );
return result;
}
//-----------------------------------------------------------------------------
/*
=================================================
RayTracingPipelineDesc::operator ==
=================================================
*/
bool RayTracingPipelineDesc::operator == (const RayTracingPipelineDesc &rhs) const
{
return (specialization == rhs.specialization);
}
/*
=================================================
RayTracingPipelineDesc::CalcHash
=================================================
*/
HashVal RayTracingPipelineDesc::CalcHash () const
{
HashVal result;
result << HashOf( specialization );
return result;
}
} // AE::Graphics
| 29.671429 | 84 | 0.508907 | azhirnov |
21792114ff9d5ef38c87bcc5e0548e9ad7c614f9 | 9,539 | cpp | C++ | hanse_ros/hanse_wall_sonar/src/wall_follow_fancy_node.cpp | iti-luebeck/HANSE2012 | fd2348823a6a51baf87cd493529f085fb22d65a7 | [
"BSD-3-Clause"
] | null | null | null | hanse_ros/hanse_wall_sonar/src/wall_follow_fancy_node.cpp | iti-luebeck/HANSE2012 | fd2348823a6a51baf87cd493529f085fb22d65a7 | [
"BSD-3-Clause"
] | null | null | null | hanse_ros/hanse_wall_sonar/src/wall_follow_fancy_node.cpp | iti-luebeck/HANSE2012 | fd2348823a6a51baf87cd493529f085fb22d65a7 | [
"BSD-3-Clause"
] | null | null | null | #include "wall_follow_fancy_node.h"
using namespace Eigen;
WallFollowFancyNode::WallFollowFancyNode(ros::NodeHandle n):node_(n){
//advertise publishers
pub_goal_ = node_.advertise<geometry_msgs::PoseStamped>("sonar/wall_follow/goal", 1000);
pub_circles_ = node_.advertise<geometry_msgs::PolygonStamped>("sonar/fancy/circles", 1000);
pub_path_ = node_.advertise<geometry_msgs::PolygonStamped>("sonar/fancy/path", 1000);
//setup subscribers
setupSubscribers();
}
void WallFollowFancyNode::sonarLaserUpdate(
const geometry_msgs::PolygonStamped::ConstPtr& msg) throw (std::runtime_error)
{
//create eigen object for robot position and oriantation
const Vector3d robot_position(last_pose_.position.x, last_pose_.position.y, last_pose_.position.z);
const Quaterniond robot_oriantation(last_pose_.orientation.w,
last_pose_.orientation.x,
last_pose_.orientation.y,
last_pose_.orientation.z);
//calculate the robot yaw angle
Vector3d robot_rot;
robot_rot = robot_oriantation * Vector3d::UnitX();
const double robot_yaw_angle = atan2(robot_rot(1), robot_rot(0));
//create vector of Vector3d for global sonar points that are in front of the robot
std::vector<Vector3d> global_front_sonar_points;
for(const geometry_msgs::Point32 &p : msg->polygon.points){
Vector3d vp(p.x, p.y, p.z);
if(!isBehindRobot(vp, robot_yaw_angle, robot_position)){
//add point if it isn't behind the robot
global_front_sonar_points.push_back(vp);
}
}
// create std::vector<Vector3d> of points in a circle
std::vector<Vector3d> circ;
for (unsigned int i = 0; i < 360; i+=config_.boundingcircle_angle_steps_) {
const Vector3d dVector = config_.boundingcircle_radius_ * Vector3d::UnitX();
AngleAxisd rotate(angles::from_degrees((double) i), Vector3d::UnitZ());
circ.push_back(rotate * dVector);
}
std::list<Vector3d> result;
for (const auto &p: global_front_sonar_points) {
//create point circle for current point
std::list<Vector3d> pCirc;
for (const auto &c:circ) {
Vector3d circ_point = c + p;
pCirc.push_back(circ_point);
}
//filter unwanted points
for (std::list<Vector3d>::iterator it = pCirc.begin(); it != pCirc.end(); ) {
// remove all points that lie inside other circles
const Vector3d &pc(*it);
if(isInsideOtherCircle(config_.boundingcircle_radius_, global_front_sonar_points, pc)){
//remove point if it lies inside another circle
it = pCirc.erase(it);
} else if(isBehindRobot(pc, robot_yaw_angle, robot_position)){
//remove point if it is behind a robot
it = pCirc.erase(it);
} else {
//keep point and continue with next point
it++;
}
}
result.insert(result.end(), pCirc.begin(), pCirc.end());
}
//Greedy Algorithm to calculate goal point and orientation
//getting a list of points by looking at the next points that are close to each other
//limit by a limit_lookahead_distancee, limit_lookahead_index_delta and limit_point_sdistance
const double limit_point_sdistance = pow(config_.limit_point_distance_, 2);
const double limit_lookahead_sdistance = pow(config_.limit_lookahead_distance_, 2);
std::vector<Vector3d> nearest_point_list = {robot_position};
for(int i = 0; i < config_.limit_lookahead_index_delta_; i++){
//use last point in nearest_point_list as reference point
const Vector3d &ref_point(*(--nearest_point_list.end()));
//initialize
Vector3d const *nearestPoint = NULL;
double nearest_sdistance = DBL_MAX;
//search nearest point
for(const Vector3d &p: result){
const double p_sdistance = (p - ref_point).squaredNorm();
if(p_sdistance < nearest_sdistance //is nearer
&& (p-robot_position).squaredNorm() < limit_lookahead_sdistance //check lookahead distance limit
&& std::find(nearest_point_list.begin(),nearest_point_list.end(),p)==nearest_point_list.end() //isn't already the nearest point list
&& p_sdistance < limit_point_sdistance //check if distance between the two points is small enough
){
nearestPoint = &p;
nearest_sdistance = (*nearestPoint - ref_point).squaredNorm();
}
}
//check if we found a new Point
if(nearest_sdistance != DBL_MAX){
nearest_point_list.push_back(*nearestPoint);
} else {
//give up because there aren't any closer points
break;
}
}
//remove robot position
nearest_point_list.erase(nearest_point_list.begin());
//sum up all chosen nearest points
Vector3d sum(0, 0, 0);
for(const auto &p:nearest_point_list){
sum += p - robot_position;
}
//calculate goal position
Vector3d goal;
goal = 3 * sum / sum.norm() + robot_position;
//calculate goal orientation
Quaterniond goal_orientation;
goal_orientation = AngleAxisd(atan2(sum(1), sum(0)), Vector3d::UnitZ());
//create Stamped Pose to publish
geometry_msgs::PoseStamped spose;
spose.header.frame_id = "/map";
spose.header.stamp = ros::Time::now();
spose.pose.position.x = goal(0);
spose.pose.position.y = goal(1);
spose.pose.position.z = goal(2);
spose.pose.orientation.x = goal_orientation.x();
spose.pose.orientation.y = goal_orientation.y();
spose.pose.orientation.z = goal_orientation.z();
spose.pose.orientation.w = goal_orientation.w();
//publish circels and path
publishDebugInfo(result, nearest_point_list);
//publish goal
pub_goal_.publish(spose);
}
bool WallFollowFancyNode::isBehindRobot(const Vector3d &p, const double &robot_yaw_angle, const Vector3d &robot_position)
{
//calculate position relative to robot
Vector3d p_reltative = p - robot_position;
double p_angle = atan2(p_reltative(1), p_reltative(0));
double diff = robot_yaw_angle - p_angle;
diff = fmod(diff + 2.5 * M_PI, 2 * M_PI);
//return true if the point p is behind
return ((diff > M_PI));
}
bool WallFollowFancyNode::isInsideOtherCircle(const double &distance, const std::vector<Vector3d> &global_sonar_points, const Vector3d &p)
{
for (const Vector3d &q : global_sonar_points) {
if ((q - p).norm() < distance) {
return true;
}
}
return false;
}
void WallFollowFancyNode::publishDebugInfo(const std::list<Vector3d> &circle_points,const std::vector<Vector3d> &path_points){
geometry_msgs::PolygonStamped spolygon;
spolygon.header.frame_id = "/map";
spolygon.header.stamp = ros::Time::now();
//create polygon from valid points
for(const Vector3d &point: circle_points){
geometry_msgs::Point32 p;
p.x = point(0);
p.y = point(1);
p.z = point(2);
spolygon.polygon.points.push_back(p);
}
pub_circles_.publish(spolygon);
//create polygon from valid points
spolygon.polygon.points.clear();
for(const Vector3d &point: path_points){
geometry_msgs::Point32 p;
p.x = point(0);
p.y = point(1);
p.z = point(2);
spolygon.polygon.points.push_back(p);
}
pub_path_.publish(spolygon);
}
void WallFollowFancyNode::configCallback(hanse_wall_sonar::wall_follow_fancy_node_paramsConfig &config, uint32_t level){
bool old_sim_mode = this->config_.simulation_mode_;
this->config_ = config;
//check if simulation mode changed and subscribe to new subscriber if needed
if (config.simulation_mode_ != old_sim_mode){
setupSubscribers();
}
}
void WallFollowFancyNode::posUpdate(const geometry_msgs::PoseStamped::ConstPtr &msg){
//update last pose
last_pose_ = msg->pose;
}
void WallFollowFancyNode::setupSubscribers(){
sub_pos_.shutdown();
sub_global_sonar_.shutdown();
//Subscribe to topic laser_scan (from sonar)
sub_global_sonar_ = node_.subscribe<geometry_msgs::PolygonStamped>("sonar/global_sonar/polygon", 1000, &WallFollowFancyNode::sonarLaserUpdate, this);
if(config_.simulation_mode_){
//Subscribe to the current position
sub_pos_ = node_.subscribe<geometry_msgs::PoseStamped>("posemeter", 1000, &WallFollowFancyNode::posUpdate, this);
}else {
//Subscribe to the current position
sub_pos_ = node_.subscribe<geometry_msgs::PoseStamped>("position/estimate", 1000, &WallFollowFancyNode::posUpdate, this);
}
}
int main(int argc, char **argv)
{
// init wall follow node
ros::init(argc, argv, "wall_follow_fancy_node");
//create NodeHandle
ros::NodeHandle n;
WallFollowFancyNode wall_follow_fancy_node(n);
// Set up a dynamic reconfigure server.
// This should be done before reading parameter server values.
dynamic_reconfigure::Server<hanse_wall_sonar::wall_follow_fancy_node_paramsConfig> dr_srv;
dynamic_reconfigure::Server<hanse_wall_sonar::wall_follow_fancy_node_paramsConfig>::CallbackType cb;
cb = boost::bind(&WallFollowFancyNode::configCallback, &wall_follow_fancy_node, _1, _2);
dr_srv.setCallback(cb);
ros::Rate loop_rate(10);
ros::spin();
return 0;
}
| 36.830116 | 153 | 0.667366 | iti-luebeck |
217cb9cd795a06ba066b98343082d40530e90512 | 6,712 | cpp | C++ | src/core/lib/core_qt_common/controls/wg_action.cpp | wgsyd/wgtf | d8cacb43e2c5d40080d33c18a8c2f5bd27d21bed | [
"BSD-3-Clause"
] | 28 | 2016-06-03T05:28:25.000Z | 2019-02-14T12:04:31.000Z | src/core/lib/core_qt_common/controls/wg_action.cpp | karajensen/wgtf | 740397bcfdbc02bc574231579d57d7c9cd5cc26d | [
"BSD-3-Clause"
] | null | null | null | src/core/lib/core_qt_common/controls/wg_action.cpp | karajensen/wgtf | 740397bcfdbc02bc574231579d57d7c9cd5cc26d | [
"BSD-3-Clause"
] | 14 | 2016-06-03T05:52:27.000Z | 2019-03-21T09:56:03.000Z | #include "wg_action.hpp"
#include "core_generic_plugin/interfaces/i_component_context.hpp"
#include "core_ui_framework/i_ui_application.hpp"
#include "core_ui_framework/i_ui_framework.hpp"
#include "core_ui_framework/i_action.hpp"
#include "core_qt_common/interfaces/i_qt_helpers.hpp"
#include "helpers/qt_helpers.hpp"
#include <QQmlEngine>
#include <QQmlContext>
namespace wgt
{
struct WGAction::Implementation : Depends<IQtHelpers, IUIApplication, IUIFramework>
{
Implementation(WGAction* self)
// TODO: This is extremely wasteful as we don't need per instance lambdas
: func_([self](IAction*) { emit self->triggered(); }),
enabledFunc_([self](const IAction*) { return self->getEnabled(); }),
checkedFunc_([self](const IAction*) { return self->getChecked(); }), checkable_(false), checked_(false),
enabled_(true), visible_(true), self_(self), active_(false), separator_(false), componentComplete_(false)
{
}
~Implementation()
{
destroyAction();
}
void onComponentComplete()
{
componentComplete_ = true;
createAction();
}
bool getActive() const
{
return active_;
}
void setActive(bool active)
{
if (active_ == active)
{
return;
}
active_ = active;
auto uiApplication = get<IUIApplication>();
if (uiApplication == nullptr || action_ == nullptr || visible_ == false)
{
return;
}
active_ ? uiApplication->addAction(*action_) : uiApplication->removeAction(*action_);
}
QString getActionId() const
{
return actionId_.c_str();
}
void setActionId(const QString& actionId)
{
destroyAction();
actionId_ = actionId.toUtf8().data();
createAction();
}
QString getActionText() const
{
return actionText_.c_str();
}
void setActionText(const QString& actionText)
{
destroyAction();
actionText_ = actionText.toUtf8().data();
createAction();
}
QString getActionPath() const
{
return actionPath_.c_str();
}
void setActionPath(const QString& actionPath)
{
destroyAction();
actionPath_ = actionPath.toUtf8().data();
createAction();
}
bool getCheckable() const
{
return checkable_;
}
void setCheckable(bool checkable)
{
destroyAction();
checkable_ = checkable;
createAction();
}
bool getChecked() const
{
return checked_;
}
void setChecked(bool checked)
{
destroyAction();
checked_ = checked;
createAction();
}
bool getEnabled() const
{
return enabled_;
}
void setEnabled(bool enabled)
{
enabled_ = enabled;
}
bool getVisible() const
{
return visible_;
}
bool getSeparator() const
{
return separator_;
}
void setSeparator(bool separator)
{
separator_ = separator;
}
void setVisible(bool visible)
{
if (visible_ == visible)
{
return;
}
visible_ = visible;
auto uiApplication = get<IUIApplication>();
if (uiApplication == nullptr || action_ == nullptr || active_ == false)
{
return;
}
visible_ ? uiApplication->addAction(*action_) : uiApplication->removeAction(*action_);
}
QVariant data()
{
if (action_ && self_)
{
auto qdata = get<IQtHelpers>()->toQVariant(action_->getData(), this->self_);
return qdata;
}
return QVariant();
}
void setData(const QVariant& qdata)
{
if (action_)
{
auto data = get<IQtHelpers>()->toVariant(qdata);
action_->setData(data);
emit self_->dataChanged();
}
}
void createAction()
{
if (componentComplete_ == false)
{
return;
}
auto uiFramework = get<IUIFramework>();
if (uiFramework == nullptr)
{
return;
}
if (actionId_.empty() && getSeparator())
{
action_ = uiFramework->createAction("", "", actionPath_.c_str(), nullptr, enabledFunc_, nullptr);
}
else if (actionPath_.empty() || actionText_.empty())
{
action_ =
uiFramework->createAction(actionId_.c_str(), func_, enabledFunc_, checkable_ ? checkedFunc_ : nullptr);
}
else
{
action_ = uiFramework->createAction(actionId_.c_str(), actionText_.c_str(), actionPath_.c_str(), func_,
enabledFunc_, checkable_ ? checkedFunc_ : nullptr);
}
auto uiApplication = get<IUIApplication>();
if (action_ == nullptr || uiApplication == nullptr || active_ == false || visible_ == false)
{
return;
}
uiApplication->addAction(*action_);
}
void destroyAction()
{
if (action_ == nullptr)
{
return;
}
auto uiApplication = get<IUIApplication>();
if (uiApplication != nullptr && active_ == true && visible_ == true)
{
uiApplication->removeAction(*action_);
}
action_.reset();
}
WGAction* self_;
std::function<void(IAction*)> func_;
std::function<bool(const IAction*)> enabledFunc_;
std::function<bool(const IAction*)> checkedFunc_;
bool checkable_ : 1;
bool checked_ : 1;
bool enabled_ : 1;
bool visible_ : 1;
bool active_ : 1;
bool separator_ : 1;
bool componentComplete_ : 1;
std::string actionId_;
std::string actionText_;
std::string actionPath_;
std::unique_ptr<IAction> action_;
};
WGAction::WGAction(QQuickItem* parent) : QQuickItem(parent)
{
impl_.reset(new Implementation(this));
}
WGAction::~WGAction()
{
}
void WGAction::componentComplete()
{
QQuickItem::componentComplete();
impl_->onComponentComplete();
}
bool WGAction::getActive() const
{
return impl_->getActive();
}
void WGAction::setActive(bool active)
{
impl_->setActive(active);
}
QString WGAction::getActionId() const
{
return impl_->getActionId();
}
void WGAction::setActionId(const QString& actionId)
{
impl_->setActionId(actionId);
}
QString WGAction::getActionText() const
{
return impl_->getActionText();
}
void WGAction::setActionText(const QString& actionId)
{
impl_->setActionText(actionId);
}
QString WGAction::getActionPath() const
{
return impl_->getActionPath();
}
void WGAction::setActionPath(const QString& actionId)
{
impl_->setActionPath(actionId);
}
bool WGAction::getCheckable() const
{
return impl_->getCheckable();
}
void WGAction::setCheckable(bool checkable)
{
impl_->setCheckable(checkable);
}
bool WGAction::getChecked() const
{
return impl_->getChecked();
}
void WGAction::setChecked(bool checked)
{
impl_->setChecked(checked);
}
bool WGAction::getEnabled() const
{
return impl_->getEnabled();
}
void WGAction::setEnabled(bool enabled)
{
impl_->setEnabled(enabled);
}
bool WGAction::getVisible() const
{
return impl_->getVisible();
}
bool WGAction::getSeparator() const
{
return impl_->getSeparator();
}
void WGAction::setSeparator(bool separator)
{
impl_->setSeparator(separator);
}
QVariant WGAction::data() const
{
return impl_->data();
}
void WGAction::setData(const QVariant& userData)
{
impl_->setData(userData);
}
void WGAction::setVisible(bool visible)
{
impl_->setVisible(visible);
}
} // end namespace wgt
| 18.23913 | 112 | 0.692342 | wgsyd |
217ee0498a3f16453bac3dad2f37d3ea1b1a372f | 4,826 | cpp | C++ | data/magic_mount/core/socket.cpp | chaveza6870/tsu | 69eef801bdb85f6b51ec322c0fc0782f3e2f7af1 | [
"MIT"
] | 1 | 2019-12-22T22:42:20.000Z | 2019-12-22T22:42:20.000Z | data/magic_mount/core/socket.cpp | micc9/tsu | 69eef801bdb85f6b51ec322c0fc0782f3e2f7af1 | [
"MIT"
] | null | null | null | data/magic_mount/core/socket.cpp | micc9/tsu | 69eef801bdb85f6b51ec322c0fc0782f3e2f7af1 | [
"MIT"
] | 1 | 2019-12-14T16:13:48.000Z | 2019-12-14T16:13:48.000Z | /* socket.c - All socket related operations
*/
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <endian.h>
#include <daemon.h>
#include <utils.h>
#include <logging.h>
#define ABS_SOCKET_LEN(sun) (sizeof(sa_family_t) + strlen(sun->sun_path + 1) + 1)
socklen_t setup_sockaddr(struct sockaddr_un *sun, const char *name) {
memset(sun, 0, sizeof(*sun));
sun->sun_family = AF_LOCAL;
strcpy(sun->sun_path + 1, name);
return ABS_SOCKET_LEN(sun);
}
int create_rand_socket(struct sockaddr_un *sun) {
memset(sun, 0, sizeof(*sun));
sun->sun_family = AF_LOCAL;
gen_rand_str(sun->sun_path + 1, sizeof(sun->sun_path) - 1);
int fd = xsocket(AF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC, 0);
xbind(fd, (struct sockaddr*) sun, ABS_SOCKET_LEN(sun));
xlisten(fd, 1);
return fd;
}
int socket_accept(int sockfd, int timeout) {
struct pollfd pfd = {
.fd = sockfd,
.events = POLL_IN
};
return xpoll(&pfd, 1, timeout * 1000) <= 0 ? -1 : xaccept4(sockfd, nullptr, nullptr, SOCK_CLOEXEC);
}
void get_client_cred(int fd, struct ucred *cred) {
socklen_t ucred_length = sizeof(*cred);
getsockopt(fd, SOL_SOCKET, SO_PEERCRED, cred, &ucred_length);
}
/*
* Receive a file descriptor from a Unix socket.
* Contributed by @mkasick
*
* Returns the file descriptor on success, or -1 if a file
* descriptor was not actually included in the message
*
* On error the function terminates by calling exit(-1)
*/
int recv_fd(int sockfd) {
// Need to receive data from the message, otherwise don't care about it.
char iovbuf;
struct cmsghdr *cmsg;
struct iovec iov = {
.iov_base = &iovbuf,
.iov_len = 1,
};
char cmsgbuf[CMSG_SPACE(sizeof(int))];
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
.msg_control = cmsgbuf,
.msg_controllen = sizeof(cmsgbuf),
};
xrecvmsg(sockfd, &msg, MSG_WAITALL);
// Was a control message actually sent?
switch (msg.msg_controllen) {
case 0:
// No, so the file descriptor was closed and won't be used.
return -1;
case sizeof(cmsgbuf):
// Yes, grab the file descriptor from it.
break;
default:
goto error;
}
cmsg = CMSG_FIRSTHDR(&msg);
if (cmsg == nullptr ||
cmsg->cmsg_len != CMSG_LEN(sizeof(int)) ||
cmsg->cmsg_level != SOL_SOCKET ||
cmsg->cmsg_type != SCM_RIGHTS) {
error:
LOGE("unable to read fd");
exit(-1);
}
return *(int *)CMSG_DATA(cmsg);
}
/*
* Send a file descriptor through a Unix socket.
* Contributed by @mkasick
*
* On error the function terminates by calling exit(-1)
*
* fd may be -1, in which case the dummy data is sent,
* but no control message with the FD is sent.
*/
void send_fd(int sockfd, int fd) {
// Need to send some data in the message, this will do.
char junk[] = { '\0' };
struct iovec iov = {
.iov_base = junk,
.iov_len = 1,
};
struct msghdr msg = {
.msg_iov = &iov,
.msg_iovlen = 1,
};
char cmsgbuf[CMSG_SPACE(sizeof(int))];
if (fd != -1) {
// Is the file descriptor actually open?
if (fcntl(fd, F_GETFD) == -1) {
if (errno != EBADF) {
PLOGE("unable to send fd");
}
// It's closed, don't send a control message or sendmsg will EBADF.
} else {
// It's open, send the file descriptor in a control message.
msg.msg_control = cmsgbuf;
msg.msg_controllen = sizeof(cmsgbuf);
struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
*(int *)CMSG_DATA(cmsg) = fd;
}
}
xsendmsg(sockfd, &msg, 0);
}
int read_int(int fd) {
int val;
if (xxread(fd, &val, sizeof(val)) != sizeof(val))
return -1;
return val;
}
int read_int_be(int fd) {
uint32_t val;
if (xxread(fd, &val, sizeof(val)) != sizeof(val))
return -1;
return ntohl(val);
}
void write_int(int fd, int val) {
if (fd < 0) return;
xwrite(fd, &val, sizeof(val));
}
void write_int_be(int fd, int val) {
uint32_t nl = htonl(val);
xwrite(fd, &nl, sizeof(nl));
}
static char *rd_str(int fd, int len) {
char *val = (char *) xmalloc(sizeof(char) * (len + 1));
xxread(fd, val, len);
val[len] = '\0';
return val;
}
char* read_string(int fd) {
int len = read_int(fd);
return rd_str(fd, len);
}
char* read_string_be(int fd) {
int len = read_int_be(fd);
return rd_str(fd, len);
}
void write_string(int fd, const char *val) {
if (fd < 0) return;
int len = strlen(val);
write_int(fd, len);
xwrite(fd, val, len);
}
void write_string_be(int fd, const char *val) {
int len = strlen(val);
write_int_be(fd, len);
xwrite(fd, val, len);
}
void write_key_value(int fd, const char *key, const char *val) {
write_string_be(fd, key);
write_string_be(fd, val);
}
void write_key_token(int fd, const char *key, int tok) {
char val[16];
sprintf(val, "%d", tok);
write_key_value(fd, key, val);
}
| 22.551402 | 100 | 0.652507 | chaveza6870 |
2180b81131c7b38844182fdd9fd43f8577c701bc | 9,818 | cxx | C++ | src/tools/log-common/log-desc.cxx | ManticoreProject/manticore | 74b07c02ebc6c69764c1256ff0c02a921dcaefbb | [
"MIT"
] | 60 | 2017-12-13T20:07:32.000Z | 2022-01-21T09:15:40.000Z | src/tools/log-common/log-desc.cxx | ManticoreProject/pmlc | 74b07c02ebc6c69764c1256ff0c02a921dcaefbb | [
"MIT"
] | 21 | 2016-02-12T21:30:13.000Z | 2020-03-25T02:22:44.000Z | src/tools/log-common/log-desc.cxx | ManticoreProject/manticore | 74b07c02ebc6c69764c1256ff0c02a921dcaefbb | [
"MIT"
] | 8 | 2016-01-21T20:47:53.000Z | 2020-04-30T14:31:42.000Z | /*! \file log-desc.cxx
*
* \author John Reppy
*/
/*
* COPYRIGHT (c) 2009 The Manticore Project (http://manticore.cs.uchicago.edu)
* All rights reserved.
*/
#include "event-desc.hxx"
#include "log-desc.hxx"
#include <string.h>
#include <stdio.h> /* FIXME: replace error message in AddTransition with something else */
#include <stdlib.h> /* FIXME: replace exit in AddTransition with something else */
#include <stack>
#include <assert.h>
/* additional info about events */
struct EventGrpInfo {
std::vector<StateGroup *> *stateGrps;
std::vector<IntervalGroup *> *intervalGrps;
std::vector<DependentGroup *> *dependentGrps;
};
inline char *CopyString (const char *s)
{
if (s == 0)
return 0;
else
return strcpy (new char[strlen(s)+1], s);
}
/***** class Group member functions *****/
Group::Group (const char *desc, GroupKind kind)
{
this->_desc = CopyString(desc);
this->_kind = kind;
}
Group::~Group ()
{
delete this->_desc;
}
bool Group::containsEvent (EventDesc *) const
{
return false;
}
/***** class EventGroup member functions *****/
EventGroup::EventGroup (const char *desc, int nEvents, int nGroups)
: Group (desc, EVENT_GROUP),
_events(nEvents, (EventDesc *)0),
_groups(nGroups, (Group *)0)
{
}
EventGroup::~EventGroup ()
{
}
bool EventGroup::containsEvent (EventDesc *evt) const
{
/* check the list of events */
for (unsigned int i = 0; i < this->_events.size(); i++) {
if (this->_events[i] == evt)
return true;
}
/* recursively check sub-groups */
for (unsigned int i = 0; i < this->_groups.size(); i++) {
if (this->_groups[i]->containsEvent(evt))
return true;
}
/* otherwise, not in this group */
return false;
}
void EventGroup::AddEvent (int i, EventDesc *item)
{
this->_events.at(i) = item;
}
void EventGroup::AddGroup (int i, Group *item)
{
this->_groups.at(i) = item;
item->SetGroup (this);
}
/***** class StateGroup member functions *****/
StateGroup::StateGroup (const char *desc, int nStates, int nTransitions)
: Group (desc, STATE_GROUP),
_stateNames(nStates, (const char *)0),
_stateColors(nStates, (const char *)0),
_transitions(nTransitions, StateTransition()),
_events()
{
}
StateGroup::~StateGroup ()
{
for (unsigned int i = 0; i < this->_stateNames.size(); i++) {
delete this->_stateNames[i];
delete this->_stateColors[i];
}
}
bool StateGroup::containsEvent (EventDesc *evt) const
{
for (unsigned int i = 0; i < this->_transitions.size(); i++) {
if (this->_transitions.at(i)._event == evt)
return true;
}
return false;
}
int StateGroup::NextState (int st, EventDesc *evt) const
{
for (unsigned int i = 0; i < this->_transitions.size(); i++) {
if (this->_transitions.at(i)._event == evt)
return this->_transitions.at(i)._nextState;
}
return -1;
}
void StateGroup::SetStart (const char *st)
{
// first map the state name to an index
unsigned int state;
for (state = 0; state < this->_stateNames.size(); state++) {
if (strcmp(this->_stateNames.at(state), st) == 0)
break;
}
if (state == this->_stateNames.size()) {
fprintf(stderr, "unknown state name \"%s\"\n", st);
exit(1);
}
this->_start = state;
}
void StateGroup::AddState (int i, const char *st, const char *color)
{
this->_stateNames.at(i) = CopyString(st);
this->_stateColors.at(i) = CopyString(color);
}
void StateGroup::AddTransition (int i, EventDesc *evt, const char *st)
{
// first map the state name to an index
unsigned int state;
for (state = 0; state < this->_stateNames.size(); state++) {
if (strcmp(this->_stateNames.at(state), st) == 0)
break;
}
if (state == this->_stateNames.size()) {
fprintf(stderr, "unknown state name \"%s\"\n", st);
exit(1);
}
// then add the transition info
this->_transitions.at(i)._event = evt;
this->_transitions.at(i)._nextState = state;
// look for evt in the _events vector
for (std::vector<EventDesc *>::iterator iter = this->_events.begin();
iter < this->_events.end(); iter++
) {
if ((*iter)->Id() == evt->Id())
return; /* evt is already in the _events vector */
}
// if we get here, then evt should be added to the _events vector
this->_events.push_back(evt);
}
/***** class IntervalGroup member functions *****/
IntervalGroup::IntervalGroup (const char *desc, EventDesc *a, EventDesc *b, const char *color)
: Group (desc, INTERVAL_GROUP),
_start(a), _end(b), _color(CopyString(color))
{
}
IntervalGroup::~IntervalGroup ()
{
delete this->_color;
}
bool IntervalGroup::containsEvent (EventDesc *evt) const
{
return (this->_start == evt) || (this->_end == evt);
}
/***** class DependentGroup member functions *****/
DependentGroup::DependentGroup (const char *desc, EventDesc *src, EventDesc *dst, const char *color)
: Group (desc, DEPENDENT_GROUP),
_src(src), _dst(dst), _color(CopyString(color))
{
}
DependentGroup::~DependentGroup ()
{
delete this->_color;
}
bool DependentGroup::containsEvent (EventDesc *evt) const
{
return (this->_src == evt) || (this->_dst == evt);
}
/***** class LogFileDesc member functions *****/
LogFileDesc::LogFileDesc (std::vector<EventDesc *> *evts)
{
this->_root = 0;
this->_events = evts;
this->_info = 0;
}
LogFileDesc::~LogFileDesc ()
{
delete this->_root;
delete this->_events;
}
EventDesc *LogFileDesc::FindEventByName (const char *name) const
{
for (unsigned int i = 0; i < this->_events->size(); i++) {
if (strcmp(name, this->_events->at(i)->Name()) == 0)
return this->_events->at(i);
}
return 0;
}
std::vector<StateGroup *> *LogFileDesc::StateGroups (EventDesc *ed) const
{
if (ed->HasAttr (ATTR_STATE))
return this->_info[ed->Id()]->stateGrps;
else
return 0;
}
std::vector<IntervalGroup *> *LogFileDesc::IntervalGroups (EventDesc *ed) const
{
if (ed->HasAttr (ATTR_INTERVAL))
return this->_info[ed->Id()]->intervalGrps;
else
return 0;
}
std::vector<DependentGroup *> *LogFileDesc::DependentGroups (EventDesc *ed) const
{
if (ed->HasAttr (ATTR_DEPENDENT))
return this->_info[ed->Id()]->dependentGrps;
else
return 0;
}
/* add a group to a group vector */
template <class T>
static void AddGroup (std::vector<T *> *&v, T *g)
{
if (v == 0)
v = new std::vector<T *>(1, g);
else
v->push_back(g);
}
void LogFileDesc::_InitEventInfo ()
{
class Visitor : public LogDescVisitor {
public:
Visitor (LogFileDesc *ld, EventGrpInfo **info) : _logFile(ld), _info(info) { }
void VisitGroup (EventGroup *) { }
void VisitStateGroup (StateGroup *grp)
{
std::vector<EventDesc *>::iterator iter;
std::vector<EventDesc *> evts = grp->Events();
for (iter = evts.begin(); iter < evts.end(); iter++) {
EventDesc *ed = *iter;
assert (ed != 0);
AddGroup<StateGroup> (this->_info[ed->Id()]->stateGrps, grp);
}
}
void VisitIntervalGroup (IntervalGroup *grp)
{
int id = grp->Start()->Id();
AddGroup<IntervalGroup> (this->_info[id]->intervalGrps, grp);
id = grp->End()->Id();
AddGroup<IntervalGroup> (this->_info[id]->intervalGrps, grp);
}
void VisitDependentGroup (DependentGroup *grp)
{
int id = grp->Src()->Id();
AddGroup<DependentGroup> (this->_info[id]->dependentGrps, grp);
id = grp->Dst()->Id();
AddGroup<DependentGroup> (this->_info[id]->dependentGrps, grp);
}
private:
EventGrpInfo **_info;
LogFileDesc *_logFile;
};
this->_info = new EventGrpInfo*[this->_events->size()];
for (unsigned int i = 0; i < this->_events->size(); i++) {
if (this->_events->at(i)->isSimpleEvent())
this->_info[i] = 0;
else {
this->_info[i] = new EventGrpInfo;
this->_info[i]->stateGrps = 0;
this->_info[i]->intervalGrps = 0;
this->_info[i]->dependentGrps = 0;
}
}
Visitor v(this, this->_info);
this->PreOrderWalk (&v);
}
/* visitor walks of the event hierarchy */
struct StkNode {
EventGroup *grp;
int i; // child index in the group
StkNode (EventGroup *g) { this->grp = g; this->i = 0; }
Group *Next ()
{
if (this->i < grp->NumKids())
return grp->Kid(this->i++);
else
return 0;
}
};
typedef std::stack<StkNode> Stack_t;
//! \brief do a pre-order traversal of the event hierarchy, calling the visitor methods at each
//! node.
void LogFileDesc::PreOrderWalk (LogDescVisitor *visitor)
{
Stack_t stk;
visitor->VisitGroup (this->_root);
stk.push (StkNode(this->_root));
while (! stk.empty()) {
Group *p = stk.top().Next();
if (p == 0) {
stk.pop();
}
else switch (p->Kind()) {
case EVENT_GROUP: {
EventGroup *grp = reinterpret_cast<EventGroup *>(p);
visitor->VisitGroup (grp);
stk.push (StkNode(grp));
} break;
case STATE_GROUP: {
StateGroup *grp = reinterpret_cast<StateGroup *>(p);
visitor->VisitStateGroup (grp);
} break;
case INTERVAL_GROUP: {
IntervalGroup *grp = reinterpret_cast<IntervalGroup *>(p);
visitor->VisitIntervalGroup (grp);
} break;
case DEPENDENT_GROUP: {
DependentGroup *grp = reinterpret_cast<DependentGroup *>(p);
visitor->VisitDependentGroup (grp);
} break;
}
}
}
//! \brief do a post-order traversal of the event hierarchy, calling the visitor methods at each
//! node.
void LogFileDesc::PostOrderWalk (LogDescVisitor *visitor)
{
#ifdef FIXME
Stack_t stk;
stk.push (StkNode(this->_root));
while (! stk.empty()) {
Group *p = stk.top().Next();
if (p == 0) {
visitor->VisitGroup (stk.top().grp);
stk.pop();
}
else {
EventGroup *grp = dynamic_cast<EventGroup *>(p);
if (grp != 0) {
visitor->VisitGroup (grp);
stk.push (StkNode(grp));
}
else
visitor->VisitEvent (static_cast<EventDesc *>(p));
}
}
#endif
}
| 23.714976 | 100 | 0.63404 | ManticoreProject |
218130810ffab4bbe79706fcb2bfb73c57ddf5d8 | 3,009 | hpp | C++ | units/units.hpp | google/cpp-from-the-sky-down | 10c8d16e877796f2906bedbd3a66fb6469b3a211 | [
"Apache-2.0"
] | 219 | 2018-08-15T22:01:07.000Z | 2022-03-23T11:46:54.000Z | units/units.hpp | sthagen/cpp-from-the-sky-down | 72114a17a659e5919b4cbe3363e35c04f833d9d9 | [
"Apache-2.0"
] | 5 | 2018-09-11T06:15:28.000Z | 2022-01-05T15:27:31.000Z | units/units.hpp | sthagen/cpp-from-the-sky-down | 72114a17a659e5919b4cbe3363e35c04f833d9d9 | [
"Apache-2.0"
] | 27 | 2018-09-11T06:14:40.000Z | 2022-03-20T09:46:14.000Z | // Copyright 2018 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
//
// https://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.
// limitations under the License.
#include <cmath>
#include <ostream>
#include <string_view>
template <int M = 0, int K = 0, int S = 0>
struct unit {
long double value;
};
using meter = unit<1, 0, 0>;
using kilogram = unit<0, 1, 0>;
using second = unit<0, 0, 1>;
template <int M, int K, int S>
unit<M, K, S> operator+(unit<M, K, S> a, unit<M, K, S> b) {
return {a.value + b.value};
}
template <int M, int K, int S>
unit<M, K, S> operator-(unit<M, K, S> a, unit<M, K, S> b) {
return {a.value - b.value};
}
template <int M1, int K1, int S1, int M2, int K2, int S2>
unit<M1 + M2, K1 + K2, S1 + S2> operator*(unit<M1, K1, S1> a,
unit<M2, K2, S2> b) {
return {a.value * b.value};
}
template <typename T, int M, int K, int S>
unit<M, K, S> operator*(T a, unit<M, K, S> b) {
return {a * b.value};
}
template <int M1, int K1, int S1, int M2, int K2, int S2>
unit<M1 - M2, K1 - K2, S1 - S2> operator/(unit<M1, K1, S1> a,
unit<M2, K2, S2> b) {
return {a.value / b.value};
}
template <int N, int M, int K, int S>
unit<N * M, N * K, N * S> pow(unit<M, K, S> u) {
static_assert(N >= 0, "pow only supports positive powers for now");
if (N == 0) return {1.0};
auto value = u.value;
for (int i = 1; i < N; ++i) {
value = value * value;
}
return {value};
}
template <int M, int K, int S>
unit<M / 2, K / 2, S / 2> sqrt(unit<M, K, S> u) {
constexpr auto m = M / 2;
constexpr auto k = K / 2;
constexpr auto s = S / 2;
static_assert(m * 2 == M && k * 2 == K && s * 2 == S,
"Don't yet support fractional exponents");
return {std::sqrt(u.value)};
}
using newton = unit<1, 1, -2>;
template <int V>
std::ostream& print_unit(std::ostream& os, std::string_view abbrev) {
switch (V) {
case 0:
break;
case 1:
os << abbrev;
break;
default:
os << abbrev << "^" << V;
}
return os;
}
template <int M, int K, int S>
std::ostream& operator<<(std::ostream& os, unit<M, K, S> u) {
os << u.value;
print_unit<M>(os, "m");
print_unit<K>(os, "kg");
print_unit<S>(os, "s");
return os;
}
std::ostream& operator<<(std::ostream& os, newton n) {
os << n.value << "N";
return os;
}
using joule = unit<2, 1, -2>;
std::ostream& operator<<(std::ostream& os, joule n) {
os << n.value << "J";
return os;
}
meter operator""_m(long double v) { return {v}; }
kilogram operator""_kg(long double v) { return {v}; }
second operator""_s(long double v) { return {v}; }
| 25.939655 | 75 | 0.580259 | google |
21886401a9dfc06c5a5c2099fcb86b33bec5780e | 5,025 | cpp | C++ | compiler/src/Silang.cpp | jadedrip/SimpleLang | f39c490e5a41151d1d0d2f8c77c6ce524b7842f0 | [
"BSD-3-Clause"
] | 16 | 2015-03-30T02:46:49.000Z | 2020-07-28T13:36:54.000Z | compiler/src/Silang.cpp | jadedrip/SimpleLang | f39c490e5a41151d1d0d2f8c77c6ce524b7842f0 | [
"BSD-3-Clause"
] | 1 | 2020-09-01T09:38:30.000Z | 2020-09-01T09:38:30.000Z | compiler/src/Silang.cpp | jadedrip/SimpleLang | f39c490e5a41151d1d0d2f8c77c6ce524b7842f0 | [
"BSD-3-Clause"
] | 2 | 2020-02-07T02:09:48.000Z | 2020-02-19T13:31:35.000Z | // Silang.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#include <memory>
#include "Ast/AstNode.h"
#include <llvm/ExecutionEngine/ExecutionEngine.h>
#include <llvm/Support/TargetSelect.h>
#include <llvm/Support/ManagedStatic.h>
#include <llvm/Support/Signals.h>
#include <llvm/ExecutionEngine/MCJIT.h>
#include <llvm/ExecutionEngine/Interpreter.h>
#include <llvm/ExecutionEngine/SectionMemoryManager.h>
#include <llvm/ExecutionEngine/JITEventListener.h>
#include <llvm/IR/AssemblyAnnotationWriter.h>
#include <llvm/Support/DynamicLibrary.h>
#include <llvm/Support/FormattedStream.h>
#include <llvm/ExecutionEngine/JITSymbol.h>
#include <llvm/Support/PrettyStackTrace.h>
#include <llvm/IRReader/IRReader.h>
#include <llvm/Support/SourceMgr.h>
#include "Ast/AstModule.h"
#include "modules.h"
#include "utility.h"
#include "CompilerOptions.h"
extern int yyparse(void);
extern FILE *yyin, *yyout;
extern int yydebug, yylineno;
bool parse() {
try {
yydebug = 0;
return 0 == yyparse(); /* start the analysis*/
}
catch (std::exception e) {
std::cerr << "Error: " << e.what() << std::endl;
}
return false;
}
using namespace llvm;
LLVMContext llvmContext;
std::unique_ptr<Module> module;
AstModule* currentPackage = new AstModule();
ExecutionEngine* buildEngine(std::unique_ptr<Module> Owner);
// 源文件是否 utf8 的
bool utf8File = false;
extern RTDyldMemoryManager *RTDyldMM;
void execute(char * const *envp){
char *error = NULL;
std::string ErrStr;
llvm::StringRef MCPU = llvm::sys::getHostCPUName();
Function *mainFunction = currentPackage->getFunc();
raw_os_ostream os(std::clog);
//
// Execute the program
//
llvm::ExecutionEngine *EE = buildEngine(std::move(module));
if (EE) {
EE->setVerifyModules(true);
auto target = EE->getTargetMachine();
// The following functions have no effect if their respective profiling
// support wasn't enabled in the build configuration.
EE->RegisterJITEventListener(
JITEventListener::createOProfileJITEventListener());
EE->RegisterJITEventListener(
JITEventListener::createIntelJITEventListener());
EE->DisableLazyCompilation(false);
CLangModule::moveAll(EE);
// Give MCJIT a chance to apply relocations and set page permissions.
EE->finalizeObject();
// EE->runStaticConstructorsDestructors(false);
std::vector<std::string> noargs;
EE->runFunctionAsMain(mainFunction, noargs, envp);
// Clear instruction cache before code will be executed.
if (RTDyldMM)
static_cast<SectionMemoryManager*>(RTDyldMM)->invalidateInstructionCache(
);
// Run static destructors.
// EE->runStaticConstructorsDestructors(true);
}
else
std::cerr << "无法创建 JIT 引擎: " << ErrStr << std::endl;
CLangModule::shutdown();
}
using namespace llvm;
namespace stdfs = std::filesystem;
int main(int argc, char* argv[], char * const *envp)
{
PrettyStackTraceProgram X(argc, argv);
atexit(llvm_shutdown); // Call llvm_shutdown() on exit.
sys::PrintStackTraceOnErrorSignal(argv[0]);
InitializeNativeTarget();
InitializeNativeTargetAsmPrinter();
InitializeNativeTargetAsmParser();
if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr)) {
errs() << "Error loading program symbols.\n";
return -1;
}
std::string err;
//if (sys::DynamicLibrary::LoadLibraryPermanently("msvcp_win.dll", &err)) {
// errs() << "Error loading: "<< err<< "\n";
// // return -1;
//}
std::clog << "Triple: " << ::sys::getProcessTriple() << std::endl;
std::clog << "HostCpu: " << ::sys::getHostCPUName().str() << std::endl;
CompilerOptions::instance().triple = ::sys::getProcessTriple();
llvm::Triple triple;
std::clog << "OsName: " << triple.getOSName().str() << std::endl;
std::clog << "========" << std::endl;
auto *m = new Module("TOP", llvmContext);
module.reset(m);
bool b;
if (argc > 1) {
yylineno = 0;
yyin = fopen(argv[1], "r"); /* 首先打开要被处理的文件（参数1）yyin是lex默认的文件输入指针，设置了则不处理控制台输入 */
if (!yyin) {
std::cerr << "无法打开文件：" << argv[1] << std::endl;
return -1;
}
b = parse();
fclose(yyin);
}
else {
b = parse();
}
if (b) {
try {
auto c=new AstContext(m);
// 默认导入 si
auto package= CLangModule::loadPackage("si");
c->addImport("", package);
currentPackage->preprocessor(c);
}
catch (std::runtime_error e) {
std::cerr << "发生异常：" << e.what() << std::endl;
module.reset();
CLangModule::shutdown();
return -1;
}
std::ofstream of("out.gv");
of << "digraph ast {" << std::endl;
of << "rankdir=LR;" << std::endl;
currentPackage->draw(of);
of << "}";
of.close();
currentPackage->generateCode(m);
{
std::ofstream file("out.ll");
llvm::raw_os_ostream os(file);
module->print(os, nullptr, false, true);
os.flush();
file.close();
}
// system("start out.gv");
execute(envp);
// system("lli -force-interpreter out.ll");
// clang -lx64\Debug\clib.lib -x ir -o out.exe -g out.ll lib\si\String.ll lib\si\core.ll lib\si\Coroutine.ll
} else {
CLangModule::shutdown();
auto * m= module.release();
delete m;
}
return 0;
}
| 25.125 | 110 | 0.683781 | jadedrip |
218a51d4222e1be7fd560bf4681d04c352462270 | 6,685 | cpp | C++ | test/test_eigen_utils.cpp | stellarpower/vio_common | 5508203cbcc166cbcd34dc0a6f7852c73e2cff55 | [
"BSD-3-Clause"
] | 16 | 2017-06-02T07:22:31.000Z | 2022-03-23T02:39:39.000Z | test/test_eigen_utils.cpp | stellarpower/vio_common | 5508203cbcc166cbcd34dc0a6f7852c73e2cff55 | [
"BSD-3-Clause"
] | 2 | 2020-08-10T04:01:35.000Z | 2021-01-18T08:21:17.000Z | test/test_eigen_utils.cpp | stellarpower/vio_common | 5508203cbcc166cbcd34dc0a6f7852c73e2cff55 | [
"BSD-3-Clause"
] | 19 | 2017-08-03T02:23:11.000Z | 2021-09-22T02:17:46.000Z | #include <gtest/gtest.h>
#include <iostream>
#include "Eigen/Core"
#include "Eigen/Dense"
#include "vio/eigen_utils.h"
TEST(Eigen, Inverse) {
Eigen::Matrix<double, 6, 6> information = Eigen::Matrix<double, 6, 6>::Zero();
information(5, 5) = 1.0e8;
information(0, 0) = 1.0e8;
information(1, 1) = 1.0e8;
information(2, 2) = 1.0e8;
Eigen::Matrix<double, 6, 6> cov = information.inverse();
for (int i = 0; i < 5; ++i) {
EXPECT_TRUE(std::isnan(cov(0, 0)));
}
EXPECT_NEAR(cov(5, 5), 1e-8, 1e-10);
}
TEST(Eigen, SuperDiagonal) {
Eigen::MatrixXd M = Eigen::MatrixXd::Random(3, 5);
ASSERT_LT((vio::superdiagonal(M) - vio::subdiagonal(M.transpose())).norm(),
1e-9);
M = Eigen::MatrixXd::Random(4, 4);
ASSERT_LT((vio::superdiagonal(M) - vio::subdiagonal(M.transpose())).norm(),
1e-9);
M = Eigen::MatrixXd::Random(5, 3);
ASSERT_LT((vio::superdiagonal(M) - vio::subdiagonal(M.transpose())).norm(),
1e-9);
}
TEST(eigen_utils, ReparameterizeJacobians) {
double distances[] = {3, 3e2, 3e4, 3e8}; // close to inifity
std::vector<Eigen::Vector3d, Eigen::aligned_allocator<Eigen::Vector3d>>
expected_abrhoi{{1, -0.378937, 0.488034},
{1, -0.378937, 0.00488034},
{1, -0.378937, 4.88034e-05},
{1, -0.378937, 4.88034e-09}};
std::vector<Eigen::Vector3d, Eigen::aligned_allocator<Eigen::Vector3d>>
expected_abrhoj{{0.225489, -0.287133, 0.507999},
{0.264809, -0.280117, 0.00356978},
{0.267946, -0.277415, 3.57259e-05},
{0.267949, -0.277401, 3.57266e-09}};
for (size_t jack = 0; jack < sizeof(distances) / sizeof(distances[0]);
++jack) {
double dist = distances[jack];
Eigen::Matrix3d Ri = Eigen::Matrix3d::Identity();
Eigen::Vector3d ptini;
ptini << dist * cos(15 * M_PI / 180) * cos(45 * M_PI / 180),
-dist * sin(15 * M_PI / 180),
dist * cos(15 * M_PI / 180) * sin(45 * M_PI / 180);
Eigen::Matrix3d Rj =
Eigen::AngleAxisd(30 * M_PI / 180, Eigen::Vector3d::UnitY())
.toRotationMatrix();
Eigen::Vector3d pi = Eigen::Vector3d::Zero();
Eigen::Vector3d pj = Eigen::Vector3d::Random();
Eigen::Vector3d ptinj = Rj.transpose() * (ptini - pj);
Eigen::Vector3d abrhoi = Eigen::Vector3d(ptini[0], ptini[1], 1) / ptini[2];
Eigen::Vector3d abrhoj;
Eigen::Matrix<double, 3, 9> jacobian;
vio::reparameterize_AIDP(Ri, Rj, abrhoi, pi, pj, abrhoj, &jacobian);
Eigen::Matrix<double, 3, 9> jacobianNumeric;
vio::reparameterizeNumericalJacobian(Ri, Rj, abrhoi, pi, pj, abrhoj,
jacobianNumeric);
EXPECT_TRUE(jacobian.isApprox(jacobianNumeric, 1e-7));
EXPECT_TRUE(expected_abrhoi[jack].isApprox(abrhoi, 1e-6));
EXPECT_LT((expected_abrhoj[jack] - abrhoj).lpNorm<Eigen::Infinity>(), 1e-5);
}
// infinity
Eigen::Matrix3d Ri = Eigen::Matrix3d::Identity();
Eigen::Vector3d ptiniRay;
ptiniRay << cos(15 * M_PI / 180) * cos(45 * M_PI / 180),
-sin(15 * M_PI / 180), cos(15 * M_PI / 180) * sin(45 * M_PI / 180);
Eigen::Matrix3d Rj =
Eigen::AngleAxisd(30 * M_PI / 180, Eigen::Vector3d::UnitY())
.toRotationMatrix();
Eigen::Vector3d pi = Eigen::Vector3d::Zero();
Eigen::Vector3d pj = Eigen::Vector3d::Random();
Eigen::Vector3d ptinjRay = Rj.transpose() * ptiniRay;
ptinjRay /= ptinjRay[2];
ptinjRay[2] = 0;
Eigen::Vector3d abrhoi =
Eigen::Vector3d(1, -tan(15 * M_PI / 180) / sin(45 * M_PI / 180), 0);
Eigen::Vector3d abrhoj;
Eigen::Matrix<double, 3, 9> jacobian;
vio::reparameterize_AIDP(Ri, Rj, abrhoi, pi, pj, abrhoj, &jacobian);
Eigen::Matrix<double, 3, 9> jacobianNumeric;
vio::reparameterizeNumericalJacobian(Ri, Rj, abrhoi, pi, pj, abrhoj,
jacobianNumeric);
EXPECT_TRUE(jacobian.rightCols<6>().isMuchSmallerThan(1, 1e-8));
EXPECT_TRUE(jacobian.isApprox(jacobianNumeric, 1e-8));
EXPECT_TRUE(abrhoj.isApprox(ptinjRay, 1e-8));
}
TEST(eigen_utils, ExtractBlocks) {
Eigen::MatrixXd m(5, 5);
m << 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25;
std::vector<std::pair<size_t, size_t> > vRowStartInterval;
for (size_t jack = 0; jack < 5; ++jack)
vRowStartInterval.push_back(std::make_pair(jack, 1));
// test deleting none entry
Eigen::MatrixXd res = vio::extractBlocks(m, vRowStartInterval, vRowStartInterval);
EXPECT_LT((res - m).lpNorm<Eigen::Infinity>(), 1e-8);
// test deleting odd indexed rows/cols
vRowStartInterval.clear();
for (size_t jack = 0; jack < 5; jack += 2)
vRowStartInterval.push_back(std::make_pair(jack, 1));
res = vio::extractBlocks(m, vRowStartInterval, vRowStartInterval);
Eigen::MatrixXd expected(3, 3);
expected << 1, 3, 5, 11, 13, 15, 21, 23, 25;
EXPECT_LT((res - expected).lpNorm<Eigen::Infinity>(), 1e-8);
// test deleting even indexed rows/cols
vRowStartInterval.clear();
for (size_t jack = 1; jack < 5; jack += 2)
vRowStartInterval.push_back(std::make_pair(jack, 1));
res = vio::extractBlocks(m, vRowStartInterval, vRowStartInterval);
Eigen::MatrixXd expected2(2, 2);
expected2 << 7, 9, 17, 19;
EXPECT_LT((res - expected2).lpNorm<Eigen::Infinity>(), 1e-8);
// test with keeping more than 1 rows/cols each time
vRowStartInterval.clear();
vRowStartInterval.push_back(std::make_pair(0, 2));
vRowStartInterval.push_back(std::make_pair(3, 2));
res = vio::extractBlocks(m, vRowStartInterval, vRowStartInterval);
Eigen::MatrixXd expected3(4, 4);
expected3 << 1, 2, 4, 5, 6, 7, 9, 10, 16, 17, 19, 20, 21, 22, 24, 25;
EXPECT_LT((res - expected3).lpNorm<Eigen::Infinity>(), 1e-8);
// test with different rows and cols to keep
vRowStartInterval.clear();
vRowStartInterval.push_back(std::make_pair(0, 2));
vRowStartInterval.push_back(std::make_pair(3, 2));
std::vector<std::pair<size_t, size_t> > vColStartInterval;
vColStartInterval.push_back(std::make_pair(0, 2));
vColStartInterval.push_back(std::make_pair(3, 1));
res = vio::extractBlocks(m, vRowStartInterval, vColStartInterval);
Eigen::MatrixXd expected4(4, 3);
expected4 << 1, 2, 4, 6, 7, 9, 16, 17, 19, 21, 22, 24;
EXPECT_LT((res - expected4).lpNorm<Eigen::Infinity>(), 1e-8);
}
TEST(Eigen, QuaternionDiff) {
Eigen::Vector4d xyzw(0.0002580249512621188, 0.0005713455181395015,
0.7010130254309982, 0.7131481929890183);
Eigen::Quaterniond ref(xyzw[3], xyzw[0], xyzw[1], xyzw[2]);
Eigen::Quaterniond actual(xyzw.data());
EXPECT_LT(Eigen::AngleAxisd(ref.inverse() * actual).angle(), 1e-8);
}
| 39.323529 | 84 | 0.6362 | stellarpower |
218ce951f0ae7d750efd02621147e6ce750ee59a | 626 | cpp | C++ | tests/SelectionTests.cpp | lw983165/Ops | b91808bbf9a011c439476dbdf227aa455b53bf72 | [
"Apache-2.0"
] | null | null | null | tests/SelectionTests.cpp | lw983165/Ops | b91808bbf9a011c439476dbdf227aa455b53bf72 | [
"Apache-2.0"
] | null | null | null | tests/SelectionTests.cpp | lw983165/Ops | b91808bbf9a011c439476dbdf227aa455b53bf72 | [
"Apache-2.0"
] | null | null | null | #include "catch.hpp"
#include "Selection.hpp"
#include "Circle.hpp"
TEST_CASE("copy constructor and equals operator") {
Selection *sel = new Selection();
Circle *c1 = new Circle();
Circle *c2 = new Circle();
sel->add(c1);
sel->add(c2);
REQUIRE(sel->getSize() == 2);
Selection *sel2 = new Selection();
Selection *sel3;
sel3 = sel; // copy pointer
*sel2 = *sel; // copy contents
REQUIRE(sel->getSize() == 2);
REQUIRE(sel2->getSize() == 2);
sel2->remove(1);
REQUIRE(sel->getSize() == 2);
REQUIRE(sel2->getSize() == 1);
REQUIRE(sel3->getSize() == 2);
}
| 20.193548 | 51 | 0.578275 | lw983165 |
218d372a58c7587d4d8e687f2afe7be3268f8dc3 | 2,395 | cpp | C++ | libs/json/test/value_object.cpp | rzr/json_spirit | 065bfd09c45f1f89a9ce254b31fe10e0a53cdf1d | [
"BSL-1.0"
] | 103 | 2015-01-13T18:06:47.000Z | 2021-11-24T11:22:29.000Z | libs/json/test/value_object.cpp | rzr/json_spirit | 065bfd09c45f1f89a9ce254b31fe10e0a53cdf1d | [
"BSL-1.0"
] | 12 | 2015-08-04T12:46:17.000Z | 2021-01-12T06:49:24.000Z | libs/json/test/value_object.cpp | rzr/json_spirit | 065bfd09c45f1f89a9ce254b31fe10e0a53cdf1d | [
"BSL-1.0"
] | 37 | 2015-03-07T01:16:37.000Z | 2022-01-26T08:42:51.000Z | /**
* Copyright (C) 2012, 2013 ciere consulting, ciere.com
*/
#define BOOST_TEST_MODULE value_object
#include <boost/test/unit_test.hpp>
#include "ciere/json/io.hpp"
#include "ciere/json/value.hpp"
#include <string>
namespace json = ciere::json;
BOOST_TEST_DONT_PRINT_LOG_VALUE(json::value::object_iterator)
BOOST_TEST_DONT_PRINT_LOG_VALUE(json::value::const_object_iterator)
void const_test_f( json::value const & value );
BOOST_AUTO_TEST_CASE(all)
{
json::value value;
BOOST_CHECK_EQUAL(value.type(), json::null_type);
value = ciere::json::object()
("number" ,123)
("foo" ,"bar")
("meaning", 42)
;
BOOST_CHECK_EQUAL(value.type(), json::object_type);
BOOST_CHECK_EQUAL(value["number"] , 123);
BOOST_CHECK_EQUAL(value["foo"] , "bar");
BOOST_CHECK_EQUAL(value["meaning"] , 42);
value["number"] = 78.3;
BOOST_CHECK_EQUAL(value["number"] , 78.3);
value["foo"] = ciere::json::object()
( "color", "black" )
( "size" , 93 )
( "tone" , ciere::json::null_t() )
;
BOOST_CHECK_EQUAL(value["foo"]["size"] , 93);
BOOST_CHECK_EQUAL(value["foo"]["color"] , "black");
value["foo"]["color"] = "blue";
BOOST_CHECK_NE (value["foo"]["color"] , "black");
BOOST_CHECK_EQUAL(value["foo"]["color"] , "blue");
BOOST_CHECK_EQUAL(value["foo"].length() , 3u);
json::value::object_iterator iter = value["foo"].begin_object();
json::value::object_iterator iter_end = value["foo"].end_object();
BOOST_CHECK_EQUAL(iter->name() , "color");
BOOST_CHECK_EQUAL(iter->value() , "blue");
++iter;
BOOST_CHECK_EQUAL(iter->name() , "size");
BOOST_CHECK_EQUAL(iter->value() , 93);
++iter;
BOOST_CHECK_EQUAL(iter->name() , "tone");
BOOST_CHECK_EQUAL(iter->value() , json::null_t());
++iter;
BOOST_CHECK_EQUAL(iter , iter_end);
value.set("bar", json::array()(42)("top")(1234.5) );
BOOST_CHECK( value.has_key("bar") );
BOOST_CHECK( !value.has_key("cafe") );
BOOST_CHECK_EQUAL(value["bar"][2], 1234.5);
value.set("cafe", "open");
BOOST_CHECK_EQUAL(value["cafe"], "open");
const_test_f(value);
}
void const_test_f( json::value const & value )
{
BOOST_CHECK(value.has_key("cafe"));
BOOST_CHECK_THROW(value["sam"], std::out_of_range);
BOOST_CHECK_EQUAL(value["cafe"], "open");
BOOST_CHECK_EQUAL(value["bar"][2], 1234.5);
}
| 26.611111 | 71 | 0.639666 | rzr |
218f56e777c20d947629b2cefe9c15c8a2186f8d | 5,540 | cpp | C++ | nucleo32_f303k8/Drivers/MiYALAB_STM32F303K8/USART/Uart.cpp | miyalab/DefaultProjectForSTM32 | 5e054974fe6e33c08638b2b239db35fc7275f908 | [
"MIT"
] | null | null | null | nucleo32_f303k8/Drivers/MiYALAB_STM32F303K8/USART/Uart.cpp | miyalab/DefaultProjectForSTM32 | 5e054974fe6e33c08638b2b239db35fc7275f908 | [
"MIT"
] | null | null | null | nucleo32_f303k8/Drivers/MiYALAB_STM32F303K8/USART/Uart.cpp | miyalab/DefaultProjectForSTM32 | 5e054974fe6e33c08638b2b239db35fc7275f908 | [
"MIT"
] | null | null | null | /*
* MIT License
*
* Copyright (c) 2020 MiYA LAB(K.Miyauchi)
*
* 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 : Uart.cpp
* Author: K.Miyauchi
*
* Version : 1.00
*/
//--------------------------
// インクルード
//--------------------------
#include "Uart.h"
//--------------------------------------------------------------------------------------------
// MiYA LAB OSS
// USART Uart Mode スーパークラス Init関数
// Baudrate : 0 < Baudrate(通信速度[bps]) << (システムクロック/10)
// Length : UART_WORDLENGTH_8B(データ長8bit)
// UART_WORDLENGTH_9B(データ長9bit)
// StopBits : UART_STOPBITS_1(1ストップビット)
// UART_STOPBITS_2(2ストップビット)
// Parity : UART_PARITY_NONE(パリティなし)
// UART_PARITY_EVEN(偶数パリティ)
// UART_PARITY_ODD(奇数パリティ)
// return : 0(正常)
// other wise(エラー)
//--------------------------------------------------------------------------------------------
uint8_t MiYALAB::STM32F303K8::USART_UartMode::Init(uint32_t Baudrate, uint32_t Length, uint32_t StopBits, uint32_t Parity)
{
// USART設定
hUart.Init.BaudRate = Baudrate;
hUart.Init.WordLength = Length;
hUart.Init.StopBits = StopBits;
hUart.Init.Parity = Parity;
hUart.Init.Mode = UART_MODE_TX_RX;
hUart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
hUart.Init.OverSampling = UART_OVERSAMPLING_16;
hUart.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
hUart.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
// USART設定適用(UART)
if(HAL_UART_Init(&hUart) != HAL_OK){
return HAL_ERROR;
}
return HAL_OK;
}
//--------------------------------------------------------------------------------------------
// MiYA LAB OSS
// USART1 Uart Mode クラス コンストラクタ
//--------------------------------------------------------------------------------------------
MiYALAB::STM32F303K8::USART1_UartMode::USART1_UartMode()
{
__HAL_RCC_USART1_CLK_ENABLE();
hUart.Instance = USART1;
}
//--------------------------------------------------------------------------------------------
// MiYA LAB OSS
// USART1 Uart Mode クラス デストラクタ
//--------------------------------------------------------------------------------------------
MiYALAB::STM32F303K8::USART1_UartMode::~USART1_UartMode()
{
HAL_UART_DeInit(&hUart);
__HAL_RCC_USART1_CLK_DISABLE();
}
//--------------------------------------------------------------------------------------------
// MiYA LAB OSS
// USART1 Uart Mode クラス Enable関数
//--------------------------------------------------------------------------------------------
uint8_t MiYALAB::STM32F303K8::USART1_UartMode::Enable()
{
// ハードウェア設定用データ群
GPIO_InitTypeDef GpioInitStruct = {0};
// クロック許可
__HAL_RCC_GPIOB_CLK_ENABLE();
// GPIO設定
GpioInitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7;
GpioInitStruct.Mode = GPIO_MODE_AF_PP;
GpioInitStruct.Pull = GPIO_PULLUP;
GpioInitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GpioInitStruct.Alternate = GPIO_AF7_USART1;
HAL_GPIO_Init(GPIOB, &GpioInitStruct);
return HAL_OK;
}
//--------------------------------------------------------------------------------------------
// MiYA LAB OSS
// USART2 Uart Mode クラス コンストラクタ
//--------------------------------------------------------------------------------------------
MiYALAB::STM32F303K8::USART2_UartMode::USART2_UartMode()
{
__HAL_RCC_USART2_CLK_ENABLE();
hUart.Instance = USART2;
}
//--------------------------------------------------------------------------------------------
// MiYA LAB OSS
// USART2 Uart Mode クラス デストラクタ
//--------------------------------------------------------------------------------------------
MiYALAB::STM32F303K8::USART2_UartMode::~USART2_UartMode()
{
HAL_UART_DeInit(&hUart);
__HAL_RCC_USART2_CLK_DISABLE();
}
//--------------------------------------------------------------------------------------------
// MiYA LAB OSS
// USART2 Uart Mode クラス Enable関数
//--------------------------------------------------------------------------------------------
uint8_t MiYALAB::STM32F303K8::USART2_UartMode::Enable()
{
// ハードウェア設定用データ群
GPIO_InitTypeDef GpioInitStruct = {0};
// クロック許可
__HAL_RCC_GPIOA_CLK_ENABLE();
// GPIO設定
GpioInitStruct.Pin = GPIO_PIN_2 | GPIO_PIN_15;
GpioInitStruct.Mode = GPIO_MODE_AF_PP;
GpioInitStruct.Pull = GPIO_PULLUP;
GpioInitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GpioInitStruct.Alternate = GPIO_AF7_USART2;
HAL_GPIO_Init(GPIOA, &GpioInitStruct);
return HAL_OK;
}
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
/*
* 2020.12.01 : ファイル作成
*/
| 34.197531 | 122 | 0.537906 | miyalab |
218fbd71373c01a56caa8165ffee436c1108c47d | 3,480 | cc | C++ | aimsdata/src/aimsfdf/lib/io/fdfprocpar.cc | brainvisa/aims-free | 5852c1164292cadefc97cecace022d14ab362dc4 | [
"CECILL-B"
] | 4 | 2019-07-09T05:34:10.000Z | 2020-10-16T00:03:15.000Z | aimsdata/src/aimsfdf/lib/io/fdfprocpar.cc | brainvisa/aims-free | 5852c1164292cadefc97cecace022d14ab362dc4 | [
"CECILL-B"
] | 72 | 2018-10-31T14:52:50.000Z | 2022-03-04T11:22:51.000Z | aimsdata/src/aimsfdf/lib/io/fdfprocpar.cc | brainvisa/aims-free | 5852c1164292cadefc97cecace022d14ab362dc4 | [
"CECILL-B"
] | null | null | null | /* This software and supporting documentation are distributed by
* Institut Federatif de Recherche 49
* CEA/NeuroSpin, Batiment 145,
* 91191 Gif-sur-Yvette cedex
* France
*
* This software is governed by the CeCILL-B license under
* French law and abiding by the rules of distribution of free software.
* You can use, modify and/or redistribute the software under the
* terms of the CeCILL-B license as circulated by CEA, CNRS
* and INRIA at the following URL "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL-B license and that you accept its terms.
*/
/*
* lecture de fichiers FDF
*/
// activate deprecation warning
#ifdef AIMSDATA_CLASS_NO_DEPREC_WARNING
#undef AIMSDATA_CLASS_NO_DEPREC_WARNING
#endif
#include <aims/io/fdfprocpar_g.h>
using namespace aims;
using namespace carto;
using namespace std;
namespace aims {
string FdfProcPar::search( ifstream & file, string param ) {
string line = "";
size_t space_found;
while (getline(file, line, '\n')) {
space_found = line.find_first_of(" ");
if (space_found != string::npos) {
if (param.compare(0, param.length(), line, 0, space_found) == 0) {
// Line starts with the parameter name
break;
}
}
}
return line;
}
int FdfProcPar::search( ifstream & file, string param, int type, int active ) {
int result = 0, linetype, lineactive;
string line = "";
vector<string> tokens;
line = this->search( file, param );
if ( line != "\0") {
// Parameter was found, we tokenize it to check it is active and right type
tokenize(line, tokens, " ");
if ( tokens.size() < 10 ) {
cout << "Problem getting values for parameter : \'" << param << "\'" << endl;
}
else {
stringTo(tokens[2], linetype);
stringTo(tokens[9], lineactive);
if ((lineactive == active) && ( linetype == type )) {
// Get the number of elements
getline(file, line, ' ');
line.erase(line.find_last_not_of (" ") + 1);
stringTo(line, result);
}
}
}
return result;
}
}
| 35.876289 | 93 | 0.623851 | brainvisa |
218fe650375999474e12775d34a63748733759f5 | 409 | cpp | C++ | suda/0407/c.cpp | tusikalanse/acm-icpc | 20150f42752b85e286d812e716bb32ae1fa3db70 | [
"MIT"
] | 2 | 2021-06-09T12:27:07.000Z | 2021-06-11T12:02:03.000Z | suda/0407/c.cpp | tusikalanse/acm-icpc | 20150f42752b85e286d812e716bb32ae1fa3db70 | [
"MIT"
] | 1 | 2021-09-08T12:00:05.000Z | 2021-09-08T14:52:30.000Z | suda/0407/c.cpp | tusikalanse/acm-icpc | 20150f42752b85e286d812e716bb32ae1fa3db70 | [
"MIT"
] | null | null | null | #include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int MOD = 1e9 + 7;
long long qp(long long a, long long n) {
long long res = 1;
while(n) {
if(n&1)
res *= a;
a *= a;
a %= MOD;
res %= MOD;
n >>= 1;
}
return res;
}
int main() {
long long n, k;
int cnt = 0;
while(~scanf("%lld %lld", &n, &k)) {
printf("Case #%d: %lld\n", ++cnt, qp(n%MOD, k)%MOD);
}
} | 15.148148 | 54 | 0.542787 | tusikalanse |
219021cd67531b557eaadb711e7054e2062ff48e | 10,485 | cpp | C++ | ccec/src/Bus.cpp | rdkcmf/rdk-hdmicec | a46b0f30031344c8d2dcdfe1b82c543d885c8394 | [
"Apache-2.0"
] | 1 | 2018-09-04T05:48:09.000Z | 2018-09-04T05:48:09.000Z | ccec/src/Bus.cpp | rdkcmf/rdk-hdmicec | a46b0f30031344c8d2dcdfe1b82c543d885c8394 | [
"Apache-2.0"
] | null | null | null | ccec/src/Bus.cpp | rdkcmf/rdk-hdmicec | a46b0f30031344c8d2dcdfe1b82c543d885c8394 | [
"Apache-2.0"
] | 1 | 2018-08-16T20:46:53.000Z | 2018-08-16T20:46:53.000Z | /*
* If not stated otherwise in this file or this component's Licenses.txt file the
* following copyright and licenses apply:
*
* Copyright 2016 RDK Management
*
* 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.
*/
/**
* @defgroup hdmicec
* @{
* @defgroup ccec
* @{
**/
/**
* @defgroup hdmi_bus HDMI-CEC BUS
* @ingroup HDMI_CEC
* @addtogroup hdmi_bus
* @{
*/
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include "ccec/CECFrame.hpp"
#include "ccec/FrameListener.hpp"
#include "ccec/Driver.hpp"
#include "ccec/Exception.hpp"
#include "ccec/Util.hpp"
#include "Bus.hpp"
using CCEC_OSAL::AutoLock;
using CCEC_OSAL::Thread;
CCEC_BEGIN_NAMESPACE
/**
* @brief This function is used to create the instance of Bus class.
*
* @return instance Instance of the Bus class.
*/
Bus & Bus::getInstance(void)
{
static Bus instance;
return instance;
}
/**
* @brief This function is a constructor for the class Bus. It is used to starts
* the read and write thread which creates its instance.
*
* @return None
*/
Bus::Bus(void) : reader(*this), writer(*this)
{
CCEC_LOG( LOG_DEBUG, "Bus Instance Created\r\n");
Thread(this->reader).start();
Thread(this->writer).start();
CCEC_LOG( LOG_DEBUG, "Bus Instance DONE\r\n");
}
/**
* @brief This function starts the threads and gets the instance for Bus.
*
* @return None
*/
void Bus::start(void)
{AutoLock rlock_(rMutex), wlock_(wMutex);
CCEC_LOG( LOG_INFO, "Bus::start is called \r\n");
if(reader.isStopped())
{
Thread(reader).start();
}
if(writer.isStopped())
{
Thread(writer).start();
}
Driver::getInstance().open();
started = true;
}
/**
* @brief This function stops the reader & writer threads and removes the
* instance for Bus.
*
* @return None
*/
void Bus::stop(void)
{AutoLock rlock_(rMutex), wlock_(wMutex);
CCEC_LOG( LOG_INFO, "Bus::stop is called\r\n");
started = false;
reader.stop(true);
writer.stop(true);
Driver::getInstance().close();
CCEC_LOG( LOG_INFO, "Bus::stop is called reader isstop :%d writer isstop :%d \r\n",reader.isStopped(),writer.isStopped());
}
/**
* @brief This is a destructor for class BUS. This function initiates the closing
* of threads and the instance for Bus will be freed.
*
* @return None
*/
Bus::~Bus(void)
{
Assert(!started);
reader.stop(true);
writer.stop(true);
CCEC_LOG( LOG_DEBUG, "Bus::Destroyed\r\n");
}
/**
* @brief This function is used to read CECFrame from the driver. This gets
* notified to the frameListener which is listening for frames in CEC bus.
*
* @return None
*/
void Bus::Reader::run(void)
{
CECFrame frame;
if(isStopped())
{
runStarted();
}
CCEC_LOG( LOG_INFO, "Bus::Reader::run() started\r\n");
while (isRunning()) {
try {
Driver::getInstance().read(frame);
{AutoLock lock_(bus.rMutex);
if (bus.listeners.size() == 0) CCEC_LOG( LOG_DEBUG, "Bus::Reader discarding msgs for lack of listener\r\n");
std::list<FrameListener *>::iterator list_it;
for(list_it = bus.listeners.begin(); list_it!= bus.listeners.end(); list_it++) {
CCEC_LOG( LOG_DEBUG, "Bus::Reader::run() notify Listener\r\n");
(*list_it)->notify(frame);
//CCEC_LOG( LOG_DEBUG, "Bus::Reader::run() notify Listener Done\r\n");
}
}
}
catch(InvalidStateException &e) {
CCEC_LOG( LOG_DEBUG, "EOF for reader [%d]\r\n", isRunning());
}
}
stopCompleted();
}
/**
* @brief This function is used to stop the reader to read frames from the bus.
*
* @param[in] block State of Reader.
*
* @return None
*/
void Bus::Reader::stop(bool block)
{
CCEC_LOG( LOG_INFO, "Bus::Reader::stop::stop Entering [%d]\r\n", block);
{AutoLock lock_(bus.rMutex);
stopStarted();
}
Driver::getInstance().close();
if (block) {
while (!isStopped()) {
usleep(50 * 1000);
}
CCEC_LOG( LOG_DEBUG, "Bus::Reader::stop::stop completed\r\n");
}
}
/**
* @brief This function is used to add new listener for reading frames.
*
* @param[in] listener Struct pointer for the addition of listener.
*
* @return None
*/
void Bus::addFrameListener(FrameListener *listener)
{
{AutoLock lock_(rMutex);
if (!started) throw InvalidStateException();
listeners.push_back(listener);
}
}
/**
* @brief This function is used to remove the listener.
*
* @param[in] listener Struct pointer of a listener which is to be removed.
*
* @return None
*/
void Bus::removeFrameListener(FrameListener *listener)
{
{ AutoLock lock_(rMutex);
if (!started) throw InvalidStateException();
listeners.remove(listener);
}
}
/**
* @brief This function is used to poll the bus for frame availability and it
* writes the CEC frame to the driver.
*
* @return None
*/
void Bus::Writer::run(void)
{
CECFrame frame;
//Driver::getInstance()->open();
CCEC_LOG( LOG_INFO, "Bus::Writer::run() started\r\n");
CECFrame * outFrame = NULL;
if(isStopped())
{
runStarted();
}
do {
CCEC_LOG( LOG_DEBUG, "Bus::Writer::run Looping [%d]\r\n", isRunning());
try {
outFrame = bus.wQueue.poll();
if (outFrame != 0) {
Driver::getInstance().write(*outFrame);
}
else {
CCEC_LOG( LOG_DEBUG, "Bus::Writer::run EOF [%d]\r\n", isRunning());
/* sentinel value */
throw InvalidStateException();
}
}
catch(InvalidStateException &e) {
CCEC_LOG( LOG_EXP, "Driver closed writer[%d]\r\n", isRunning());
}
catch(Exception &e) {
CCEC_LOG( LOG_EXP,"Driver write failed\r\n");
e.what();
}
delete outFrame;
}
while (isRunning());
if (!isRunning()) {
while(bus.wQueue.size() > 0) {
outFrame = bus.wQueue.poll();
delete outFrame;
}
}
stopCompleted();
}
/**
* @brief This function is used to stop the writer for polling the bus and writing
* to the driver.
*
* @param[in] block State of Writer.
*
* @return None
*/
void Bus::Writer::stop(bool block)
{
CCEC_LOG( LOG_INFO, "Bus::Writer::stop::stop Entering [%d]\r\n", block);
{AutoLock lock_(bus.wMutex);
if (isRunning()) {
stopStarted();
bus.wQueue.offer(0);
CCEC_LOG( LOG_DEBUG, "Bus::Writer::stop::stop offer completed [%d]\r\n", isRunning());
}
}
if (block) {
while (!isStopped()) {
usleep(50 * 1000);
}
CCEC_LOG( LOG_DEBUG, "Bus::Writer::stop::stop completed\r\n");
}
}
/**
* @brief This function is used to write the frame to the driver. If it fails,
* as it is a synchronous function, it retries every 250ms till the retry count lapse.
*
* @param[in] frame CEC frame to be sent.
* @param[in] timeout Time period for retrying.
*
* @return None
*/
void Bus::send(const CECFrame &frame, int timeout)
{
{AutoLock rlock_(rMutex), wlock_(wMutex);
if (timeout <= 0) {
if (!started) throw InvalidStateException();
try {
Driver::getInstance().write(frame);
CCEC_LOG( LOG_DEBUG, "Bus::send write done\r\n");
}
catch (Exception &e){
if( frame.length() > 1) CCEC_LOG( LOG_EXP, "Bus::send exp caught [%s] \r\n", e.what());
throw;
}
}
}
{AutoLock rlock_(rMutex), wlock_(wMutex);
if (timeout > 0) {
/* Retry in 250ms increment till timeout */
int retry = (timeout / 250);
do {
try {
if (!started) throw InvalidStateException();
send(frame, 0);
retry = 0;
}
catch (Exception &e){
if( frame.length() > 1) CCEC_LOG( LOG_EXP, "Bus::send exp caught [%s], retry [%d]\r\n", e.what(), retry);
if (retry == 0) {
throw;
}
usleep(250000);
}
} while (retry--);
}
}
}
/**
* @brief This function is used to keep asynchronously sending the frame by
* keeping copy of cec frame in the queue of the driver.
*
* @param[in] frame CEC frame which need to be sent asynchronously.
*
* @return None
*/
void Bus::sendAsync(const CECFrame &frame)
{
{AutoLock lock_(wMutex);
if (!started) throw InvalidStateException();
CECFrame *copyFrame = (new CECFrame());
*copyFrame = frame;
wQueue.offer((copyFrame));
}
}
/**
* @brief This function is used to poll the logical address
* and returns the ACK or NACK received from other devices.
* If NACK then the device can use this logical address.
*
* @param[in] Logical address of initiator.
* @param[in] Logical address of follower.
*
* @return throws exception if there is NACK
*/
void Bus::poll(const LogicalAddress &from, const LogicalAddress &to)
{
{AutoLock rlock_(rMutex), wlock_(wMutex);
if (!started) throw InvalidStateException();
try {
Driver::getInstance().poll(from, to);
CCEC_LOG( LOG_DEBUG, "Bus::poll done\r\n");
}
catch (Exception &e){
CCEC_LOG( LOG_DEBUG, "Bus::poll exp caught [%s] \r\n", e.what());
throw;
}
}
}
/**
* @brief This function is used to ping devices, to know whether it present
* and returns the ACK or NACK received from other devices.
* If ACK is received, then the device is present.
*
* @param[in] Logical address of initiator.
* @param[in] Logical address of follower.
*
* @return throws exception if there is NACK
*/
void Bus::ping(const LogicalAddress &from, const LogicalAddress &to)
{
{AutoLock rlock_(rMutex), wlock_(wMutex);
if (!started) throw InvalidStateException();
try {
Driver::getInstance().poll(from, to);
CCEC_LOG( LOG_DEBUG, "Bus::ping done\r\n");
}
catch (Exception &e){
CCEC_LOG( LOG_DEBUG, "Bus::ping exp caught [%s] \r\n", e.what());
throw;
}
}
}
CCEC_END_NAMESPACE
/** @} */
/** @} */
/** @} */
| 23.456376 | 125 | 0.61774 | rdkcmf |
219b4444505a17560db90a3e0309b3151f9d9de4 | 1,708 | cpp | C++ | cachelib/navy/testing/tests/BufferGenTest.cpp | GerHobbelt/CacheLib | 580bf6950aad89cf86dbc153f12dada79b71eaf7 | [
"Apache-2.0"
] | 578 | 2021-09-01T14:19:55.000Z | 2022-03-29T12:22:46.000Z | cachelib/navy/testing/tests/BufferGenTest.cpp | igchor/Cachelib | 7db2c643d49fd0a4ec6c492d94a400cbe0515a70 | [
"Apache-2.0"
] | 61 | 2021-09-02T18:48:06.000Z | 2022-03-31T01:56:00.000Z | cachelib/navy/testing/tests/BufferGenTest.cpp | igchor/Cachelib | 7db2c643d49fd0a4ec6c492d94a400cbe0515a70 | [
"Apache-2.0"
] | 88 | 2021-09-02T21:22:19.000Z | 2022-03-27T07:40:27.000Z | /*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* 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 <gtest/gtest.h>
#include "cachelib/navy/testing/BufferGen.h"
namespace facebook {
namespace cachelib {
namespace navy {
namespace tests {
namespace {
bool isRange(uint8_t b, uint8_t rmin, uint8_t rmax) {
return rmin <= b && b <= rmax;
}
bool isAlphaChar(uint8_t b) {
return isRange(b, 'a', 'z') || isRange(b, 'A', 'Z') || isRange(b, '0', '9') ||
b == '+' || b == '=';
}
} // namespace
TEST(BufferGen, Basic) {
BufferGen bg{1};
uint32_t count[10]{};
for (uint32_t i = 0; i < 100; i++) {
auto buf = bg.gen(4, 8);
EXPECT_LE(4, buf.size());
EXPECT_GT(8, buf.size());
count[buf.size()]++;
for (size_t j = 0; j < buf.size(); j++) {
EXPECT_TRUE(isAlphaChar(buf.data()[j]));
}
}
EXPECT_LT(0, count[4]);
EXPECT_LT(0, count[5]);
EXPECT_LT(0, count[6]);
EXPECT_LT(0, count[7]);
}
TEST(BufferGen, Seed) {
BufferGen bg1{1};
auto buf1 = bg1.gen(10);
BufferGen bg2{1};
auto buf2 = bg2.gen(10);
EXPECT_EQ(buf1.view(), buf2.view());
}
} // namespace tests
} // namespace navy
} // namespace cachelib
} // namespace facebook
| 26.276923 | 80 | 0.645199 | GerHobbelt |
219cdeb6660499e8cbcfe983ba8c1ea85574556c | 824 | hpp | C++ | cpp/G3M/GEOMultiLine2DMeshSymbol.hpp | glob3mobile/g3m | 2b2c6422f05d13e0855b1dbe4e0afed241184193 | [
"BSD-2-Clause"
] | 70 | 2015-02-06T14:39:14.000Z | 2022-01-07T08:32:48.000Z | cpp/G3M/GEOMultiLine2DMeshSymbol.hpp | glob3mobile/g3m | 2b2c6422f05d13e0855b1dbe4e0afed241184193 | [
"BSD-2-Clause"
] | 118 | 2015-01-21T10:18:00.000Z | 2018-10-16T15:00:57.000Z | cpp/G3M/GEOMultiLine2DMeshSymbol.hpp | glob3mobile/g3m | 2b2c6422f05d13e0855b1dbe4e0afed241184193 | [
"BSD-2-Clause"
] | 41 | 2015-01-10T22:29:27.000Z | 2021-06-08T11:56:16.000Z | //
// GEOMultiLine2DMeshSymbol.hpp
// G3M
//
// Created by Diego Gomez Deck on 3/26/13.
//
//
#ifndef __G3M__GEOMultiLine2DMeshSymbol__
#define __G3M__GEOMultiLine2DMeshSymbol__
#include "GEOMeshSymbol.hpp"
#include "Color.hpp"
class GEOLine2DStyle;
class GEOMultiLine2DMeshSymbol : public GEOMeshSymbol {
private:
const std::vector<std::vector<Geodetic2D*>*>* _coordinatesArray;
const Color _lineColor;
const float _lineWidth;
double _deltaHeight;
public:
GEOMultiLine2DMeshSymbol(const std::vector<std::vector<Geodetic2D*>*>* coordinatesArray,
const GEOLine2DStyle& style,
double deltaHeight = 0.0);
~GEOMultiLine2DMeshSymbol() {
#ifdef JAVA_CODE
super.dispose();
#endif
}
Mesh* createMesh(const G3MRenderContext* rc) const;
};
#endif
| 20.097561 | 90 | 0.706311 | glob3mobile |
219cf28f6a7af2774c2958e28a9ec9390b6e5dd0 | 181 | cpp | C++ | AtCoder/ABC049/B/abc049_b.cpp | object-oriented-human/competitive | 9e761020e887d8980a39a64eeaeaa39af0ecd777 | [
"MIT"
] | 2 | 2021-07-27T10:46:47.000Z | 2021-07-27T10:47:57.000Z | AtCoder/ABC049/B/abc049_b.cpp | foooop/competitive | 9e761020e887d8980a39a64eeaeaa39af0ecd777 | [
"MIT"
] | null | null | null | AtCoder/ABC049/B/abc049_b.cpp | foooop/competitive | 9e761020e887d8980a39a64eeaeaa39af0ecd777 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
int main() {
int h, w; cin >> h >> w;
while (h--) {
string s; cin >> s;
cout << s << '\n' << s << '\n';
}
} | 20.111111 | 39 | 0.414365 | object-oriented-human |
219d7018bab8dc6adc95ad85bcfaaa23f793bb02 | 2,381 | hpp | C++ | src/port/esp_mesh/impl/function_impl.hpp | rnascunha/coap-te | eaff16162b1a524ad06e18dbdc79ca4c8658b3a8 | [
"MIT"
] | null | null | null | src/port/esp_mesh/impl/function_impl.hpp | rnascunha/coap-te | eaff16162b1a524ad06e18dbdc79ca4c8658b3a8 | [
"MIT"
] | null | null | null | src/port/esp_mesh/impl/function_impl.hpp | rnascunha/coap-te | eaff16162b1a524ad06e18dbdc79ca4c8658b3a8 | [
"MIT"
] | null | null | null | #ifndef COAP_TE_PORT_ESP_MESH_FUNCTION_IMPL_HPP__
#define COAP_TE_PORT_ESP_MESH_FUNCTION_IMPL_HPP__
#include "../function.hpp"
#include "message/types.hpp"
#include "message/parser.hpp"
#include "debug/print_message.hpp"
#include "esp_log.h"
namespace CoAP{
namespace Port{
namespace ESP_Mesh{
#if COAP_TE_PORT_POSIX == 1
template<int BlockTimeMs,
typename Endpoint,
typename CoAPEngine,
bool AddHost /* = true */,
bool RemoveHost /* = true */>
void proxy_forward_udp_mesh(CoAP::Port::POSIX::udp<Endpoint>& socket,
Endpoint& ep_server,
CoAPEngine& engine,
void* buffer,
std::size_t buffer_size,
CoAP::Error& ec) noexcept
{
mesh_data_t data;
data.data = static_cast<uint8_t*>(buffer);
data.size = static_cast<uint16_t>(buffer_size);
mesh_addr_t from, to;
int flag = 0;
//Receiving from mesh net to external net
esp_err_t err = esp_mesh_recv_toDS(&from,
&to,
&data,
BlockTimeMs,
&flag,
NULL,
0);
if(err == ESP_OK)
{
if constexpr (AddHost)
{
data.size = CoAP::Port::ESP_Mesh::add_host(data.data,
data.size,
buffer_size,
from,
ec);
if(ec) return;
}
socket.send(data.data, data.size, ep_server, ec);
if(ec) return;
}
else if(err != ESP_ERR_MESH_TIMEOUT)
{
ec = CoAP::errc::socket_receive;
return;
}
Endpoint ep;
size_t size = socket.template receive<BlockTimeMs>(buffer, buffer_size, ep, ec);
if(ec) return;
if(size > 0)
{
CoAP::Message::message msg;
CoAP::Message::parse(msg, static_cast<const uint8_t*>(buffer), size, ec);
if(ec) return;
typename CoAPEngine::endpoint to;
std::size_t msize = CoAP::Port::ESP_Mesh::remove_host(msg, buffer, size, *to.native(), ec);
if(ec)
{
CoAP::Error ecp;
std::size_t size_resp = engine.make_response(msg,
buffer, buffer_size,
CoAP::Message::code::precondition_failed,
nullptr,
ec.message(), std::strlen(ec.message()),
ecp);
if(ecp) return;
socket.send(buffer, size_resp, ep, ec);
}
else
{
to.type(CoAP::Port::ESP_Mesh::endpoint_type::from_external);
engine.get_connection().send(buffer, msize, to, ec);
// if(ec) return;
//already last thing
}
}
}
#endif /* COAP_TE_PORT_POSIX == 1 */
}//ESP_Mesh
}//Port
}//CoAP
#endif /* COAP_TE_PORT_ESP_MESH_FUNCTION_IMPL_HPP__ */
| 22.252336 | 93 | 0.654347 | rnascunha |
219ebc0196dc1ef078367ea6ff6a81312c7defbb | 6,904 | cc | C++ | utils/dx12test/dx12test.cc | gyakoo/simutils | 9e3b35ad30f3022b755b0f13d5f1a2c9fdf79715 | [
"MIT"
] | 4 | 2015-10-19T13:53:41.000Z | 2020-05-14T19:48:44.000Z | utils/dx12test/dx12test.cc | gyakoo/simutils | 9e3b35ad30f3022b755b0f13d5f1a2c9fdf79715 | [
"MIT"
] | 6 | 2015-09-30T14:00:32.000Z | 2015-09-30T14:06:55.000Z | utils/dx12test/dx12test.cc | gyakoo/simutils | 9e3b35ad30f3022b755b0f13d5f1a2c9fdf79715 | [
"MIT"
] | null | null | null |
#pragma warning(disable:4100 4005 4297)
#if defined(_DEBUG) && !defined(_WIN64)
#include <vld.h>
#endif
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <Windows.h>
#undef VIS_DX11
#undef VIS_GL
#ifndef VIS_DX12
#define VIS_DX12
#endif
#define VIS_IMPLEMENTATION
#include <vis.h>
struct app_assets
{
vis_handle pipeline;
vis_handle cmd_list;
vis_handle vb;
vis_handle vs;
vis_handle ps;
vis_handle shader_layout;
vis_handle* render_targets;
vis_viewport viewport;
};
struct app_vertex
{
float position[3];
float color[4];
};
void app_wait_for_gpu(vis* vi)
{
// tell gpu to signal once it finishes and wait for it here
vis_handle signal = vis_sync_gpu_to_signal(vi);
vis_sync_cpu_wait_for_signal(vi, signal);
vis_release_resource(vi, &signal);
}
int app_load_assets(vis* vi, app_assets* assets)
{
// Define the geometry for a triangle, the vertex and pixel shaders for it
app_vertex triangleVertices[] =
{
{ { 0.0f, 0.25f * vi->aspect_ratio, 0.0f },{ 1.0f, 0.0f, 0.0f, 1.0f } },
{ { 0.25f, -0.25f * vi->aspect_ratio, 0.0f },{ 0.0f, 1.0f, 0.0f, 1.0f } },
{ { -0.25f, -0.25f * vi->aspect_ratio, 0.0f },{ 0.0f, 0.0f, 1.0f, 1.0f } }
};
const uint32_t vbSize = sizeof(app_vertex) * 3;
vis_input_element vinput[] =
{
{ "POSITION", 0, VIS_FORMAT_R32G32B32_FLOAT, 0, 0 },
{ "COLOR", 0, VIS_FORMAT_R32G32B32_FLOAT, 0, 12 },
};
const char* vsstr = "";
const char* psstr = "";
// Resources (data) - not filling data in yet
{
// vb for triangle
assets->vb = vis_create_resource(vi, VIS_TYPE_VERTEXBUFFER, nullptr, vbSize);
// compile and create vs/ps
vis_shader_bytecode vsbytecode = { 0 };
vis_shader_bytecode psbytecode = { 0 };
vis_shader_compile_desc vsdesc = { (void*)vsstr, strlen(vsstr), VIS_STAGE_VS, "vs_main", "vs_5_0", VIS_COMPILEFLAG_DEBUG };
vis_shader_compile_desc psdesc = { (void*)psstr, strlen(psstr), VIS_STAGE_PS, "ps_main", "ps_5_0", VIS_COMPILEFLAG_DEBUG };
vis_shader_compile(vi, VIS_LOAD_SOURCE_MEMORY, &vsdesc, &vsbytecode);
vis_shader_compile(vi, VIS_LOAD_SOURCE_MEMORY, &psdesc, &psbytecode);
assets->vs = vis_create_resource(vi, VIS_TYPE_SHADER, &vsbytecode, VIS_STAGE_VS);
assets->ps = vis_create_resource(vi, VIS_TYPE_SHADER, &psbytecode, VIS_STAGE_PS);
vis_shader_release_bytecode(vi, &vsbytecode);
vis_shader_release_bytecode(vi, &vsbytecode);
// create RT with the back buffers
const uint32_t bbcount = vis_backbuffer_count(vi);
assets->render_targets = (vis_handle*)vis_malloc(sizeof(vis_handle)*bbcount);
for (uint32_t i = 0; i < bbcount; ++i)
{
vis_handle bbuffer = vis_backbuffer_acquire(vi, i);
assets->render_targets[i] = vis_create_resource(vi,
VIS_TYPE_RENDER_TARGET, bbuffer, VIS_NONE);
vis_release_resource(vi, &bbuffer);
}
}
// Descriptors (metadata)
{
vis_shader_layout shaderLayout = {
nullptr, // no shader registers
0,
VIS_STAGE_IA | VIS_STAGE_VS | VIS_STAGE_PS
};
assets->shader_layout = vis_create_resource(vi, VIS_TYPE_SHADER_LAYOUT, &shaderLayout, VIS_NONE);
}
// Pipeline state
{
vis_pipeline_state pstate;
vis_pipeline_state_set_default(vi, &pstate);
pstate.vertex_layout = vinput;
pstate.vertex_layout_count = 2;
pstate.shader_layout = assets->shader_layout;
pstate.vs = assets->vs;
pstate.ps = assets->ps;
assets->pipeline = vis_create_resource(vi, VIS_TYPE_PIPELINE, &pstate, VIS_NONE);
}
// Command list. creates and record a VB upload data, then waits for it
{
assets->cmd_list = vis_create_resource(vi, VIS_TYPE_COMMAND_LIST, &assets->pipeline, VIS_NONE);
// Record some upload to GPU in the cmd list
vis_command_list_record(vi, assets->cmd_list);
vis_handle vbupdate = vis_command_list_resource_update(vi, assets->cmd_list, assets->vb, triangleVertices, sizeof(app_vertex));
vis_command_list_close(vi, assets->cmd_list);
vis_command_list_execute(vi, &assets->cmd_list, 1);
// tell gpu to signal once it finishes and wait for it here
app_wait_for_gpu(vi);
// release temporary resources allocated for upload
vis_release_resource(vi, &vbupdate);
}
// viewport/scissor rect
vis_rect_make(&assets->viewport.rect, 0.0f, 0.0f, (float)vi->width, (float)vi->height);
assets->viewport.depth_min = 0.0f; assets->viewport.depth_max = 1.0f;
return VIS_OK;
}
void app_unload_assets(vis* vi, app_assets* assets)
{
vis_release_resource(vi, &assets->shader_layout);
vis_release_resource(vi, &assets->ps);
vis_release_resource(vi, &assets->vs);
vis_release_resource(vi, &assets->vb);
vis_release_resource(vi, &assets->pipeline);
vis_release_resource(vi, &assets->cmd_list);
const uint32_t bbcount = vis_backbuffer_count(vi);
for (uint32_t i = 0; i < bbcount; ++i)
vis_release_resource(vi, &assets->render_targets[i]);
vis_safefree(assets->render_targets);
}
void app_render(vis* vi, app_assets* assets)
{
// populate command list
{
vis_command_list_reset(vi, assets->cmd_list);
vis_command_list_record(vi, assets->cmd_list);
// (push) set necessary state
vis_command_list_set(vi, assets->cmd_list, VIS_CLS_SHADER_LAYOUT, &assets->shader_layout, VIS_NONE);
vis_command_list_set(vi, assets->cmd_list, VIS_CLS_VIEWPORTS, &assets->viewport, 1);
vis_command_list_set(vi, assets->cmd_list, VIS_CLS_SCISSORS, &assets->viewport.rect, 1);
vis_command_list_set(vi, assets->cmd_list, VIS_CLS_RENDER_TARGETS, &assets->render_targets[vi->framendx], 1);
// drawing commands
vis_cmd_clear clear = { &assets->render_targets[vi->framendx], 1, { 0.0f, 0.2f, 0.4f, 1.0f } };
vis_command_list_set(vi, assets->cmd_list, VIS_CLS_CLEAR_RT, &clear, VIS_NONE);
vis_command_list_set(vi, assets->cmd_list, VIS_CLS_PRIM_TOPOLOGY, nullptr, VIS_PRIMTOPO_TRIANGLE_LIST);
vis_command_list_set(vi, assets->cmd_list, VIS_CLS_VERTEX_BUFFER, &assets->vb, 1);
vis_cmd_draw draw = { 0, 3, 0, 1 };
vis_command_list_set(vi, assets->cmd_list, VIS_CLS_DRAW, &draw, VIS_NONE);
// (pop) necessary state
vis_command_list_set(vi, assets->cmd_list, VIS_CLS_RENDER_TARGETS, &assets->render_targets[vi->framendx], -1);
// close
vis_command_list_close(vi, assets->cmd_list);
}
// execute command list
vis_command_list_execute(vi, &assets->cmd_list, 1);
}
int main(int argc, const char** argv)
{
vis* v;
vis_opts vopts = { 0 };
vopts.width = 1024;
vopts.height = 768;
vopts.title = "fltview";
if (vis_init(&v, &vopts) == VIS_OK)
{
app_assets assets = { 0 };
if (app_load_assets(v, &assets) == VIS_OK)
{
while (vis_begin_frame(v) == VIS_OK)
{
app_render(v, &assets);
vis_present_frame(v);
app_wait_for_gpu(v);
}
app_unload_assets(v, &assets);
}
vis_release(&v);
}
return 0;
} | 32.720379 | 131 | 0.699594 | gyakoo |
21a2475c6692579f019d51bd6b520ef889dfc13c | 2,710 | cpp | C++ | UxGL/sources/UxError.cpp | Emmanuel-DUPUIS/heightmapterrain | 9c1f41afe8d314607c20ad6341648920debbebbf | [
"MIT"
] | null | null | null | UxGL/sources/UxError.cpp | Emmanuel-DUPUIS/heightmapterrain | 9c1f41afe8d314607c20ad6341648920debbebbf | [
"MIT"
] | null | null | null | UxGL/sources/UxError.cpp | Emmanuel-DUPUIS/heightmapterrain | 9c1f41afe8d314607c20ad6341648920debbebbf | [
"MIT"
] | null | null | null | //========================================================================
// Height Map Terrain Model
// MIT License
// Copyright (c) 2017 Emmanuel DUPUIS, emmanuel.dupuis@undecentum.com
//========================================================================
#include "UxError.h"
#include <direct.h>
#include <iostream>
#include <gl/glew.h>
#include <vector>
#define __error(e) {e, #e}
char* UxError::_Cwd = nullptr;
const char* UxError::getCwd()
{
if (!_Cwd)
{
_Cwd = new char[2048];
_getcwd(_Cwd, 2048);
char *p = _Cwd;
while (*p)
{
if (*p > 64 && *p < 91)
*p += 32;
p++;
}
}
return _Cwd;
}
std::string UxError::removeCwd(const char* iFileName)
{
const char* cwd = getCwd();
const char *pCwd = cwd;
const char *pFileName = iFileName;
while (*pCwd != '\0' && pFileName != '\0' && *pCwd == *pFileName)
{
pCwd++;
pFileName++;
}
if (*pCwd == '\0')
return std::string(pFileName);
std::string path;
while (*pCwd != '\0')
{
if (*pCwd == '\\' || *pCwd == '/')
path += ".." + *pCwd;
pCwd++;
}
path += "..\\";
return path + pFileName;
}
std::ostream& UxError::error(const char *file, int line)
{
return std::cerr << "ERROR[" << removeCwd(file).c_str() << ":" << line << "]: ";
}
std::ostream& UxError::warning(const char *file, int line)
{
return std::cerr << "WARNING[" << removeCwd(file).c_str() << ":" << line << "]: ";
}
void UxError::displayGLErrors(const char *file, int line)
{
static std::vector<std::pair<GLenum, const char*>> errors = { __error(GL_INVALID_ENUM), __error(GL_INVALID_VALUE), __error(GL_INVALID_OPERATION), __error(GL_STACK_OVERFLOW), __error(GL_STACK_UNDERFLOW), __error(GL_OUT_OF_MEMORY), __error(GL_INVALID_FRAMEBUFFER_OPERATION), __error(GL_CONTEXT_LOST), __error(GL_TABLE_TOO_LARGE) };
GLenum errorNumber = glGetError();
while (errorNumber != GL_NO_ERROR)
{
const char *errorLabel = "Unknown type";
auto it = errors.begin();
for (; it != errors.end(); it++)
{
if (errorNumber == it->first)
{
errorLabel = it->second;
break;
}
}
error(file, line) << errorLabel << "' (" << (it!= errors.end()?it->first:0) << ")\n";
errorNumber = glGetError();
}
}
void UxError::assertion(const char *file, int line, bool iConditionToFulfill, const std::string& iReason)
{
if (!iConditionToFulfill)
{
std::cerr << "WARNING[" << removeCwd(file).c_str() << ":" << line << "]: " << iReason.c_str() << "\n";
UxError::exit(-33);
}
}
void UxError::exit(int32_t iCode)
{
::exit(iCode);
} | 25.092593 | 332 | 0.536162 | Emmanuel-DUPUIS |
426f5f4a526887d473249cd23c7470fc7310754d | 1,270 | cpp | C++ | Sources/Inputs/Buttons/ButtonJoystick.cpp | dreadris/Acid | 1af276edce8e6481c44d475633bf69266e16ed87 | [
"MIT"
] | null | null | null | Sources/Inputs/Buttons/ButtonJoystick.cpp | dreadris/Acid | 1af276edce8e6481c44d475633bf69266e16ed87 | [
"MIT"
] | null | null | null | Sources/Inputs/Buttons/ButtonJoystick.cpp | dreadris/Acid | 1af276edce8e6481c44d475633bf69266e16ed87 | [
"MIT"
] | null | null | null | #include "ButtonJoystick.hpp"
namespace acid {
bool ButtonJoystick::registered = Register("buttonJoystick");
ButtonJoystick::ButtonJoystick(JoystickPort port, JoystickButton button) :
m_port(port),
m_button(button) {
Joysticks::Get()->OnButton().Add([this](JoystickPort port, JoystickButton button, InputAction action) {
if (port == m_port && button == m_button) {
m_onButton(action, 0);
}
}, this);
}
bool ButtonJoystick::IsDown() const {
return (Joysticks::Get()->GetButton(m_port, m_button) != InputAction::Release) ^ m_inverted;
}
Axis::ArgumentDescription ButtonJoystick::GetArgumentDescription() const {
return {
{"inverted", "bool", "If the down reading will be inverted"},
{"port", "int", "The joystick port name"},
{"axis", "bool", "The button on the joystick being checked"}
};
}
const Node &operator>>(const Node &node, ButtonJoystick &buttonJoystick) {
node["inverted"].Get(buttonJoystick.m_inverted);
node["port"].Get(buttonJoystick.m_port);
node["button"].Get(buttonJoystick.m_button);
return node;
}
Node &operator<<(Node &node, const ButtonJoystick &buttonJoystick) {
node["inverted"].Set(buttonJoystick.m_inverted);
node["port"].Set(buttonJoystick.m_port);
node["button"].Set(buttonJoystick.m_button);
return node;
}
}
| 30.238095 | 104 | 0.725197 | dreadris |
426fdade61db3462cc7471d4961ef0c8df9f6b78 | 1,249 | cpp | C++ | stack3.cpp | jeremyphilemon/datastructures-and-algorithms | 8abbdb9048d308426f4a83b815ceb90cf92d8732 | [
"MIT"
] | 4 | 2020-04-01T14:00:11.000Z | 2021-04-26T20:17:05.000Z | stack3.cpp | jeremyphilemon/DSA | 8abbdb9048d308426f4a83b815ceb90cf92d8732 | [
"MIT"
] | null | null | null | stack3.cpp | jeremyphilemon/DSA | 8abbdb9048d308426f4a83b815ceb90cf92d8732 | [
"MIT"
] | 4 | 2020-04-10T08:12:45.000Z | 2020-09-23T22:29:43.000Z | /*
Write a C program that tests the application function reverse(stack);
which reverse the items on the stack passed to it.
This function should use two local stacks to do its job.
*/
#include <stdio.h>
#include <stdlib.h>
void push(int arr[], int size, int *top, int item)
{
if(*top==size)
printf("\nStack is full! ");
else
{
*top+=1;
arr[*top]=item;
}
}
int pop(int arr[], int *top)
{
if(*top<=0)
printf("\nStack is empty! ");
else
{
*top-=1;
return arr[(*top)+1];
}
return 0;
}
void display(int arr[], int *top)
{
int i;
for(i=1; i<=*top; i++)
printf("%d ", arr[i]);
}
void reverse(int arr[], int size, int *top)
{
int temp1[size], temp2[size], temp1top=0, temp2top=0; //Two local stacks
while(*top>0)
push(temp1, size, &temp1top, pop(arr, top));
while(temp1top>0)
push(temp2, size, &temp2top, pop(temp1, &temp1top));
while(temp2top>0)
push(arr, size, top, pop(temp2, &temp2top));
display(arr, top); printf("\n");
}
int main()
{
int size, item;
printf("Enter the size of your stack: ");
scanf("%d", &size);
int arr[size], top=0;
printf("\nEnter the elements of the stack: ");
while(top<size)
{
scanf("%d", &item);
push(arr, size, &top, item);
}
reverse(arr, size, &top);
return 0;
}
| 18.641791 | 73 | 0.618094 | jeremyphilemon |
427448ae245ff3dea5d14aee317cf9f223ec7776 | 4,143 | cc | C++ | dbs/src/model/DescribeFullBackupSetResult.cc | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 89 | 2018-02-02T03:54:39.000Z | 2021-12-13T01:32:55.000Z | dbs/src/model/DescribeFullBackupSetResult.cc | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 89 | 2018-03-14T07:44:54.000Z | 2021-11-26T07:43:25.000Z | dbs/src/model/DescribeFullBackupSetResult.cc | aliyun/aliyun-openapi-cpp-sdk | 0cf5861ece17dfb0bb251f13bf3fbdb39c0c6e36 | [
"Apache-2.0"
] | 69 | 2018-01-22T09:45:52.000Z | 2022-03-28T07:58:38.000Z | /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/dbs/model/DescribeFullBackupSetResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Dbs;
using namespace AlibabaCloud::Dbs::Model;
DescribeFullBackupSetResult::DescribeFullBackupSetResult() :
ServiceResult()
{}
DescribeFullBackupSetResult::DescribeFullBackupSetResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeFullBackupSetResult::~DescribeFullBackupSetResult()
{}
void DescribeFullBackupSetResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
if(!value["ErrCode"].isNull())
errCode_ = value["ErrCode"].asString();
if(!value["ErrMessage"].isNull())
errMessage_ = value["ErrMessage"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["BackupSetId"].isNull())
backupSetId_ = value["BackupSetId"].asString();
if(!value["SourceEndpointIpPort"].isNull())
sourceEndpointIpPort_ = value["SourceEndpointIpPort"].asString();
if(!value["StartTime"].isNull())
startTime_ = std::stol(value["StartTime"].asString());
if(!value["EndTime"].isNull())
endTime_ = std::stol(value["EndTime"].asString());
if(!value["BackupStatus"].isNull())
backupStatus_ = value["BackupStatus"].asString();
if(!value["BackupSetExpiredTime"].isNull())
backupSetExpiredTime_ = std::stol(value["BackupSetExpiredTime"].asString());
if(!value["BackupSize"].isNull())
backupSize_ = std::stol(value["BackupSize"].asString());
if(!value["StorageMethod"].isNull())
storageMethod_ = value["StorageMethod"].asString();
if(!value["ErrMessage"].isNull())
errMessage1_ = value["ErrMessage"].asString();
if(!value["BackupObjects"].isNull())
backupObjects_ = value["BackupObjects"].asString();
if(!value["CreateTime"].isNull())
createTime_ = std::stol(value["CreateTime"].asString());
if(!value["FinishTime"].isNull())
finishTime_ = std::stol(value["FinishTime"].asString());
}
std::string DescribeFullBackupSetResult::getStorageMethod()const
{
return storageMethod_;
}
std::string DescribeFullBackupSetResult::getBackupObjects()const
{
return backupObjects_;
}
long DescribeFullBackupSetResult::getEndTime()const
{
return endTime_;
}
long DescribeFullBackupSetResult::getBackupSize()const
{
return backupSize_;
}
long DescribeFullBackupSetResult::getCreateTime()const
{
return createTime_;
}
long DescribeFullBackupSetResult::getStartTime()const
{
return startTime_;
}
long DescribeFullBackupSetResult::getBackupSetExpiredTime()const
{
return backupSetExpiredTime_;
}
std::string DescribeFullBackupSetResult::getErrMessage()const
{
return errMessage_;
}
std::string DescribeFullBackupSetResult::getBackupSetId()const
{
return backupSetId_;
}
bool DescribeFullBackupSetResult::getSuccess()const
{
return success_;
}
std::string DescribeFullBackupSetResult::getErrMessage1()const
{
return errMessage1_;
}
std::string DescribeFullBackupSetResult::getErrCode()const
{
return errCode_;
}
std::string DescribeFullBackupSetResult::getSourceEndpointIpPort()const
{
return sourceEndpointIpPort_;
}
long DescribeFullBackupSetResult::getFinishTime()const
{
return finishTime_;
}
int DescribeFullBackupSetResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::string DescribeFullBackupSetResult::getBackupStatus()const
{
return backupStatus_;
}
| 26.388535 | 86 | 0.757664 | aliyun |
4274e746b54323302c3b83077aab5f6d46c8efac | 16,179 | cc | C++ | durbatuluk.cc | joelodom/durbatuluk | c612f0fdbea6875f4cb0f95b24ffec4eafa6adb1 | [
"BSD-3-Clause"
] | null | null | null | durbatuluk.cc | joelodom/durbatuluk | c612f0fdbea6875f4cb0f95b24ffec4eafa6adb1 | [
"BSD-3-Clause"
] | null | null | null | durbatuluk.cc | joelodom/durbatuluk | c612f0fdbea6875f4cb0f95b24ffec4eafa6adb1 | [
"BSD-3-Clause"
] | null | null | null | //
// Durbatuluk is Copyright (c) 2012 Joel Odom
//
// 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 "durbatuluk.h"
#include "gtest/gtest.h"
#include "durbatuluk.pb.h"
#include "logger.h"
#include "crypto.h"
#include "keyfile.h"
#include "message_handler.h"
#include "processing_engine.h"
#include "net_fetcher.h"
#include "sequence_manager.h"
#include "configuration_manager.h"
#include "base64.h"
#include <openssl/engine.h>
// leave as EXIT_FAILURE until handler function is sure of success
int final_return_value = EXIT_FAILURE;
void usage(std::ostream& outstream)
{
outstream << std::endl << " = Durbatuluk " << MAJOR_VERSION << "."
<< MINOR_VERSION << "." << MICRO_VERSION << " " << DEVELOPMENT_PHASE
<< " =" << std::endl << std::endl;
outstream << "Durbatuluk is Copyright (c) 2012 Joel Odom, Marietta, GA"
<< std::endl;
outstream << "See LEGAL.txt for license details." << std::endl;
outstream << "http://durbatuluk.googlecode.com/" << std::endl;
outstream << std::endl;
outstream << "Usage:" << std::endl;
outstream << " durbatuluk --tests (running this will reset sequence file)"
<< std::endl;
outstream << " durbatuluk --generate-keyfiles <key_name>" << std::endl;
outstream << " durbatuluk --extract-public-key <key_name>" << std::endl;
outstream << " durbatuluk --generate-shell-command "
"<recipient_encryption_key> (command text read from stdin)" << std::endl;
outstream << " durbatuluk --post-shell-command <recipient_encryption_key> "
"(command text read from stdin)"
<< std::endl;
outstream << " durbatuluk --process-message "
"(encoded command read from stdin)" << std::endl;
outstream << " durbatuluk --process-messages-from-url" << std::endl;
outstream << " durbatuluk --reset-sequence-numbers" << std::endl;
outstream << std::endl;
final_return_value = EXIT_SUCCESS;
}
bool tests(int argc, char **argv)
{
if (argc == 2 && strcmp(argv[1], "--tests") == 0)
{
if (SequenceManager::ResetSequenceNumberFile())
{
std::cout << "Sequence number file reset." << std::endl;
::testing::InitGoogleTest(&argc, argv);
final_return_value = RUN_ALL_TESTS();
return true; // handled
}
else
{
std::cout << "Failed to reset sequence number file." << std::endl;
}
}
return false; // not handled
}
bool generate_keyfiles(int argc, char **argv, std::ostream& outstream)
{
if (argc != 3 || strcmp(argv[1], "--generate-keyfiles") != 0)
{
std::stringstream ss;
ss << "argc: " << argc << " argv[1]: " << argv[1];
Logger::LogMessage(DEBUG, "generate_keyfiles", &ss);
return false; // not handled
}
// generate an RSA key
RSA* rsa = RSA_generate_key(RSA_BITS, RSA_F4, nullptr, nullptr);
if (rsa == nullptr)
{
Logger::LogMessage(ERROR, "generate_keyfiles", "RSA_generate_key failed");
return true; // handled
}
if (RSA_check_key(rsa) != 1)
{
Logger::LogMessage(ERROR, "generate_keyfiles",
"RSA_check_key indicated problem");
return true; // handled
}
// write the key files
if (!KeyFile::WriteKeyFiles(argv[2], rsa))
{
Logger::LogMessage(ERROR, "generate_keyfiles", "WriteKeyFiles failed");
return true; // handled
}
RSA_free(rsa);
outstream << "Key files generated." << std::endl << std::endl;
final_return_value = EXIT_SUCCESS;
return true; // handled
}
bool extract_public_key(int argc, char **argv)
{
if (argc != 3 || strcmp(argv[1], "--extract-public-key") != 0)
return false; // not handled
// read the key
RSAKey public_key;
if (!KeyFile::ReadPublicKeyFile(argv[2], &public_key))
{
Logger::LogMessage(ERROR, "extract_public_key", "ReadPublicKeyFile failed");
return true; // handled
}
// hash and encode
std::string encoded;
if (!Crypto::HashRSAKey(public_key, &encoded))
{
Logger::LogMessage(ERROR, "extract_public_key", "HashRSAKey failed");
return true; // handled
}
std::cout << encoded;
final_return_value = EXIT_SUCCESS;
return true; // handled
}
bool generate_shell_command(int argc, char **argv)
{
if (argc != 3 || strcmp(argv[1], "--generate-shell-command") != 0)
return false; // not handled
// read the command from stdin
std::string command;
std::getline(std::cin, command);
std::stringstream ss;
ss << "command: " << command;
Logger::LogMessage(DEBUG, "generate_shell_command", &ss);
// read the recipient encryption key
RSAKey recipient_public_key;
if (!KeyFile::ReadPublicKeyFile(argv[2], &recipient_public_key))
{
Logger::LogMessage(ERROR, "generate_shell_command",
"ReadPublicKeyFile failed");
return true; // handled
}
// read the sender signing key
std::string signing_key_name;
if (!ConfigurationManager::GetMySigningKeyName(&signing_key_name))
{
Logger::LogMessage(
ERROR, "post_shell_command", "GetMySigningKeyName failed");
return true; // handled
}
RSAKey sender_signing_rsa;
if (!KeyFile::ReadPrivateKeyFile(signing_key_name, &sender_signing_rsa))
{
Logger::LogMessage(ERROR, "generate_shell_command",
"ReadPrivateKeyFile failed");
return true; // handled
}
RSA* rsa = RSA_new();
if (rsa == nullptr)
{
Logger::LogMessage(ERROR, "generate_shell_command", "RSA_new failed");
return true; // handled
}
if (!Crypto::ImportRSAKey(sender_signing_rsa, rsa))
{
Logger::LogMessage(ERROR, "generate_shell_command", "ImportRSAKey failed");
RSA_free(rsa);
return true; // handled
}
// generate the message
std::string encoded_message;
unsigned long long sequence_number;
bool rv = ProcessingEngine::GenerateEncodedDurbatulukMessage(
MESSAGE_TYPE_SHELL_EXEC, command,
recipient_public_key, rsa, &encoded_message, &sequence_number);
RSA_free(rsa);
if (!rv)
{
Logger::LogMessage(ERROR, "generate_shell_command",
"GenerateEncodedDurbatulukMessage failed");
return true; // handled
}
// save the sequence number so that we can process the response
if (!SequenceManager::AddToAllowedSequenceNumbers(sequence_number))
{
Logger::LogMessage(
ERROR, "generate_shell_command", "AddToAllowedSequenceNumbers failed");
return true; // handled
}
std::cout << encoded_message;
final_return_value = EXIT_SUCCESS;
return true; // handled
}
bool post_shell_command(int argc, char **argv)
{
if (argc != 3 || strcmp(argv[1], "--post-shell-command") != 0)
return false; // not handled
// read the command from stdin
std::string command;
std::getline(std::cin, command);
std::stringstream ss;
ss << "command: " << command;
Logger::LogMessage(DEBUG, "post_shell_command", &ss);
// read the recipient encryption key
RSAKey recipient_public_key;
if (!KeyFile::ReadPublicKeyFile(argv[2], &recipient_public_key))
{
Logger::LogMessage(ERROR, "post_shell_command", "ReadPublicKeyFile failed");
return true; // handled
}
// read the sender signing key
std::string signing_key_name;
if (!ConfigurationManager::GetMySigningKeyName(&signing_key_name))
{
Logger::LogMessage(
ERROR, "post_shell_command", "GetMySigningKeyName failed");
return true; // handled
}
RSAKey sender_signing_rsa;
if (!KeyFile::ReadPrivateKeyFile(signing_key_name, &sender_signing_rsa))
{
Logger::LogMessage(
ERROR, "post_shell_command", "ReadPrivateKeyFile failed");
return true; // handled
}
RSA* rsa = RSA_new();
if (rsa == nullptr)
{
Logger::LogMessage(ERROR, "post_shell_command", "RSA_new failed");
return true; // handled
}
if (!Crypto::ImportRSAKey(sender_signing_rsa, rsa))
{
Logger::LogMessage(ERROR, "post_shell_command", "ImportRSAKey failed");
RSA_free(rsa);
return true; // handled
}
// generate the message
std::string encoded_message;
unsigned long long sequence_number;
bool rv = ProcessingEngine::GenerateEncodedDurbatulukMessage(
MESSAGE_TYPE_SHELL_EXEC, command,
recipient_public_key, rsa, &encoded_message, &sequence_number);
RSA_free(rsa);
if (!rv)
{
Logger::LogMessage(
ERROR, "post_shell_command", "GenerateEncodedDurbatulukMessage failed");
return true; // handled
}
// post
std::string url;
if (!ConfigurationManager::GetPostMessageURL(&url))
{
Logger::LogMessage(ERROR, "post_shell_command", "GetPostMessageURL failed");
return true; // handled
}
if (!NetFetcher::PostMessageToURL(url, encoded_message))
{
Logger::LogMessage(ERROR, "post_shell_command", "PostMessageToURL failed");
return true; // handled
}
// save the sequence number so that we can process the response
if (!SequenceManager::AddToAllowedSequenceNumbers(sequence_number))
{
Logger::LogMessage(
ERROR, "post_shell_command", "AddToAllowedSequenceNumbers failed");
return true; // handled
}
std::cout << "Command posted." << std::endl;
final_return_value = EXIT_SUCCESS;
return true; // handled
}
bool process_message(int argc, char **argv)
{
if (argc != 2 || strcmp(argv[1], "--process-message") != 0)
return false; // not handled
// read the encoded command from stdin
std::string encoded;
std::cin >> encoded;
// read the recipient encryption key
std::string encryption_key_name;
if (!ConfigurationManager::GetMyEncryptionKeyName(&encryption_key_name))
{
Logger::LogMessage(
ERROR, "process_message", "GetMyEncryptionKeyName failed");
return true; // handled
}
RSAKey recipient_private_key;
if (!KeyFile::ReadPrivateKeyFile(encryption_key_name, &recipient_private_key))
{
Logger::LogMessage(ERROR, "process_message", "ReadPrivateKeyFile failed");
return true; // handled
}
RSA* rsa = RSA_new();
if (rsa == nullptr)
{
Logger::LogMessage(ERROR, "process_message", "RSA_new failed");
return true; // handled
}
if (!Crypto::ImportRSAKey(recipient_private_key, rsa))
{
Logger::LogMessage(ERROR, "process_message", "ImportRSAKey failed");
RSA_free(rsa);
return true; // handled
}
// handle the message
DurbatulukMessage output;
if (!ProcessingEngine::HandleIncomingEncodedMessage(encoded, rsa, &output))
{
Logger::LogMessage(ERROR, "process_message",
"HandleIncomingEncodedMessage failed");
RSA_free(rsa);
return true; // handled
}
RSA_free(rsa);
std::cout << output.contents() << std::endl;
final_return_value = EXIT_SUCCESS;
return true; // handled
}
bool process_messages_from_url(int argc, char **argv)
{
if (argc != 2 || strcmp(argv[1], "--process-messages-from-url") != 0)
return false; // not handled
// read the recipient encryption key
std::string encryption_key_name;
if (!ConfigurationManager::GetMyEncryptionKeyName(&encryption_key_name))
{
Logger::LogMessage(
ERROR, "process_messages_from_url", "GetMyEncryptionKeyName failed");
return true; // handled
}
RSAKey recipient_private_key;
if (!KeyFile::ReadPrivateKeyFile(encryption_key_name, &recipient_private_key))
{
Logger::LogMessage(ERROR, "process_messages_from_url",
"ReadPrivateKeyFile failed");
return true; // handled
}
RSA* rsa = RSA_new();
if (rsa == nullptr)
{
Logger::LogMessage(ERROR, "process_messages_from_url", "RSA_new failed");
return true; // handled
}
if (!Crypto::ImportRSAKey(recipient_private_key, rsa))
{
Logger::LogMessage(
ERROR, "process_messages_from_url", "ImportRSAKey failed");
RSA_free(rsa);
return true; // handled
}
// fetch the URL
std::string url;
if (!ConfigurationManager::GetFetchMessageURL(&url))
{
Logger::LogMessage(
ERROR, "process_messages_from_url", "GetFetchMessageURL failed");
return true; // handled
}
std::string url_contents;
if (!NetFetcher::FetchURL(url, &url_contents))
{
Logger::LogMessage(ERROR, "process_messages_from_url", "FetchURL failed");
RSA_free(rsa);
return true; // handled
}
// process each command in the URL, one by one
std::stringstream ss;
size_t start_tag_pos = url_contents.find("<durbatuluk>");
int message_num = 0;
int messages_successfully_processed = 0;
while (start_tag_pos != url_contents.npos)
{
++message_num; // one indexed
// find the next <durbatuluk>...</durbatuluk>
size_t end_tag_pos = url_contents.find("</durbatuluk>", start_tag_pos + 11);
if (end_tag_pos == url_contents.npos)
break; // done processing (no end tag found)
size_t len = end_tag_pos - start_tag_pos + 13;
// process the encoded command
std::string encoded(url_contents, start_tag_pos, len);
DurbatulukMessage output;
if (ProcessingEngine::HandleIncomingEncodedMessage(encoded, rsa, &output))
{
messages_successfully_processed++;
ss << "message #" << message_num << " processed successfully";
Logger::LogMessage(INFO, "process_messages_from_url", &ss);
}
else
{
ss << "could not process message #" << message_num;
Logger::LogMessage(INFO, "process_messages_from_url", &ss);
}
std::cout << output.contents() << std::endl;
start_tag_pos = url_contents.find("<durbatuluk>", end_tag_pos + 12);
}
ss << messages_successfully_processed << " of " << message_num
<< " messages processed successfully";
Logger::LogMessage(INFO, "process_messages_from_url", &ss);
RSA_free(rsa);
std::cout << "Processed " << messages_successfully_processed << " commands."
<< std::endl;
final_return_value = EXIT_SUCCESS;
return true; // handled
}
bool reset_sequence_numbers(int argc, char **argv)
{
if (argc != 2 || strcmp(argv[1], "--reset-sequence-numbers") != 0)
return false; // not handled
if (SequenceManager::ResetSequenceNumberFile())
std::cout << "Sequence number file reset." << std::endl;
else
std::cout << "Failed to reset sequence number file." << std::endl;
final_return_value = EXIT_SUCCESS;
return true; // handled
}
int main(int argc, char **argv)
{
GOOGLE_PROTOBUF_VERIFY_VERSION;
std::string config_file_name;
std::ostream outstream(std::cout.rdbuf());
if (!ConfigurationManager::GetConfigurationFileName(&config_file_name))
{
Logger::LogMessage(ERROR, "main", "GetConfigurationFileName failed");
}
else if (!ConfigurationManager::ReadConfigurationFile(config_file_name))
{
std::stringstream ss;
ss << "Failed to read " << config_file_name;
Logger::LogMessage(ERROR, "main", &ss);
}
else if (RAND_status() != 1)
{
// This could happen on systems without OS-provided randomness,
// in which case additional features are required to initialize
// the PRNG.
Logger::LogMessage(ERROR, "main", "PRNG not initialized.");
}
else if (!(
tests(argc, argv) ||
generate_keyfiles(argc, argv, outstream) ||
extract_public_key(argc, argv) ||
generate_shell_command(argc, argv) ||
post_shell_command(argc, argv) ||
process_message(argc, argv) ||
process_messages_from_url(argc, argv) ||
reset_sequence_numbers(argc, argv)
))
usage(outstream);
RAND_cleanup();
google::protobuf::ShutdownProtobufLibrary();
return final_return_value;
}
| 29.098921 | 80 | 0.686878 | joelodom |
427a18a90e3ca2935695d9f2bdb7408edc96e0f6 | 396 | hpp | C++ | overlay/src/nxcord_overlay_utils.hpp | Grarak/NXCord | 7ba09804c79cdc74da0d4f4766e6d8a1a8a10279 | [
"MIT"
] | 36 | 2019-12-11T15:46:34.000Z | 2021-12-18T10:14:36.000Z | overlay/src/nxcord_overlay_utils.hpp | Grarak/NXCord | 7ba09804c79cdc74da0d4f4766e6d8a1a8a10279 | [
"MIT"
] | 10 | 2020-01-26T11:38:13.000Z | 2020-10-10T22:04:20.000Z | overlay/src/nxcord_overlay_utils.hpp | Grarak/NXCord | 7ba09804c79cdc74da0d4f4766e6d8a1a8a10279 | [
"MIT"
] | 7 | 2020-01-23T13:33:40.000Z | 2021-03-23T21:54:08.000Z | #pragma once
#define private public
#define protected public
#include <tesla.hpp>
#undef private
#undef protected
constexpr std::string_view NO_SYSMODULE = "Can't communicate with \nsysmodule!";
constexpr std::string_view NOT_CONNECTED = "Not connected to voice channel.";
inline tsl::elm::OverlayFrame *defaultOverlayFrame() {
return new tsl::elm::OverlayFrame("NXCord", NXCORD_VERSION);
}
| 26.4 | 80 | 0.775253 | Grarak |
427ae138dfab9411734f96b149a07a5b15d849e5 | 297 | cpp | C++ | Ch 06/6.21.cpp | Felon03/CppPrimer | 7dc2daf59f0ae7ec5670def15cb5fab174fe9780 | [
"Apache-2.0"
] | null | null | null | Ch 06/6.21.cpp | Felon03/CppPrimer | 7dc2daf59f0ae7ec5670def15cb5fab174fe9780 | [
"Apache-2.0"
] | null | null | null | Ch 06/6.21.cpp | Felon03/CppPrimer | 7dc2daf59f0ae7ec5670def15cb5fab174fe9780 | [
"Apache-2.0"
] | null | null | null | /*编写一个函数，令其接受两个参数：一个是int型整数，另一个是int指针。
函数比较int的值和指针所指的值，返回较大的那个
*/
#include<iostream>
using namespace std;
// 比较函数
int compare_int(const int &a, const int *b)
{
return a > *b ? a : *b;
}
int main()
{
int x = 100;
int y = 200;
int *z = &y;
cout << compare_int(x, z) << endl;
return 0;
} | 12.913043 | 43 | 0.62963 | Felon03 |
427b1170c333ab65d47be9827db6c46499529998 | 3,844 | cpp | C++ | src/WorldGenerator/Grid.cpp | Smerom/WorldBuilder | 997a6f2e5a7b1d090cde3ec566845d3c537535e4 | [
"MIT"
] | 6 | 2017-03-15T18:27:06.000Z | 2022-01-08T04:22:35.000Z | src/WorldGenerator/Grid.cpp | Smerom/WorldBuilder | 997a6f2e5a7b1d090cde3ec566845d3c537535e4 | [
"MIT"
] | null | null | null | src/WorldGenerator/Grid.cpp | Smerom/WorldBuilder | 997a6f2e5a7b1d090cde3ec566845d3c537535e4 | [
"MIT"
] | null | null | null | // --
// Grid.cpp
// WorldGenerator
//
#include "Grid.hpp"
namespace WorldBuilder {
Grid::Grid(const api::Grid *theGrid) : verts(theGrid->vertices_size()){
// copy our verts over
uint_fast32_t count = theGrid->vertices_size();
for (uint_fast32_t index = 0; index < count; index++) {
api::GridVertex apiVertex = theGrid->vertices(index);
verts[index].index = index;
verts[index].vector.coords[0] = apiVertex.xcoord();
verts[index].vector.coords[1] = apiVertex.ycoord();
verts[index].vector.coords[2] = apiVertex.zcoord();
// set neighbors
uint_fast32_t neighborCount = apiVertex.neighbors_size();
std::vector<GridVertex *> temp(neighborCount);
verts[index].neighbors = temp;
for (uint_fast32_t neighborIndex = 0; neighborIndex < neighborCount; neighborIndex++) {
verts[index].neighbors[neighborIndex] = &verts[apiVertex.neighbors(neighborIndex)];
}
}
}
Grid::Grid(uint32_t vertexCount) : verts(vertexCount) {
}
void Grid::addGrpcGridPart(const api::Grid *theGrid){
// copy our verts over
uint_fast32_t count = theGrid->vertices_size();
for (uint_fast32_t index = 0; index < count; index++) {
api::GridVertex apiVertex = theGrid->vertices(index);
verts[apiVertex.index()].index = apiVertex.index();
verts[apiVertex.index()].vector.coords[0] = apiVertex.xcoord();
verts[apiVertex.index()].vector.coords[1] = apiVertex.ycoord();
verts[apiVertex.index()].vector.coords[2] = apiVertex.zcoord();
// set neighbors
uint_fast32_t neighborCount = apiVertex.neighbors_size();
std::vector<GridVertex *> temp(neighborCount);
verts[apiVertex.index()].neighbors = temp;
for (uint_fast32_t neighborIndex = 0; neighborIndex < neighborCount; neighborIndex++) {
verts[apiVertex.index()].neighbors[neighborIndex] = &verts[apiVertex.neighbors(neighborIndex)];
}
}
}
void Grid::buildCenters() {
for (auto vertexIt = this->verts.begin(); vertexIt != this->verts.end(); vertexIt++) {
Vec3 center;
for (auto neighborIt = vertexIt->neighbors.begin(); neighborIt != vertexIt->neighbors.end(); neighborIt++) {
center = center + (*neighborIt)->get_vector();
}
center = math::normalize3Vector(center);
vertexIt->neighborCenter = center;
}
}
std::unordered_map<uint32_t, GridVertex *> GridVertex::neighborsByDepth(uint32_t dist) const {
// create
auto newNeighbors = std::make_shared<std::unordered_map<uint32_t, GridVertex*>>();
std::unordered_map<uint32_t, GridVertex*> depthNeighbors;
//neighbors.reserve(/*some count*/);
for (auto neigh : this->neighbors) {
depthNeighbors.insert({neigh->index, neigh});
newNeighbors->insert({neigh->index, neigh});
}
for (uint32_t depth = 1; depth < dist; depth++) {
auto currentTest = newNeighbors;
newNeighbors = std::make_unique<std::unordered_map<uint32_t, GridVertex*>>();
for (auto neighTestIt : *currentTest) {
auto neighTest = neighTestIt.second;
for (auto neigh : neighTest->neighbors) {
// check if in neighbors
if (depthNeighbors.find(neigh->index) == depthNeighbors.end()) {
depthNeighbors.insert({neigh->index, neigh});
newNeighbors->insert({neigh->index, neigh});
}
}
}
}
return depthNeighbors;
}
} | 42.241758 | 120 | 0.581426 | Smerom |
42829b75df9b0c44a5b7297042b3374ad883df26 | 1,921 | cpp | C++ | src/CodingSkill/CPPCoding/TestQuiz2.cpp | SungwooNam/ProgrammingStudy | 3c2fe6096fea29547f05ff29bbde14a48c4afa9b | [
"MIT"
] | 1 | 2019-07-22T04:58:15.000Z | 2019-07-22T04:58:15.000Z | src/CodingSkill/CPPCoding/TestQuiz2.cpp | SungwooNam/ProgrammingStudy | 3c2fe6096fea29547f05ff29bbde14a48c4afa9b | [
"MIT"
] | 1 | 2017-02-21T16:02:41.000Z | 2017-02-21T16:02:41.000Z | src/CodingSkill/CPPCoding/TestQuiz2.cpp | SungwooNam/ProgrammingStudy | 3c2fe6096fea29547f05ff29bbde14a48c4afa9b | [
"MIT"
] | null | null | null | /*
#include <boost/test/unit_test.hpp>
#include <vector>
#include <numeric>
#include <limits>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <math.h>
#include <stdio.h>
class Host
{
private:
int m_HostID;
int m_InstanceType;
std::list<bool> m_Slots;
public:
Host( int id, int type );
void Add( int slot )
{
m_Slots.push_back( slot );
}
};
typedef boost::shared_ptr<Host> HostPtr;
class HostLoader
{
public:
std::list<HostPtr> LoadFromFile( const char *filename)
{
// FIX ME : need to use c++ stream class
FILE *fp = fopen( filename, "rt" );
if( fp == NULL )
throw "Failed to open file";
std::list<HostPtr> hosts;
char line[255];
while( fgets( line, 255, fp ) != NULL )
{
std::list<const char *> tokens;
tokenizer( line, ',', tokens );
std::list<const char *>::iterator I = tokens.begin();
int hostid = atoi( *I ); ++I;
int
std::vector<const char*> heads( tokens.begin(), tokens.begin()+2 );
HostPtr host( new Host( atoi( heads[0]), atoi( heads[1] ) ) );
std::list<const char *>::iterator I;
for( I = tokens.begin()+3; I != tokens.end(); ++I )
{
const char *token = *I;
bool isTaken = atoi( token ) == 1 ? true : false;
host->Add( isTaken );
}
hosts.push_back( host );
}
fclose(fp);
}
private:
void tokenizer( char *line, char separator, std::list<const char*>& tokens )
{
char *c = line;
bool isNewToken = true;
while( *c != NULL )
{
if( isNewToken )
{
tokens.push_back( c );
isNewToken = false;
}
if( *c == separator )
{
isNewToken = true;
*c = NULL;
}
c++;
}
}
};
BOOST_AUTO_TEST_CASE( TestQuiz2Test1 )
{
{
FILE *fp = fopen( "temp.txt", "wt" );
fprintf( fp, "1,M1,3,0,0,1\n");
fprintf( fp, "2,M2,4,0,0,1,0\n");
fprintf( fp, "3,M3,5,0,0,1,0,1\n");
fclose(fp);
}
HostLoader loader;
loader.LoadFromFile( "temp.txt" );
}
*/ | 17 | 77 | 0.587194 | SungwooNam |
4285b2d22cb421b450bbd4555e1fd61bef747fcf | 1,525 | cpp | C++ | src/example_pcl_load_ply_file.cpp | dringakn/ROSExamples | f4f19d21fab3630c112148e198f117f0466032c4 | [
"MIT"
] | 2 | 2020-07-14T19:37:43.000Z | 2020-07-15T04:38:09.000Z | src/example_pcl_load_ply_file.cpp | dringakn/ROSExamples | f4f19d21fab3630c112148e198f117f0466032c4 | [
"MIT"
] | null | null | null | src/example_pcl_load_ply_file.cpp | dringakn/ROSExamples | f4f19d21fab3630c112148e198f117f0466032c4 | [
"MIT"
] | null | null | null | /**
* Author: Dr. Ing. Ahmad Kamal Nasir
* Email: dringakn@gmail.com
* Description:
* Notes: Add pcl_ros library in CMakeLists
* For testing
* roscore
* rosrun ros_examples example_pcl_load_ply_file _map_file_name:=/home/ahmad/catkin_ws/src/ROSExamples/map/sample.ply
* rviz (Add Pointcloud visulizer)
**/
#include <pcl/io/ply_io.h>
#include <pcl/point_cloud.h>
#include <pcl_conversions/pcl_conversions.h>
#include <ros/ros.h>
#include <sensor_msgs/PointCloud2.h>
int main(int argc, char* argv[]) {
ros::init(argc, argv, "example_pcl_load_ply_file");
ros::NodeHandle nh("~");
std::string map_file_name;
if (!nh.param<std::string>("map_file_name", map_file_name, "/home/workshop/LUMS1.ply"))
nh.setParam("map_file_name", map_file_name);
ROS_INFO("Map file: %s", map_file_name.c_str());
ros::Publisher pub =
nh.advertise<sensor_msgs::PointCloud2>("/pointcloud", 1000, true);
pcl::PCLPointCloud2* pc = new pcl::PCLPointCloud2;
if (pcl::io::loadPLYFile(map_file_name.c_str(), *pc) == -1) {
ROS_INFO("Pointcloud file (%s) not loaded", map_file_name.c_str());
return -1;
}else{
ROS_INFO("Loaded %dx%d points from %s", pc->width, pc->height, map_file_name.c_str());
sensor_msgs::PointCloud2 msg;
pcl_conversions::fromPCL(*pc, msg);
msg.header.stamp = ros::Time::now();
msg.header.frame_id = "map";
pub.publish(msg);
}
ros::Rate rate(1);
while (ros::ok()) {
ros::spinOnce();
rate.sleep();
}
return 0;
} | 30.5 | 123 | 0.66623 | dringakn |
428b473dc18059f23d96c990007a0299ce57c2e9 | 4,594 | hpp | C++ | include/NP-Engine/Window/Window.hpp | naphipps/NP-Engine | 0cac8b2d5e76c839b96f2061bf57434bdc37915e | [
"MIT"
] | null | null | null | include/NP-Engine/Window/Window.hpp | naphipps/NP-Engine | 0cac8b2d5e76c839b96f2061bf57434bdc37915e | [
"MIT"
] | null | null | null | include/NP-Engine/Window/Window.hpp | naphipps/NP-Engine | 0cac8b2d5e76c839b96f2061bf57434bdc37915e | [
"MIT"
] | null | null | null | //##===----------------------------------------------------------------------===##//
//
// Author: Nathan Phipps 2/10/21
//
//##===----------------------------------------------------------------------===##//
#ifndef NP_ENGINE_WINDOW_HPP
#define NP_ENGINE_WINDOW_HPP
#include <utility>
#include "NP-Engine/Primitive/Primitive.hpp"
#include "NP-Engine/Event/Event.hpp"
#include "NP-Engine/Platform/Platform.hpp"
#include "NP-Engine/Memory/Memory.hpp"
#include "NP-Engine/Time/Time.hpp"
#include "NP-Engine/String/String.hpp"
#include "NP-Engine/Concurrency/Concurrency.hpp"
#include "NP-Engine/Container/Container.hpp"
#include "NP-Engine/Vendor/GlfwInclude.hpp"
// TODO: update comments
namespace np::window
{
class Window : public event::EventHandler
{
public:
constexpr static ui32 DEFAULT_WIDTH = 800;
constexpr static ui32 DEFAULT_HEIGHT = 600;
struct Properties
{
str Title = "NP Window";
ui32 Width = DEFAULT_WIDTH;
ui32 Height = DEFAULT_HEIGHT;
};
using ResizeCallback = void (*)(void* caller, ui32 width, ui32 height);
protected:
Properties _properties;
GLFWwindow* _glfw_window;
concurrency::Thread _thread;
atm_bl _show_procedure_is_complete;
container::omap<void*, ResizeCallback> _resize_callbacks;
static void WindowCloseCallback(GLFWwindow* glfw_window)
{
((Window*)glfwGetWindowUserPointer(glfw_window))->Close();
}
static void WindowSizeCallback(GLFWwindow* glfw_window, i32 width, i32 height)
{
Window* window = (Window*)glfwGetWindowUserPointer(glfw_window);
window->InvokeResizeCallbacks(width, height);
}
void InvokeResizeCallbacks(ui32 width, ui32 height)
{
for (auto it = _resize_callbacks.begin(); it != _resize_callbacks.end(); it++)
{
it->second(it->first, width, height);
}
}
virtual void HandleClose(event::Event& event);
virtual void HandleResize(event::Event& event);
virtual void HandleEvent(event::Event& event) override
{
switch (event.GetType())
{
case event::EventType::WindowClose:
HandleClose(event);
break;
case event::EventType::WindowResize:
HandleResize(event);
break;
}
}
virtual void ShowProcedure();
void SetGlfwCallbacks(GLFWwindow* glfw_window);
GLFWwindow* CreateGlfwWindow()
{
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
GLFWwindow* glfw_window =
glfwCreateWindow(_properties.Width, _properties.Height, _properties.Title.c_str(), nullptr, nullptr);
glfwSetWindowUserPointer(glfw_window, this);
SetGlfwCallbacks(glfw_window);
return glfw_window;
}
public:
Window(const Window::Properties& properties, event::EventSubmitter& event_submitter):
event::EventHandler(event_submitter),
_properties(properties),
_glfw_window(CreateGlfwWindow()),
_show_procedure_is_complete(true)
{
Show();
}
virtual ~Window()
{
if (_glfw_window != nullptr)
glfwDestroyWindow(_glfw_window);
}
virtual void Show()
{
_show_procedure_is_complete.store(false, mo_release);
_thread.Run(&Window::ShowProcedure, this);
}
virtual void Close();
virtual void Resize(ui32 width, ui32 height);
virtual bl IsRunning() const
{
return !_show_procedure_is_complete.load(mo_acquire) || _thread.IsRunning();
}
virtual ui32 GetWidth() const
{
return _properties.Width;
}
virtual ui32 GetHeight() const
{
return _properties.Height;
}
virtual str GetTitle() const
{
return _properties.Title;
}
virtual Properties GetProperties() const
{
return _properties;
}
virtual void Update(time::DurationMilliseconds duration_milliseconds)
{
// TODO: implement
}
virtual void SetTitle(str title)
{
_properties.Title = title;
if (IsRunning() && _glfw_window != nullptr)
{
glfwSetWindowTitle(_glfw_window, _properties.Title.c_str());
}
}
// virtual void AttachToRenderer() = 0; //TODO: we need to attach/detach from our renderer
virtual void SetEnableVSync(bl enabled = true) {}
virtual bl IsVSync() const
{
return false;
}
virtual void* GetNativeWindow() const
{
return _glfw_window;
}
virtual bl IsMinimized() const
{
return false;
}
void SetResizeCallback(void* caller, ResizeCallback callback)
{
_resize_callbacks[caller] = callback;
}
void UnsetResizeCallback(void* caller)
{
_resize_callbacks.erase(caller);
}
virtual event::EventCategory GetHandledCategories() const override
{
return event::EventCategory::Window;
}
};
} // namespace np::window
#endif /* NP_ENGINE_WINDOW_HPP */
| 22.742574 | 105 | 0.690466 | naphipps |
428b4963aed50144157ca038d0f9e06aee49382a | 3,198 | cpp | C++ | src/abnf/ParserException.cpp | medooze/sdp- | 4bf23de4cf6ade65fedb68a8c8a5baf4bd6a3e6d | [
"MIT"
] | 32 | 2018-01-01T17:01:19.000Z | 2022-02-25T10:30:47.000Z | src/abnf/ParserException.cpp | medooze/sdp- | 4bf23de4cf6ade65fedb68a8c8a5baf4bd6a3e6d | [
"MIT"
] | 4 | 2018-01-08T16:13:05.000Z | 2021-01-25T11:47:44.000Z | src/abnf/ParserException.cpp | medooze/sdp- | 4bf23de4cf6ade65fedb68a8c8a5baf4bd6a3e6d | [
"MIT"
] | 13 | 2018-09-30T05:59:24.000Z | 2022-02-24T08:58:36.000Z | /* -----------------------------------------------------------------------------
* ParserException.cpp
* -----------------------------------------------------------------------------
*
* Producer : com.parse2.aparse.Parser 2.5
* Produced : Mon Jan 08 13:30:55 CET 2018
*
* -----------------------------------------------------------------------------
*/
#include <string>
using std::string;
#include <vector>
using std::vector;
#include <exception>
using std::exception;
#include <regex>
using std::regex;
#include "ParserException.hpp"
using namespace abnf;
ParserException::ParserException(
const string& reason,
const string& text,
unsigned int index,
const vector<string>& ruleStack) :
reason(reason),
ruleStack(ruleStack),
cause(NULL)
{
unsigned int start = (index < 30) ? 0: index - 30;
unsigned int end = (text.length() < index + 30) ? text.length(): index + 30;
text60 = text.substr(start, end - start);
index60 = (index < 30) ? index : 30;
regex rx("[\\x00-\\x1F]");
text60 = regex_replace(text60, rx, string(" "));
}
ParserException::ParserException(const ParserException& exception) :
reason(exception.reason),
text60(exception.text60),
index60(exception.index60),
ruleStack(exception.ruleStack),
cause(NULL)
{
if (exception.cause != NULL)
cause = new ParserException(*exception.cause);
}
ParserException& ParserException::operator=(const ParserException& exception)
{
if (&exception != this)
{
reason = exception.reason;
text60 = exception.text60;
index60 = exception.index60;
ruleStack = exception.ruleStack;
delete cause;
cause = NULL;
if (exception.cause != NULL)
cause = new ParserException(*exception.cause);
}
return *this;
}
ParserException::~ParserException() throw()
{
delete cause;
}
const string& ParserException::getReason(void) const
{
return reason;
}
const string& ParserException::getSubstring(void) const
{
return text60;
}
unsigned int ParserException::getSubstringIndex(void) const
{
return index60;
}
const vector<string>& ParserException::getRuleStack(void) const
{
return ruleStack;
}
const char* ParserException::what(void) throw()
{
string marker(" ");
message = reason + "\n";
message += text60 + "\n";
message += marker.substr(0, index60) + "^\n";
if (!ruleStack.empty())
{
message += "rule stack:\n";
vector<string>::const_iterator s;
for (s = ruleStack.begin(); s != ruleStack.end(); s++)
message += " " + *s + "\n";
}
if (cause != NULL)
{
message += "possible cause: ";
message += cause->what();
}
return message.c_str();
}
void ParserException::setCause(const ParserException& cause)
{
delete this->cause;
this->cause = new ParserException(cause);
}
const ParserException* ParserException::getCause(void) const
{
return cause;
}
/* -----------------------------------------------------------------------------
* eof
* -----------------------------------------------------------------------------
*/
| 22.680851 | 81 | 0.550031 | medooze |
428e95ccf96e10655d2dace01af8b187e8c25960 | 187 | cpp | C++ | tools/clang/test/SemaTemplate/crash.cpp | clayne/DirectXShaderCompiler | 0ef9b702890b1d45f0bec5fa75481290323e14dc | [
"NCSA"
] | 3,102 | 2015-01-04T02:28:35.000Z | 2022-03-30T12:53:41.000Z | tools/clang/test/SemaTemplate/crash.cpp | clayne/DirectXShaderCompiler | 0ef9b702890b1d45f0bec5fa75481290323e14dc | [
"NCSA"
] | 3,740 | 2019-01-23T15:36:48.000Z | 2022-03-31T22:01:13.000Z | tools/clang/test/SemaTemplate/crash.cpp | clayne/DirectXShaderCompiler | 0ef9b702890b1d45f0bec5fa75481290323e14dc | [
"NCSA"
] | 1,868 | 2015-01-03T04:27:11.000Z | 2022-03-25T13:37:35.000Z | // RUN: not %clang_cc1 -verify %s -std=c++11
// PR17730
template <typename T>
void S<T>::mem1();
template <typename T>
void S<T>::mem2() {
const int I = sizeof(T);
(void)I;
}
| 15.583333 | 44 | 0.588235 | clayne |
428f71f151729d9a102cbb0749f6f5cdd4ab6648 | 275 | hpp | C++ | bezGameEngine/src/bez/EntryPoint.hpp | Gustvo/bezGameEngine | 8d0ac4613d1a1aac65cab51d337b9a77d56f29ec | [
"MIT"
] | null | null | null | bezGameEngine/src/bez/EntryPoint.hpp | Gustvo/bezGameEngine | 8d0ac4613d1a1aac65cab51d337b9a77d56f29ec | [
"MIT"
] | null | null | null | bezGameEngine/src/bez/EntryPoint.hpp | Gustvo/bezGameEngine | 8d0ac4613d1a1aac65cab51d337b9a77d56f29ec | [
"MIT"
] | null | null | null | #ifndef ENTRYPOINT_H_INCLUDED
#define ENTRYPOINT_H_INCLUDED
extern bez::Application *bez::CreateApplication();
int main(int argc, char **argv) {
bez::Application *App = bez::CreateApplication();
App->run();
delete App;
return 0;
}
#endif // ENTRYPOINT_H_INCLUDED
| 18.333333 | 51 | 0.730909 | Gustvo |
429130d2016227a08b4a6362490ca46598c27e8a | 1,013 | cpp | C++ | src/sequences/track.cpp | aalin/synthz0r | ecf35b3fec39020e46732a15874b66f07a3e48e9 | [
"MIT"
] | 1 | 2021-12-23T21:14:37.000Z | 2021-12-23T21:14:37.000Z | src/sequences/track.cpp | aalin/synthz0r | ecf35b3fec39020e46732a15874b66f07a3e48e9 | [
"MIT"
] | null | null | null | src/sequences/track.cpp | aalin/synthz0r | ecf35b3fec39020e46732a15874b66f07a3e48e9 | [
"MIT"
] | null | null | null | #include "track.hpp"
#include <algorithm>
namespace Sequences {
SequencePtr Track::insertSequence(uint32_t start, uint32_t length) {
const auto it = std::find_if(
_sequences.begin(),
_sequences.end(),
[&](const SequencePtr sequence) -> bool {
return sequence->start() >= start;
}
);
const SequencePtr sequence = std::make_shared<Sequence>(start, length);
_sequences.insert(it, sequence);
return sequence;
}
bool Track::eraseSequence(uint32_t position) {
const auto it = std::find_if(
_sequences.begin(),
_sequences.end(),
[&](const SequencePtr sequence) -> bool {
return sequence->positionInside(position);
}
);
if (it == _sequences.end()) {
return false;
}
_sequences.erase(it);
return true;
}
void Track::getEventsAt(std::list<NoteEvent> &events, uint32_t position) const {
for (const SequencePtr sequence : _sequences) {
if (sequence->positionInside(position)) {
sequence->getEventsAt(events, position);
return;
}
}
}
}
| 21.104167 | 81 | 0.672261 | aalin |
42918ec543d89e2a9c7ece5312556a11432124a9 | 487,114 | cpp | C++ | MRTK/h/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs28.cpp | DreVinciCode/TEAM-08 | 4f148953a9f492c0fc0db7ee85803212caa1a579 | [
"MIT"
] | null | null | null | MRTK/h/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs28.cpp | DreVinciCode/TEAM-08 | 4f148953a9f492c0fc0db7ee85803212caa1a579 | [
"MIT"
] | null | null | null | MRTK/h/Il2CppOutputProject/Source/il2cppOutput/Il2CppCCWs28.cpp | DreVinciCode/TEAM-08 | 4f148953a9f492c0fc0db7ee85803212caa1a579 | [
"MIT"
] | null | null | null | #include "pch-cpp.hpp"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include <limits>
#include "vm/CachedCCWBase.h"
#include "utils/New.h"
// System.Collections.Generic.Dictionary`2<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D;
// System.Collections.Generic.Dictionary`2<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40;
// System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739;
// System.Collections.Generic.Dictionary`2<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98;
// System.Collections.Generic.Dictionary`2<System.String,System.Collections.Generic.List`1<System.Int32>>
struct Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929;
// System.Collections.Generic.Dictionary`2<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F;
// System.Collections.Generic.Dictionary`2<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205;
// System.Collections.Generic.Dictionary`2<System.String,System.Globalization.CultureInfo>
struct Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.GUIStyle>
struct Dictionary_2_t2CD153A36C5BD27CDDC85F23918ECEF77E892E80;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.GameObject>
struct Dictionary_2_tADDBF4C67A82C92CD16099CD166D7F72E8DCB13C;
// System.Collections.Generic.Dictionary`2<System.String,Microsoft.MixedReality.Toolkit.Utilities.GameObjectManagement.GameObjectCreator>
struct Dictionary_2_t4B905357EA6EEED5320FCD817152209CD639453E;
// System.Collections.Generic.Dictionary`2<System.String,Microsoft.MixedReality.Toolkit.Input.UnityInput.GenericJoystickController>
struct Dictionary_2_t5D9CAFC1B11A95DC4356C99DA81AA0D21DE3D602;
// System.Collections.Generic.Dictionary`2<System.String,System.Int32>
struct Dictionary_2_tC94E9875910491F8130C2DC8B11E4D1548A55162;
// System.Collections.Generic.Dictionary`2<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.InteractionState>
struct Dictionary_2_t0E12F87F5F41DF921DC34287B2628077FBD0B9B7;
// System.Collections.Generic.Dictionary`2<System.String,System.LocalDataStoreSlot>
struct Dictionary_2_tBB3B761B5CD370C29795A985E92637E6653997E5;
// System.Collections.Generic.Dictionary`2<System.String,System.Object>
struct Dictionary_2_t692011309BA94F599C6042A381FC9F8B3CB08399;
// System.Collections.Generic.Dictionary`2<System.String,System.Resources.ResourceLocator>
struct Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA;
// System.Collections.Generic.Dictionary`2<System.String,System.Resources.ResourceSet>
struct Dictionary_2_tF591ED968D904B93A92B04B711C65E797B9D6E5E;
// System.Collections.Generic.Dictionary`2<System.String,Mono.Globalization.Unicode.SimpleCollator>
struct Dictionary_2_t33B68634E5ACFD2A5AE4981521BFC06805BE18BB;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.Sprite>
struct Dictionary_2_t25CEE683B20ACF6398C3718DF163CF651693326D;
// System.Collections.Generic.Dictionary`2<System.String,System.String>
struct Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.Texture2D>
struct Dictionary_2_tEB18A32D0B180DF252D5178E45E11813020BE41C;
// System.Collections.Generic.Dictionary`2<System.String,System.Type>
struct Dictionary_2_t6BC8BF32EFF6FF794B125939AD0F300DAAE19F85;
// System.Collections.Generic.Dictionary`2<System.String,System.UInt32>
struct Dictionary_2_t99BA7D0CF2528BD5CE653B61B93932B7707E7573;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.Events.UnityEvent>
struct Dictionary_2_t0BCD203B3FCC34868639079F0E9F0E57FA4C4314;
// System.Collections.Generic.Dictionary`2<System.String,System.UriParser>
struct Dictionary_2_t29257EB2565DDF3180663167EF129FA9827836C5;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.UI.ThemeStateProperty,Microsoft.MixedReality.Toolkit.UI.ThemePropertyValue>
struct Dictionary_2_tC85D48713E18B1FD26F9D7F9765A88268BB0CEB3;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose>
struct Dictionary_2_tE426674B54CFF3CCAF252B5DDF3111CE0A95A0EB;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,System.Single>
struct Dictionary_2_t93B24EBF09EDC51FA44C753284CCDD5FDF4004F3;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,UnityEngine.Transform>
struct Dictionary_2_tDC9E775D45D1D6E7F42047602A04C152147746D6;
// System.Collections.Generic.Dictionary`2<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Input.InputAnimation/PoseCurves>
struct Dictionary_2_t8377EDD7191C350CDE78E5396001C8F68AD0BCFD;
// System.Collections.Generic.Dictionary`2<System.Type,System.Collections.Generic.List`1<System.Collections.Generic.KeyValuePair`2<Microsoft.MixedReality.Toolkit.IMixedRealityService,Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar>>>
struct Dictionary_2_tA857144DDDF55C789AD2D87220722C21D74CC1A5;
// System.Collections.Generic.Dictionary`2<System.Type,System.Collections.Generic.List`1<System.Type>>
struct Dictionary_2_t8861992B7AEFEDACB74CCE3F8CDCB0349726A3D5;
// System.Collections.Generic.Dictionary`2<System.Type,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry>>
struct Dictionary_2_tEB7DD469D67D40F77F686DD4BC38E8ED993B35A9;
// System.Collections.Generic.ICollection`1<System.Int64>
struct ICollection_1_t8C5F082A91912BD5FF56F069099F2C862A275D47;
// System.Collections.Generic.ICollection`1<System.Runtime.Serialization.MemberHolder>
struct ICollection_1_t29FC939898A1CD62AAAAE62533493551757EEA9D;
// System.Collections.Generic.ICollection`1<UnityEngine.Mesh>
struct ICollection_1_t7F769DFF0B3F1FFF0181F521B9ABD47A15E0234F;
// System.Collections.Generic.ICollection`1<System.Reflection.MethodInfo>
struct ICollection_1_tDD9B777C20B498B36106AA59DF67126445CB2B60;
// System.Collections.Generic.ICollection`1<System.Object>
struct ICollection_1_t35488BE070734B4C5D136DC1A68CBC9CE507D488;
// System.Collections.Generic.ICollection`1<UnityEngine.Renderer>
struct ICollection_1_tB1A53AFE12C7FBD53E416B8623535F59C4E520B1;
// System.Collections.Generic.ICollection`1<System.String>
struct ICollection_1_t286AA3BBFF7FCE401FEFF57AEEC4FDAABA9F95B1;
// System.Collections.Generic.ICollection`1<Microsoft.MixedReality.Toolkit.UI.ThemeStateProperty>
struct ICollection_1_t7F82C99D69CE24E84C19A95A27904D02779D91C7;
// System.Collections.Generic.ICollection`1<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint>
struct ICollection_1_t625E940F4881EF4FD24EADC5FEB2F9138BFFA42B;
// System.Collections.Generic.ICollection`1<System.Type>
struct ICollection_1_t2A311F55E04C5A89362DF55411A42457AFD43A82;
struct IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB;
struct IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D;
struct IIterator_1_t2CFACF402D9A2D616023D5DA34FDF5739B123E32;
struct IIterator_1_t3FD87DAE4281E0090447733627B3A0BA377B6CEC;
struct IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4;
struct IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF;
struct IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Windows.Foundation.Collections.IIterable`1<System.Collections.Generic.IEnumerable`1<System.Char>>
struct NOVTABLE IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Collections.IEnumerable>
struct NOVTABLE IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Int64>
struct NOVTABLE IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579(IIterator_1_t3FD87DAE4281E0090447733627B3A0BA377B6CEC** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Object>
struct NOVTABLE IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.String>
struct NOVTABLE IIterable_1_t94592E586C395F026290ACC676E74C560595CC26 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) = 0;
};
// Windows.Foundation.Collections.IIterable`1<System.Type>
struct NOVTABLE IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67(IIterator_1_t2CFACF402D9A2D616023D5DA34FDF5739B123E32** comReturnValue) = 0;
};
// Windows.UI.Xaml.Interop.IBindableIterable
struct NOVTABLE IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8 : Il2CppIInspectable
{
static const Il2CppGuid IID;
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) = 0;
};
// System.Object
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Int64,TMPro.TMP_MaterialManager/FallbackMaterial>
struct KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Runtime.Serialization.MemberHolder,System.Reflection.MemberInfo[]>
struct KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct KeyCollection_t5D9800EAB943FC53EC58F55FDFC5E67C6511D223 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t5D9800EAB943FC53EC58F55FDFC5E67C6511D223, ___dictionary_0)); }
inline Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tF0DE4461DF2636D9145F888111E2BE960C03322D * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct KeyCollection_t93F2D1A04DC51685953BDB647A4B46AE6634AC8C : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t93F2D1A04DC51685953BDB647A4B46AE6634AC8C, ___dictionary_0)); }
inline Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t6C6D04C7C1300F445B3AE7ED8519CB478C0DBE40 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct KeyCollection_t6F870BF5CEDDFEB13959730E1D35AF53F95D1153 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t6F870BF5CEDDFEB13959730E1D35AF53F95D1153, ___dictionary_0)); }
inline Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t5BB631D653FC099355128DBC14DC44E27AD30739 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct KeyCollection_t2214A1F555589A7FBB88414B282C4CD4F3F60359 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t2214A1F555589A7FBB88414B282C4CD4F3F60359, ___dictionary_0)); }
inline Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t547EF37CA1540BB99B5AB9F9522E2722EB0FDE98 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Collections.Generic.List`1<System.Int32>>
struct KeyCollection_tA60E7BE57EBB9593DF56BAFFA99E103A9A78BF33 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_tA60E7BE57EBB9593DF56BAFFA99E103A9A78BF33, ___dictionary_0)); }
inline Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t0141BC6966873E9827CA2F0856EF6D6EA51AD929 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Collections.Generic.List`1<System.Int32>>
struct KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct KeyCollection_t47FFDBDA052BA25EBBE7B1AAD324D29257951CF7 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t47FFDBDA052BA25EBBE7B1AAD324D29257951CF7, ___dictionary_0)); }
inline Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tDE4EDBDC568FB033EAC636207097351E6DC14C3F * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct KeyCollection_tAB118A862065867FDA2C4F16B826C3919F04D02D : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_tAB118A862065867FDA2C4F16B826C3919F04D02D, ___dictionary_0)); }
inline Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t0C12B4D9AB2F49DBABB410260E694A4799DCB205 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Globalization.CultureInfo>
struct KeyCollection_tA97841DFBD5A46D755F70949AC18B5BA42630EDA : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_tA97841DFBD5A46D755F70949AC18B5BA42630EDA, ___dictionary_0)); }
inline Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t0015CBF964B0687CBB5ECFDDE06671A8F3DDE4BC * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Globalization.CultureInfo>
struct KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.GUIStyle>
struct KeyCollection_t1E5094B165BA0458CA9D3802C14EFF5DB95213CB : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t2CD153A36C5BD27CDDC85F23918ECEF77E892E80 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t1E5094B165BA0458CA9D3802C14EFF5DB95213CB, ___dictionary_0)); }
inline Dictionary_2_t2CD153A36C5BD27CDDC85F23918ECEF77E892E80 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t2CD153A36C5BD27CDDC85F23918ECEF77E892E80 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t2CD153A36C5BD27CDDC85F23918ECEF77E892E80 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.GUIStyle>
struct KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.GameObject>
struct KeyCollection_t8B43E8504381EBAE726A65E47CF5C58389CCDCD3 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tADDBF4C67A82C92CD16099CD166D7F72E8DCB13C * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t8B43E8504381EBAE726A65E47CF5C58389CCDCD3, ___dictionary_0)); }
inline Dictionary_2_tADDBF4C67A82C92CD16099CD166D7F72E8DCB13C * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tADDBF4C67A82C92CD16099CD166D7F72E8DCB13C ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tADDBF4C67A82C92CD16099CD166D7F72E8DCB13C * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.GameObject>
struct KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Utilities.GameObjectManagement.GameObjectCreator>
struct KeyCollection_t1122EEA535EF5F9C55B03710037D2A2F83E668E3 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t4B905357EA6EEED5320FCD817152209CD639453E * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t1122EEA535EF5F9C55B03710037D2A2F83E668E3, ___dictionary_0)); }
inline Dictionary_2_t4B905357EA6EEED5320FCD817152209CD639453E * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t4B905357EA6EEED5320FCD817152209CD639453E ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t4B905357EA6EEED5320FCD817152209CD639453E * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Utilities.GameObjectManagement.GameObjectCreator>
struct KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Input.UnityInput.GenericJoystickController>
struct KeyCollection_t4CAE5E104DB45CE6C6701604859EBD291F147A52 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t5D9CAFC1B11A95DC4356C99DA81AA0D21DE3D602 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t4CAE5E104DB45CE6C6701604859EBD291F147A52, ___dictionary_0)); }
inline Dictionary_2_t5D9CAFC1B11A95DC4356C99DA81AA0D21DE3D602 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t5D9CAFC1B11A95DC4356C99DA81AA0D21DE3D602 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t5D9CAFC1B11A95DC4356C99DA81AA0D21DE3D602 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Input.UnityInput.GenericJoystickController>
struct KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Int32>
struct KeyCollection_t61F8738ED346768CC112B2E27863BF9F73C76D90 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tC94E9875910491F8130C2DC8B11E4D1548A55162 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t61F8738ED346768CC112B2E27863BF9F73C76D90, ___dictionary_0)); }
inline Dictionary_2_tC94E9875910491F8130C2DC8B11E4D1548A55162 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tC94E9875910491F8130C2DC8B11E4D1548A55162 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tC94E9875910491F8130C2DC8B11E4D1548A55162 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Int32>
struct KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.InteractionState>
struct KeyCollection_tE1AC1685E655D31A9891CE62663D5D15F7266158 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t0E12F87F5F41DF921DC34287B2628077FBD0B9B7 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_tE1AC1685E655D31A9891CE62663D5D15F7266158, ___dictionary_0)); }
inline Dictionary_2_t0E12F87F5F41DF921DC34287B2628077FBD0B9B7 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t0E12F87F5F41DF921DC34287B2628077FBD0B9B7 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t0E12F87F5F41DF921DC34287B2628077FBD0B9B7 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.InteractionState>
struct KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.LocalDataStoreSlot>
struct KeyCollection_t0051F3CCCFE0093795854005431A3856482487EC : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tBB3B761B5CD370C29795A985E92637E6653997E5 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t0051F3CCCFE0093795854005431A3856482487EC, ___dictionary_0)); }
inline Dictionary_2_tBB3B761B5CD370C29795A985E92637E6653997E5 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tBB3B761B5CD370C29795A985E92637E6653997E5 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tBB3B761B5CD370C29795A985E92637E6653997E5 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.LocalDataStoreSlot>
struct KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Object>
struct KeyCollection_t0043475CBB02FD67894529F3CAA818080A2F7A17 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t692011309BA94F599C6042A381FC9F8B3CB08399 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t0043475CBB02FD67894529F3CAA818080A2F7A17, ___dictionary_0)); }
inline Dictionary_2_t692011309BA94F599C6042A381FC9F8B3CB08399 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t692011309BA94F599C6042A381FC9F8B3CB08399 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t692011309BA94F599C6042A381FC9F8B3CB08399 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Object>
struct KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Resources.ResourceLocator>
struct KeyCollection_t643390FEAB46EFC9FBC9286134BD21291A0B50DB : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t643390FEAB46EFC9FBC9286134BD21291A0B50DB, ___dictionary_0)); }
inline Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t46A02F90A8D65228E634FEFFC9BE32C560592BBA * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Resources.ResourceLocator>
struct KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Resources.ResourceSet>
struct KeyCollection_t5055F9153B6CD1765C9BB7D782E1266B244DC577 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tF591ED968D904B93A92B04B711C65E797B9D6E5E * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t5055F9153B6CD1765C9BB7D782E1266B244DC577, ___dictionary_0)); }
inline Dictionary_2_tF591ED968D904B93A92B04B711C65E797B9D6E5E * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tF591ED968D904B93A92B04B711C65E797B9D6E5E ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tF591ED968D904B93A92B04B711C65E797B9D6E5E * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Resources.ResourceSet>
struct KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Mono.Globalization.Unicode.SimpleCollator>
struct KeyCollection_t2C7C653A7F7E6A2DB2621D56B913C89985FDDACE : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t33B68634E5ACFD2A5AE4981521BFC06805BE18BB * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t2C7C653A7F7E6A2DB2621D56B913C89985FDDACE, ___dictionary_0)); }
inline Dictionary_2_t33B68634E5ACFD2A5AE4981521BFC06805BE18BB * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t33B68634E5ACFD2A5AE4981521BFC06805BE18BB ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t33B68634E5ACFD2A5AE4981521BFC06805BE18BB * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Mono.Globalization.Unicode.SimpleCollator>
struct KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.Sprite>
struct KeyCollection_t53F5497143F09947914563DA625139636D768FAA : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t25CEE683B20ACF6398C3718DF163CF651693326D * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t53F5497143F09947914563DA625139636D768FAA, ___dictionary_0)); }
inline Dictionary_2_t25CEE683B20ACF6398C3718DF163CF651693326D * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t25CEE683B20ACF6398C3718DF163CF651693326D ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t25CEE683B20ACF6398C3718DF163CF651693326D * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.Sprite>
struct KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.String>
struct KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D, ___dictionary_0)); }
inline Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tDE3227CA5E7A32F5070BD24C69F42204A3ADE9D5 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.String>
struct KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.Texture2D>
struct KeyCollection_t5BF010F61696931AD604E5661D57B0C3E75F3F89 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tEB18A32D0B180DF252D5178E45E11813020BE41C * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t5BF010F61696931AD604E5661D57B0C3E75F3F89, ___dictionary_0)); }
inline Dictionary_2_tEB18A32D0B180DF252D5178E45E11813020BE41C * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tEB18A32D0B180DF252D5178E45E11813020BE41C ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tEB18A32D0B180DF252D5178E45E11813020BE41C * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.Texture2D>
struct KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Type>
struct KeyCollection_t6397E1BA96E179AE535A53A9C3EE6CBF5FBF3E63 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t6BC8BF32EFF6FF794B125939AD0F300DAAE19F85 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t6397E1BA96E179AE535A53A9C3EE6CBF5FBF3E63, ___dictionary_0)); }
inline Dictionary_2_t6BC8BF32EFF6FF794B125939AD0F300DAAE19F85 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t6BC8BF32EFF6FF794B125939AD0F300DAAE19F85 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t6BC8BF32EFF6FF794B125939AD0F300DAAE19F85 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Type>
struct KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.UInt32>
struct KeyCollection_t9C88EBD04A7C700534B59CA7684F98CB11C52E5D : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t99BA7D0CF2528BD5CE653B61B93932B7707E7573 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t9C88EBD04A7C700534B59CA7684F98CB11C52E5D, ___dictionary_0)); }
inline Dictionary_2_t99BA7D0CF2528BD5CE653B61B93932B7707E7573 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t99BA7D0CF2528BD5CE653B61B93932B7707E7573 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t99BA7D0CF2528BD5CE653B61B93932B7707E7573 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.UInt32>
struct KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.Events.UnityEvent>
struct KeyCollection_t23CC136CA560A267CB18F7AA505993453468C183 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t0BCD203B3FCC34868639079F0E9F0E57FA4C4314 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t23CC136CA560A267CB18F7AA505993453468C183, ___dictionary_0)); }
inline Dictionary_2_t0BCD203B3FCC34868639079F0E9F0E57FA4C4314 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t0BCD203B3FCC34868639079F0E9F0E57FA4C4314 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t0BCD203B3FCC34868639079F0E9F0E57FA4C4314 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.Events.UnityEvent>
struct KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.UriParser>
struct KeyCollection_t4D8331BBA9E57CE61F833B1895C15542E3802424 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t29257EB2565DDF3180663167EF129FA9827836C5 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t4D8331BBA9E57CE61F833B1895C15542E3802424, ___dictionary_0)); }
inline Dictionary_2_t29257EB2565DDF3180663167EF129FA9827836C5 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t29257EB2565DDF3180663167EF129FA9827836C5 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t29257EB2565DDF3180663167EF129FA9827836C5 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.UriParser>
struct KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.UI.ThemeStateProperty,Microsoft.MixedReality.Toolkit.UI.ThemePropertyValue>
struct KeyCollection_t0E9D21E1764A2A08C9A644438565631107B5B72C : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tC85D48713E18B1FD26F9D7F9765A88268BB0CEB3 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t0E9D21E1764A2A08C9A644438565631107B5B72C, ___dictionary_0)); }
inline Dictionary_2_tC85D48713E18B1FD26F9D7F9765A88268BB0CEB3 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tC85D48713E18B1FD26F9D7F9765A88268BB0CEB3 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tC85D48713E18B1FD26F9D7F9765A88268BB0CEB3 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.UI.ThemeStateProperty,Microsoft.MixedReality.Toolkit.UI.ThemePropertyValue>
struct KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose>
struct KeyCollection_t49F18CA1046C5A2A8F4A41810E82803FCDC70EA8 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tE426674B54CFF3CCAF252B5DDF3111CE0A95A0EB * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t49F18CA1046C5A2A8F4A41810E82803FCDC70EA8, ___dictionary_0)); }
inline Dictionary_2_tE426674B54CFF3CCAF252B5DDF3111CE0A95A0EB * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tE426674B54CFF3CCAF252B5DDF3111CE0A95A0EB ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tE426674B54CFF3CCAF252B5DDF3111CE0A95A0EB * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose>
struct KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,System.Single>
struct KeyCollection_t9CAEAB716527725A2B440D05EFA11A6EFFD19D90 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t93B24EBF09EDC51FA44C753284CCDD5FDF4004F3 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t9CAEAB716527725A2B440D05EFA11A6EFFD19D90, ___dictionary_0)); }
inline Dictionary_2_t93B24EBF09EDC51FA44C753284CCDD5FDF4004F3 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t93B24EBF09EDC51FA44C753284CCDD5FDF4004F3 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t93B24EBF09EDC51FA44C753284CCDD5FDF4004F3 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,System.Single>
struct KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,UnityEngine.Transform>
struct KeyCollection_t7964F094226E0A06D962B60D99A23F14538D122E : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tDC9E775D45D1D6E7F42047602A04C152147746D6 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t7964F094226E0A06D962B60D99A23F14538D122E, ___dictionary_0)); }
inline Dictionary_2_tDC9E775D45D1D6E7F42047602A04C152147746D6 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tDC9E775D45D1D6E7F42047602A04C152147746D6 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tDC9E775D45D1D6E7F42047602A04C152147746D6 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,UnityEngine.Transform>
struct KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Input.InputAnimation/PoseCurves>
struct KeyCollection_t26193BCF221B624B63BED3D656E81EE962D231BD : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t8377EDD7191C350CDE78E5396001C8F68AD0BCFD * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t26193BCF221B624B63BED3D656E81EE962D231BD, ___dictionary_0)); }
inline Dictionary_2_t8377EDD7191C350CDE78E5396001C8F68AD0BCFD * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t8377EDD7191C350CDE78E5396001C8F68AD0BCFD ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t8377EDD7191C350CDE78E5396001C8F68AD0BCFD * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Input.InputAnimation/PoseCurves>
struct KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<System.Collections.Generic.KeyValuePair`2<Microsoft.MixedReality.Toolkit.IMixedRealityService,Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar>>>
struct KeyCollection_tD184B71B3F01E98151A7B3ADDA538C3D41A4D66E : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tA857144DDDF55C789AD2D87220722C21D74CC1A5 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_tD184B71B3F01E98151A7B3ADDA538C3D41A4D66E, ___dictionary_0)); }
inline Dictionary_2_tA857144DDDF55C789AD2D87220722C21D74CC1A5 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tA857144DDDF55C789AD2D87220722C21D74CC1A5 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tA857144DDDF55C789AD2D87220722C21D74CC1A5 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<System.Collections.Generic.KeyValuePair`2<Microsoft.MixedReality.Toolkit.IMixedRealityService,Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar>>>
struct KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8 : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<System.Type>>
struct KeyCollection_t9E16F94F958220DD61A151F0CE72C3E28C6C2BBC : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_t8861992B7AEFEDACB74CCE3F8CDCB0349726A3D5 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t9E16F94F958220DD61A151F0CE72C3E28C6C2BBC, ___dictionary_0)); }
inline Dictionary_2_t8861992B7AEFEDACB74CCE3F8CDCB0349726A3D5 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_t8861992B7AEFEDACB74CCE3F8CDCB0349726A3D5 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_t8861992B7AEFEDACB74CCE3F8CDCB0349726A3D5 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
// System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<System.Type>>
struct KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB : public RuntimeObject
{
public:
// System.Collections.Generic.ICollection`1<TKey> System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_collection
RuntimeObject* ___m_collection_0;
// System.Object System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection::m_syncRoot
RuntimeObject * ___m_syncRoot_1;
public:
inline static int32_t get_offset_of_m_collection_0() { return static_cast<int32_t>(offsetof(KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB, ___m_collection_0)); }
inline RuntimeObject* get_m_collection_0() const { return ___m_collection_0; }
inline RuntimeObject** get_address_of_m_collection_0() { return &___m_collection_0; }
inline void set_m_collection_0(RuntimeObject* value)
{
___m_collection_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_collection_0), (void*)value);
}
inline static int32_t get_offset_of_m_syncRoot_1() { return static_cast<int32_t>(offsetof(KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB, ___m_syncRoot_1)); }
inline RuntimeObject * get_m_syncRoot_1() const { return ___m_syncRoot_1; }
inline RuntimeObject ** get_address_of_m_syncRoot_1() { return &___m_syncRoot_1; }
inline void set_m_syncRoot_1(RuntimeObject * value)
{
___m_syncRoot_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_syncRoot_1), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry>>
struct KeyCollection_t57D8B1D683B3BA6FC1F65FBAEF6CF7B89CF53C14 : public RuntimeObject
{
public:
// System.Collections.Generic.Dictionary`2<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection::dictionary
Dictionary_2_tEB7DD469D67D40F77F686DD4BC38E8ED993B35A9 * ___dictionary_0;
public:
inline static int32_t get_offset_of_dictionary_0() { return static_cast<int32_t>(offsetof(KeyCollection_t57D8B1D683B3BA6FC1F65FBAEF6CF7B89CF53C14, ___dictionary_0)); }
inline Dictionary_2_tEB7DD469D67D40F77F686DD4BC38E8ED993B35A9 * get_dictionary_0() const { return ___dictionary_0; }
inline Dictionary_2_tEB7DD469D67D40F77F686DD4BC38E8ED993B35A9 ** get_address_of_dictionary_0() { return &___dictionary_0; }
inline void set_dictionary_0(Dictionary_2_tEB7DD469D67D40F77F686DD4BC38E8ED993B35A9 * value)
{
___dictionary_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dictionary_0), (void*)value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
il2cpp_hresult_t IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t3FD87DAE4281E0090447733627B3A0BA377B6CEC** comReturnValue);
il2cpp_hresult_t IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue);
il2cpp_hresult_t IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue);
il2cpp_hresult_t IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue);
il2cpp_hresult_t IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67_ComCallableWrapperProjectedMethod(RuntimeObject* __this, IIterator_1_t2CFACF402D9A2D616023D5DA34FDF5739B123E32** comReturnValue);
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Int64,TMPro.TMP_MaterialManager/FallbackMaterial>
struct KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838_ComCallableWrapper>, IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t30CEC1AA394C5CCDA490BB4CE97C7A91D3122A6F::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579(IIterator_1_t3FD87DAE4281E0090447733627B3A0BA377B6CEC** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mFE037A1FA26B15187119714FC35E6254FAE04579_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t7FC61CF1722FA8A2389B94E516A7F8948A1AF838_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Runtime.Serialization.MemberHolder,System.Reflection.MemberInfo[]>
struct KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t73568D611681B519BC34D842A97FB8678108FD73_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct KeyCollection_t5D9800EAB943FC53EC58F55FDFC5E67C6511D223_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t5D9800EAB943FC53EC58F55FDFC5E67C6511D223_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t5D9800EAB943FC53EC58F55FDFC5E67C6511D223_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t5D9800EAB943FC53EC58F55FDFC5E67C6511D223_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t5D9800EAB943FC53EC58F55FDFC5E67C6511D223(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t5D9800EAB943FC53EC58F55FDFC5E67C6511D223_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t5D9800EAB943FC53EC58F55FDFC5E67C6511D223_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<UnityEngine.Mesh,Microsoft.MixedReality.Toolkit.Utilities.MeshSmoother/MeshReference>
struct KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t4C1178B54B5D68FD2A77862BD2DE28804B6BA33F_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct KeyCollection_t93F2D1A04DC51685953BDB647A4B46AE6634AC8C_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t93F2D1A04DC51685953BDB647A4B46AE6634AC8C_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t93F2D1A04DC51685953BDB647A4B46AE6634AC8C_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t93F2D1A04DC51685953BDB647A4B46AE6634AC8C_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t93F2D1A04DC51685953BDB647A4B46AE6634AC8C(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t93F2D1A04DC51685953BDB647A4B46AE6634AC8C_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t93F2D1A04DC51685953BDB647A4B46AE6634AC8C_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Reflection.MethodInfo,System.Collections.Generic.Dictionary`2<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>>
struct KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tF255544628C5C8D94AF421590B4A0FC1D6104E06_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct KeyCollection_t6F870BF5CEDDFEB13959730E1D35AF53F95D1153_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t6F870BF5CEDDFEB13959730E1D35AF53F95D1153_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t6F870BF5CEDDFEB13959730E1D35AF53F95D1153_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t6F870BF5CEDDFEB13959730E1D35AF53F95D1153_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t6F870BF5CEDDFEB13959730E1D35AF53F95D1153(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t6F870BF5CEDDFEB13959730E1D35AF53F95D1153_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t6F870BF5CEDDFEB13959730E1D35AF53F95D1153_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Object,System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal/EventRegistrationTokenList>
struct KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t43B58BDCFCF88BA3367B5C1F78A339389D841B6B_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct KeyCollection_t2214A1F555589A7FBB88414B282C4CD4F3F60359_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t2214A1F555589A7FBB88414B282C4CD4F3F60359_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t2214A1F555589A7FBB88414B282C4CD4F3F60359_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t2214A1F555589A7FBB88414B282C4CD4F3F60359_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t2214A1F555589A7FBB88414B282C4CD4F3F60359(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t2214A1F555589A7FBB88414B282C4CD4F3F60359_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t2214A1F555589A7FBB88414B282C4CD4F3F60359_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<UnityEngine.Renderer,System.Collections.Generic.List`1<UnityEngine.Material>>
struct KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t70F23CB996AA73D7B68028CFC22A80A11BD269A3_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Collections.Generic.List`1<System.Int32>>
struct KeyCollection_tA60E7BE57EBB9593DF56BAFFA99E103A9A78BF33_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tA60E7BE57EBB9593DF56BAFFA99E103A9A78BF33_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tA60E7BE57EBB9593DF56BAFFA99E103A9A78BF33_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tA60E7BE57EBB9593DF56BAFFA99E103A9A78BF33_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tA60E7BE57EBB9593DF56BAFFA99E103A9A78BF33(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tA60E7BE57EBB9593DF56BAFFA99E103A9A78BF33_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tA60E7BE57EBB9593DF56BAFFA99E103A9A78BF33_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Collections.Generic.List`1<System.Int32>>
struct KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tCFAB06971F4B420D0AB07A7FA3A5762A7B4C6879_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct KeyCollection_t47FFDBDA052BA25EBBE7B1AAD324D29257951CF7_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t47FFDBDA052BA25EBBE7B1AAD324D29257951CF7_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t47FFDBDA052BA25EBBE7B1AAD324D29257951CF7_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t47FFDBDA052BA25EBBE7B1AAD324D29257951CF7_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t47FFDBDA052BA25EBBE7B1AAD324D29257951CF7(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t47FFDBDA052BA25EBBE7B1AAD324D29257951CF7_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t47FFDBDA052BA25EBBE7B1AAD324D29257951CF7_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Collections.Generic.Queue`1<UnityEngine.GameObject>>
struct KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t27F140EDFA0CAC95B2CA7B9C23352CFFFD4AF26F_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct KeyCollection_tAB118A862065867FDA2C4F16B826C3919F04D02D_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tAB118A862065867FDA2C4F16B826C3919F04D02D_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tAB118A862065867FDA2C4F16B826C3919F04D02D_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tAB118A862065867FDA2C4F16B826C3919F04D02D_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tAB118A862065867FDA2C4F16B826C3919F04D02D(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tAB118A862065867FDA2C4F16B826C3919F04D02D_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tAB118A862065867FDA2C4F16B826C3919F04D02D_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.BaseEventReceiver>
struct KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t9570D39366FB9C5652BAAB2D48A2292A8AEF4534_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Globalization.CultureInfo>
struct KeyCollection_tA97841DFBD5A46D755F70949AC18B5BA42630EDA_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tA97841DFBD5A46D755F70949AC18B5BA42630EDA_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tA97841DFBD5A46D755F70949AC18B5BA42630EDA_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tA97841DFBD5A46D755F70949AC18B5BA42630EDA_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tA97841DFBD5A46D755F70949AC18B5BA42630EDA(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tA97841DFBD5A46D755F70949AC18B5BA42630EDA_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tA97841DFBD5A46D755F70949AC18B5BA42630EDA_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Globalization.CultureInfo>
struct KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t2EC1E1515ECBC0F94EAF34526B42D782BB2F1BF3_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.GUIStyle>
struct KeyCollection_t1E5094B165BA0458CA9D3802C14EFF5DB95213CB_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t1E5094B165BA0458CA9D3802C14EFF5DB95213CB_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t1E5094B165BA0458CA9D3802C14EFF5DB95213CB_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t1E5094B165BA0458CA9D3802C14EFF5DB95213CB_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t1E5094B165BA0458CA9D3802C14EFF5DB95213CB(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t1E5094B165BA0458CA9D3802C14EFF5DB95213CB_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t1E5094B165BA0458CA9D3802C14EFF5DB95213CB_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.GUIStyle>
struct KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t7C861BAE4DE92F94FA4FB8B1F70EB91A502FB3CB_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.GameObject>
struct KeyCollection_t8B43E8504381EBAE726A65E47CF5C58389CCDCD3_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t8B43E8504381EBAE726A65E47CF5C58389CCDCD3_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t8B43E8504381EBAE726A65E47CF5C58389CCDCD3_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t8B43E8504381EBAE726A65E47CF5C58389CCDCD3_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t8B43E8504381EBAE726A65E47CF5C58389CCDCD3(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t8B43E8504381EBAE726A65E47CF5C58389CCDCD3_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t8B43E8504381EBAE726A65E47CF5C58389CCDCD3_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.GameObject>
struct KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t2C68CAC6CE44C0422A0D6E346EBECB663DD402BA_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Utilities.GameObjectManagement.GameObjectCreator>
struct KeyCollection_t1122EEA535EF5F9C55B03710037D2A2F83E668E3_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t1122EEA535EF5F9C55B03710037D2A2F83E668E3_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t1122EEA535EF5F9C55B03710037D2A2F83E668E3_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t1122EEA535EF5F9C55B03710037D2A2F83E668E3_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t1122EEA535EF5F9C55B03710037D2A2F83E668E3(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t1122EEA535EF5F9C55B03710037D2A2F83E668E3_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t1122EEA535EF5F9C55B03710037D2A2F83E668E3_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Utilities.GameObjectManagement.GameObjectCreator>
struct KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tA9358AFFA7B68621D3EDDE3533C5DAEAFC51B309_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Input.UnityInput.GenericJoystickController>
struct KeyCollection_t4CAE5E104DB45CE6C6701604859EBD291F147A52_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t4CAE5E104DB45CE6C6701604859EBD291F147A52_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t4CAE5E104DB45CE6C6701604859EBD291F147A52_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t4CAE5E104DB45CE6C6701604859EBD291F147A52_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t4CAE5E104DB45CE6C6701604859EBD291F147A52(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t4CAE5E104DB45CE6C6701604859EBD291F147A52_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t4CAE5E104DB45CE6C6701604859EBD291F147A52_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Input.UnityInput.GenericJoystickController>
struct KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t7ABF18D03F63DECFF35680067D1F9D7FA514BE69_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Int32>
struct KeyCollection_t61F8738ED346768CC112B2E27863BF9F73C76D90_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t61F8738ED346768CC112B2E27863BF9F73C76D90_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t61F8738ED346768CC112B2E27863BF9F73C76D90_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t61F8738ED346768CC112B2E27863BF9F73C76D90_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t61F8738ED346768CC112B2E27863BF9F73C76D90(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t61F8738ED346768CC112B2E27863BF9F73C76D90_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t61F8738ED346768CC112B2E27863BF9F73C76D90_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Int32>
struct KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t07BEC88094F6A41AB1A7C288E89E228DD02DF9A9_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.InteractionState>
struct KeyCollection_tE1AC1685E655D31A9891CE62663D5D15F7266158_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tE1AC1685E655D31A9891CE62663D5D15F7266158_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tE1AC1685E655D31A9891CE62663D5D15F7266158_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tE1AC1685E655D31A9891CE62663D5D15F7266158_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tE1AC1685E655D31A9891CE62663D5D15F7266158(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tE1AC1685E655D31A9891CE62663D5D15F7266158_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tE1AC1685E655D31A9891CE62663D5D15F7266158_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Microsoft.MixedReality.Toolkit.Experimental.InteractiveElement.InteractionState>
struct KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tD9812A96A72B97E72AC5DE7C8476EE60D3BDD455_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.LocalDataStoreSlot>
struct KeyCollection_t0051F3CCCFE0093795854005431A3856482487EC_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t0051F3CCCFE0093795854005431A3856482487EC_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t0051F3CCCFE0093795854005431A3856482487EC_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t0051F3CCCFE0093795854005431A3856482487EC_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t0051F3CCCFE0093795854005431A3856482487EC(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t0051F3CCCFE0093795854005431A3856482487EC_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t0051F3CCCFE0093795854005431A3856482487EC_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.LocalDataStoreSlot>
struct KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t745987AFED0DD473F87E9BAB581AA903FE917909_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Object>
struct KeyCollection_t0043475CBB02FD67894529F3CAA818080A2F7A17_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t0043475CBB02FD67894529F3CAA818080A2F7A17_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t0043475CBB02FD67894529F3CAA818080A2F7A17_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t0043475CBB02FD67894529F3CAA818080A2F7A17_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t0043475CBB02FD67894529F3CAA818080A2F7A17(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t0043475CBB02FD67894529F3CAA818080A2F7A17_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t0043475CBB02FD67894529F3CAA818080A2F7A17_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Object>
struct KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tE96A14879A0D65DF1A3BB158550A547678FD54E2_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Resources.ResourceLocator>
struct KeyCollection_t643390FEAB46EFC9FBC9286134BD21291A0B50DB_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t643390FEAB46EFC9FBC9286134BD21291A0B50DB_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t643390FEAB46EFC9FBC9286134BD21291A0B50DB_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t643390FEAB46EFC9FBC9286134BD21291A0B50DB_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t643390FEAB46EFC9FBC9286134BD21291A0B50DB(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t643390FEAB46EFC9FBC9286134BD21291A0B50DB_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t643390FEAB46EFC9FBC9286134BD21291A0B50DB_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Resources.ResourceLocator>
struct KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t2A1296386D6E29300601E7491310F981B154CC25_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Resources.ResourceSet>
struct KeyCollection_t5055F9153B6CD1765C9BB7D782E1266B244DC577_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t5055F9153B6CD1765C9BB7D782E1266B244DC577_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t5055F9153B6CD1765C9BB7D782E1266B244DC577_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t5055F9153B6CD1765C9BB7D782E1266B244DC577_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t5055F9153B6CD1765C9BB7D782E1266B244DC577(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t5055F9153B6CD1765C9BB7D782E1266B244DC577_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t5055F9153B6CD1765C9BB7D782E1266B244DC577_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Resources.ResourceSet>
struct KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tA8039DF8EAF42B408A3F110310CE6B20A3F544EA_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,Mono.Globalization.Unicode.SimpleCollator>
struct KeyCollection_t2C7C653A7F7E6A2DB2621D56B913C89985FDDACE_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t2C7C653A7F7E6A2DB2621D56B913C89985FDDACE_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t2C7C653A7F7E6A2DB2621D56B913C89985FDDACE_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t2C7C653A7F7E6A2DB2621D56B913C89985FDDACE_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t2C7C653A7F7E6A2DB2621D56B913C89985FDDACE(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t2C7C653A7F7E6A2DB2621D56B913C89985FDDACE_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t2C7C653A7F7E6A2DB2621D56B913C89985FDDACE_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,Mono.Globalization.Unicode.SimpleCollator>
struct KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tC0297D0052E026E0E8A4876C13CCFCA2F7E7258E_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.Sprite>
struct KeyCollection_t53F5497143F09947914563DA625139636D768FAA_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t53F5497143F09947914563DA625139636D768FAA_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t53F5497143F09947914563DA625139636D768FAA_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t53F5497143F09947914563DA625139636D768FAA_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t53F5497143F09947914563DA625139636D768FAA(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t53F5497143F09947914563DA625139636D768FAA_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t53F5497143F09947914563DA625139636D768FAA_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.Sprite>
struct KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tB2DF357DE90BC3118E0459675962D8398B91B280_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.String>
struct KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t52C81163A051BCD87A36FEF95F736DD600E2305D_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.String>
struct KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t8051195EC9E772852C5EF8B6C91754013AE95923_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.Texture2D>
struct KeyCollection_t5BF010F61696931AD604E5661D57B0C3E75F3F89_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t5BF010F61696931AD604E5661D57B0C3E75F3F89_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t5BF010F61696931AD604E5661D57B0C3E75F3F89_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t5BF010F61696931AD604E5661D57B0C3E75F3F89_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t5BF010F61696931AD604E5661D57B0C3E75F3F89(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t5BF010F61696931AD604E5661D57B0C3E75F3F89_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t5BF010F61696931AD604E5661D57B0C3E75F3F89_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.Texture2D>
struct KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tBAA78FC0BA274A02C206E5F3C29F3034DBF4B468_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.Type>
struct KeyCollection_t6397E1BA96E179AE535A53A9C3EE6CBF5FBF3E63_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t6397E1BA96E179AE535A53A9C3EE6CBF5FBF3E63_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t6397E1BA96E179AE535A53A9C3EE6CBF5FBF3E63_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t6397E1BA96E179AE535A53A9C3EE6CBF5FBF3E63_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t6397E1BA96E179AE535A53A9C3EE6CBF5FBF3E63(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t6397E1BA96E179AE535A53A9C3EE6CBF5FBF3E63_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t6397E1BA96E179AE535A53A9C3EE6CBF5FBF3E63_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.Type>
struct KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tE158CA7A9A272410B768D337A7A3325053BBF346_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.UInt32>
struct KeyCollection_t9C88EBD04A7C700534B59CA7684F98CB11C52E5D_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t9C88EBD04A7C700534B59CA7684F98CB11C52E5D_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t9C88EBD04A7C700534B59CA7684F98CB11C52E5D_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t9C88EBD04A7C700534B59CA7684F98CB11C52E5D_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t9C88EBD04A7C700534B59CA7684F98CB11C52E5D(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t9C88EBD04A7C700534B59CA7684F98CB11C52E5D_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t9C88EBD04A7C700534B59CA7684F98CB11C52E5D_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.UInt32>
struct KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tC203F162F1790785E4922ED84A85E0D50F5232AB_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,UnityEngine.Events.UnityEvent>
struct KeyCollection_t23CC136CA560A267CB18F7AA505993453468C183_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t23CC136CA560A267CB18F7AA505993453468C183_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t23CC136CA560A267CB18F7AA505993453468C183_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t23CC136CA560A267CB18F7AA505993453468C183_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t23CC136CA560A267CB18F7AA505993453468C183(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t23CC136CA560A267CB18F7AA505993453468C183_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t23CC136CA560A267CB18F7AA505993453468C183_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,UnityEngine.Events.UnityEvent>
struct KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t479FE38C6AE1996789FB3FD8F94DB680C3FC2744_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.String,System.UriParser>
struct KeyCollection_t4D8331BBA9E57CE61F833B1895C15542E3802424_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t4D8331BBA9E57CE61F833B1895C15542E3802424_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t4D8331BBA9E57CE61F833B1895C15542E3802424_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t4D8331BBA9E57CE61F833B1895C15542E3802424_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t4D8331BBA9E57CE61F833B1895C15542E3802424(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t4D8331BBA9E57CE61F833B1895C15542E3802424_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t4D8331BBA9E57CE61F833B1895C15542E3802424_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.String,System.UriParser>
struct KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06_ComCallableWrapper>, IIterable_1_t94592E586C395F026290ACC676E74C560595CC26, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824, IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t94592E586C395F026290ACC676E74C560595CC26*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(5);
interfaceIds[0] = IIterable_1_t94592E586C395F026290ACC676E74C560595CC26::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IIterable_1_t6359E278A71A51A15FA83695BA7C54F9B3E04824::IID;
interfaceIds[3] = IIterable_1_t05BE14C1DEA010486117E0E313F29EF024BDB2BF::IID;
interfaceIds[4] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 5;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7(IIterator_1_t125F1266580B29D637CD7546CA3812EB7C0B0D9D** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m03F765E1BD333E4E315525DE80BF54183A4D54D7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8(IIterator_1_t6A46A7244E5AAD0AE4F2A07AF43DA5052D55F4A4** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m512126C71D7E9D1C31B56F64455F33E9FEEC89F8_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87(IIterator_1_t966CEB5AF294B82E90C669B54974D432637938CF** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD8D790F1EED3414261E3D73A15AA6B40BD8B4A87_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tB0F2FDF4F6A16E7629A17469247F505E0FCA1E06_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.UI.ThemeStateProperty,Microsoft.MixedReality.Toolkit.UI.ThemePropertyValue>
struct KeyCollection_t0E9D21E1764A2A08C9A644438565631107B5B72C_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t0E9D21E1764A2A08C9A644438565631107B5B72C_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t0E9D21E1764A2A08C9A644438565631107B5B72C_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t0E9D21E1764A2A08C9A644438565631107B5B72C_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t0E9D21E1764A2A08C9A644438565631107B5B72C(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t0E9D21E1764A2A08C9A644438565631107B5B72C_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t0E9D21E1764A2A08C9A644438565631107B5B72C_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.UI.ThemeStateProperty,Microsoft.MixedReality.Toolkit.UI.ThemePropertyValue>
struct KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080_ComCallableWrapper>, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(2);
interfaceIds[0] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[1] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 2;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tA7D1C644F7D1191B6EBB28F2CB9C544F17CA1080_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose>
struct KeyCollection_t49F18CA1046C5A2A8F4A41810E82803FCDC70EA8_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t49F18CA1046C5A2A8F4A41810E82803FCDC70EA8_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t49F18CA1046C5A2A8F4A41810E82803FCDC70EA8_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t49F18CA1046C5A2A8F4A41810E82803FCDC70EA8_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t49F18CA1046C5A2A8F4A41810E82803FCDC70EA8(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t49F18CA1046C5A2A8F4A41810E82803FCDC70EA8_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t49F18CA1046C5A2A8F4A41810E82803FCDC70EA8_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Utilities.MixedRealityPose>
struct KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t4EFAADA0D00E26A2A81D6C2C356A09E5240953C4_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,System.Single>
struct KeyCollection_t9CAEAB716527725A2B440D05EFA11A6EFFD19D90_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t9CAEAB716527725A2B440D05EFA11A6EFFD19D90_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t9CAEAB716527725A2B440D05EFA11A6EFFD19D90_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t9CAEAB716527725A2B440D05EFA11A6EFFD19D90_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t9CAEAB716527725A2B440D05EFA11A6EFFD19D90(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t9CAEAB716527725A2B440D05EFA11A6EFFD19D90_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t9CAEAB716527725A2B440D05EFA11A6EFFD19D90_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,System.Single>
struct KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tEBFE8EA71C018BF548CC3AA7F9050DDA0233ADBF_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,UnityEngine.Transform>
struct KeyCollection_t7964F094226E0A06D962B60D99A23F14538D122E_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t7964F094226E0A06D962B60D99A23F14538D122E_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t7964F094226E0A06D962B60D99A23F14538D122E_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t7964F094226E0A06D962B60D99A23F14538D122E_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t7964F094226E0A06D962B60D99A23F14538D122E(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t7964F094226E0A06D962B60D99A23F14538D122E_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t7964F094226E0A06D962B60D99A23F14538D122E_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,UnityEngine.Transform>
struct KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t63FBEAC92C4C759A3C6ECCD0A8CBB511745442F1_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Input.InputAnimation/PoseCurves>
struct KeyCollection_t26193BCF221B624B63BED3D656E81EE962D231BD_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t26193BCF221B624B63BED3D656E81EE962D231BD_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t26193BCF221B624B63BED3D656E81EE962D231BD_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t26193BCF221B624B63BED3D656E81EE962D231BD_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t26193BCF221B624B63BED3D656E81EE962D231BD(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t26193BCF221B624B63BED3D656E81EE962D231BD_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t26193BCF221B624B63BED3D656E81EE962D231BD_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<Microsoft.MixedReality.Toolkit.Utilities.TrackedHandJoint,Microsoft.MixedReality.Toolkit.Input.InputAnimation/PoseCurves>
struct KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33_ComCallableWrapper>, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33_ComCallableWrapper>(obj) {}
virtual il2cpp_hresult_t STDCALL QueryInterface(const Il2CppGuid& iid, void** object) IL2CPP_OVERRIDE
{
if (::memcmp(&iid, &Il2CppIUnknown::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIInspectable::IID, sizeof(Il2CppGuid)) == 0
|| ::memcmp(&iid, &Il2CppIAgileObject::IID, sizeof(Il2CppGuid)) == 0)
{
*object = GetIdentity();
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIManagedObjectHolder::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIManagedObjectHolder*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(1);
interfaceIds[0] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 1;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tE3441D7A92FFCBB2B79B8A5A472B6B450F72FD33_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<System.Collections.Generic.KeyValuePair`2<Microsoft.MixedReality.Toolkit.IMixedRealityService,Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar>>>
struct KeyCollection_tD184B71B3F01E98151A7B3ADDA538C3D41A4D66E_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tD184B71B3F01E98151A7B3ADDA538C3D41A4D66E_ComCallableWrapper>, IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tD184B71B3F01E98151A7B3ADDA538C3D41A4D66E_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tD184B71B3F01E98151A7B3ADDA538C3D41A4D66E_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_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(3);
interfaceIds[0] = IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 3;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67(IIterator_1_t2CFACF402D9A2D616023D5DA34FDF5739B123E32** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tD184B71B3F01E98151A7B3ADDA538C3D41A4D66E(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tD184B71B3F01E98151A7B3ADDA538C3D41A4D66E_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tD184B71B3F01E98151A7B3ADDA538C3D41A4D66E_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<System.Collections.Generic.KeyValuePair`2<Microsoft.MixedReality.Toolkit.IMixedRealityService,Microsoft.MixedReality.Toolkit.IMixedRealityServiceRegistrar>>>
struct KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8_ComCallableWrapper>, IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8_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_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(3);
interfaceIds[0] = IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 3;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67(IIterator_1_t2CFACF402D9A2D616023D5DA34FDF5739B123E32** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_tFFE8E22DCCCFBF06CABDDF6915D62479F49BD2C8_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<System.Type>>
struct KeyCollection_t9E16F94F958220DD61A151F0CE72C3E28C6C2BBC_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t9E16F94F958220DD61A151F0CE72C3E28C6C2BBC_ComCallableWrapper>, IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t9E16F94F958220DD61A151F0CE72C3E28C6C2BBC_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t9E16F94F958220DD61A151F0CE72C3E28C6C2BBC_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_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(3);
interfaceIds[0] = IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 3;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67(IIterator_1_t2CFACF402D9A2D616023D5DA34FDF5739B123E32** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t9E16F94F958220DD61A151F0CE72C3E28C6C2BBC(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t9E16F94F958220DD61A151F0CE72C3E28C6C2BBC_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t9E16F94F958220DD61A151F0CE72C3E28C6C2BBC_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.ObjectModel.ReadOnlyDictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<System.Type>>
struct KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB_ComCallableWrapper>, IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB_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_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(3);
interfaceIds[0] = IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 3;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67(IIterator_1_t2CFACF402D9A2D616023D5DA34FDF5739B123E32** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t3EDED99D62B69817C6B393481AB0693C16D235EB_ComCallableWrapper(obj));
}
// COM Callable Wrapper for System.Collections.Generic.Dictionary`2/KeyCollection<System.Type,System.Collections.Generic.List`1<Microsoft.MixedReality.Toolkit.BaseEventSystem/EventHandlerEntry>>
struct KeyCollection_t57D8B1D683B3BA6FC1F65FBAEF6CF7B89CF53C14_ComCallableWrapper IL2CPP_FINAL : il2cpp::vm::CachedCCWBase<KeyCollection_t57D8B1D683B3BA6FC1F65FBAEF6CF7B89CF53C14_ComCallableWrapper>, IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872, IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4, IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8
{
inline KeyCollection_t57D8B1D683B3BA6FC1F65FBAEF6CF7B89CF53C14_ComCallableWrapper(RuntimeObject* obj) : il2cpp::vm::CachedCCWBase<KeyCollection_t57D8B1D683B3BA6FC1F65FBAEF6CF7B89CF53C14_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_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIMarshal::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIMarshal*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
if (::memcmp(&iid, &Il2CppIWeakReferenceSource::IID, sizeof(Il2CppGuid)) == 0)
{
*object = static_cast<Il2CppIWeakReferenceSource*>(this);
AddRefImpl();
return IL2CPP_S_OK;
}
*object = NULL;
return IL2CPP_E_NOINTERFACE;
}
virtual uint32_t STDCALL AddRef() IL2CPP_OVERRIDE
{
return AddRefImpl();
}
virtual uint32_t STDCALL Release() IL2CPP_OVERRIDE
{
return ReleaseImpl();
}
virtual il2cpp_hresult_t STDCALL GetIids(uint32_t* iidCount, Il2CppGuid** iids) IL2CPP_OVERRIDE
{
Il2CppGuid* interfaceIds = il2cpp_codegen_marshal_allocate_array<Il2CppGuid>(3);
interfaceIds[0] = IIterable_1_t4D7C58066842A44A0C48B4D670B58E08F5C98872::IID;
interfaceIds[1] = IIterable_1_t64693143CE4E5082C6101BC54B0427C21F3C01C4::IID;
interfaceIds[2] = IBindableIterable_tF6BD0C070562CD9C91E3C1B1A5F4667E9C3C74A8::IID;
*iidCount = 3;
*iids = interfaceIds;
return IL2CPP_S_OK;
}
virtual il2cpp_hresult_t STDCALL GetRuntimeClassName(Il2CppHString* className) IL2CPP_OVERRIDE
{
return GetRuntimeClassNameImpl(className);
}
virtual il2cpp_hresult_t STDCALL GetTrustLevel(int32_t* trustLevel) IL2CPP_OVERRIDE
{
return ComObjectBase::GetTrustLevel(trustLevel);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67(IIterator_1_t2CFACF402D9A2D616023D5DA34FDF5739B123E32** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_mD436D926611E89172F9CCDB96214C201E7E6AE67_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619(IIterator_1_tB1AB5AB497E87D6A397AA084D3D3D6B8D211022C** comReturnValue) IL2CPP_OVERRIDE
{
return IIterable_1_First_m54AC7E778E98ED35C6B7AD98C35C325B8A3DF619_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
virtual il2cpp_hresult_t STDCALL IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7(IBindableIterator_tD7550F1144CFBE58090050457A2BE92B1CAEABBB** comReturnValue) IL2CPP_OVERRIDE
{
return IBindableIterable_First_m91EC6ED0173145266318FDB7F9074798CD766BD7_ComCallableWrapperProjectedMethod(GetManagedObjectInline(), comReturnValue);
}
};
IL2CPP_EXTERN_C Il2CppIUnknown* CreateComCallableWrapperFor_KeyCollection_t57D8B1D683B3BA6FC1F65FBAEF6CF7B89CF53C14(RuntimeObject* obj)
{
void* memory = il2cpp::utils::Memory::Malloc(sizeof(KeyCollection_t57D8B1D683B3BA6FC1F65FBAEF6CF7B89CF53C14_ComCallableWrapper));
if (memory == NULL)
{
il2cpp_codegen_raise_out_of_memory_exception();
}
return static_cast<Il2CppIManagedObjectHolder*>(new(memory) KeyCollection_t57D8B1D683B3BA6FC1F65FBAEF6CF7B89CF53C14_ComCallableWrapper(obj));
}
| 44.25895 | 479 | 0.825897 | DreVinciCode |
42937a8586472399642f3d771bef9c5eef8fca73 | 4,124 | cpp | C++ | Engine/Test/Core/Molten/System/UserInputTest.cpp | jimmiebergmann/MoltenEngine | d39e1dc8f2e92bcac7936a5e283faa66f65118ab | [
"MIT"
] | 1 | 2020-10-05T05:24:47.000Z | 2020-10-05T05:24:47.000Z | Engine/Test/Core/Molten/System/UserInputTest.cpp | jimmiebergmann/MoltenEngine | d39e1dc8f2e92bcac7936a5e283faa66f65118ab | [
"MIT"
] | null | null | null | Engine/Test/Core/Molten/System/UserInputTest.cpp | jimmiebergmann/MoltenEngine | d39e1dc8f2e92bcac7936a5e283faa66f65118ab | [
"MIT"
] | null | null | null | /*
* MIT License
*
* Copyright (c) 2019 Jimmie Bergmann
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files(the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions :
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#include "Test.hpp"
#include "Molten/System/UserInput.hpp"
namespace Molten
{
TEST(System, UserInput_Mouse)
{
{
EXPECT_NO_THROW(Mouse::IsDown(Mouse::Button::Left));
EXPECT_NO_THROW(Mouse::IsDown(Mouse::Button::Middle));
EXPECT_NO_THROW(Mouse::IsDown(Mouse::Button::Right));
EXPECT_NO_THROW(Mouse::IsDown(Mouse::Button::Forward));
EXPECT_NO_THROW(Mouse::IsDown(Mouse::Button::Backward));
}
{
UserInput userInput;
UserInput::Event event;
userInput.Begin();
{
EXPECT_EQ(userInput.GetEventCount(), size_t(0));
userInput.PressMouseButton(Mouse::Button::Left, Vector2i32(100, 200));
}
userInput.End();
EXPECT_EQ(userInput.GetEventCount(), size_t(2));
EXPECT_TRUE(userInput.PollEvent(event));
EXPECT_EQ(event.type, UserInput::Event::Type::MouseButtonPressed);
EXPECT_EQ(event.mouseButtonEvent.button, Mouse::Button::Left);
EXPECT_EQ(event.mouseButtonEvent.position, Vector2i32(100, 200));
EXPECT_TRUE(userInput.PollEvent(event));
EXPECT_EQ(event.type, UserInput::Event::Type::MouseButtonDown);
EXPECT_EQ(event.mouseButtonEvent.button, Mouse::Button::Left);
EXPECT_EQ(event.mouseButtonEvent.position, Vector2i32(100, 200));
EXPECT_FALSE(userInput.PollEvent(event));
EXPECT_EQ(userInput.GetEventCount(), size_t(0));
userInput.Begin();
{
}
userInput.End();
EXPECT_EQ(userInput.GetEventCount(), size_t(1));
{
EXPECT_TRUE(userInput.PollEvent(event));
EXPECT_EQ(event.type, UserInput::Event::Type::MouseButtonDown);
EXPECT_EQ(event.mouseButtonEvent.button, Mouse::Button::Left);
EXPECT_EQ(event.mouseButtonEvent.position, Vector2i32(100, 200));
EXPECT_FALSE(userInput.PollEvent(event));
EXPECT_EQ(userInput.GetEventCount(), size_t(0));
}
userInput.Begin();
{
userInput.ReleaseMouseButton(Mouse::Button::Left, Vector2i32(100, 200));
}
userInput.End();
EXPECT_EQ(userInput.GetEventCount(), size_t(1));
{
EXPECT_TRUE(userInput.PollEvent(event));
EXPECT_EQ(event.type, UserInput::Event::Type::MouseButtonReleased);
EXPECT_EQ(event.mouseButtonEvent.button, Mouse::Button::Left);
EXPECT_EQ(event.mouseButtonEvent.position, Vector2i32(100, 200));
EXPECT_FALSE(userInput.PollEvent(event));
EXPECT_EQ(userInput.GetEventCount(), size_t(0));
}
userInput.Begin();
{
}
userInput.End();
EXPECT_EQ(userInput.GetEventCount(), size_t(0));
}
}
} | 38.542056 | 88 | 0.629243 | jimmiebergmann |
429970335fea53bffc30a617719b2848aa93a64a | 17,140 | cpp | C++ | contrib/pgxc_ctl/pgxc_ctl.cpp | wotchin/openGauss-server | ebd92e92b0cfd76b121d98e4c57a22d334573159 | [
"MulanPSL-1.0"
] | 1 | 2020-06-30T15:00:50.000Z | 2020-06-30T15:00:50.000Z | contrib/pgxc_ctl/pgxc_ctl.cpp | wotchin/openGauss-server | ebd92e92b0cfd76b121d98e4c57a22d334573159 | [
"MulanPSL-1.0"
] | null | null | null | contrib/pgxc_ctl/pgxc_ctl.cpp | wotchin/openGauss-server | ebd92e92b0cfd76b121d98e4c57a22d334573159 | [
"MulanPSL-1.0"
] | null | null | null | /*-------------------------------------------------------------------------
*
* pgxc_ctl.c
*
* Main module of Postgres-XC configuration and operation tool.
*
* Copyright (c) 2013 Postgres-XC Development Group
*
*-------------------------------------------------------------------------
*/
/*
* PXC_CTL Postgres-XC configurator and operation tool
*
*
* Command line options
*
* -c --configuration file : configuration file. Rerative path
* start at $HOME/.pgxc_ctl or homedir if
* specified by --home option
* --home homedir : home directory of pgxc_ctl. Default is
* $HOME/.pgxc_ctl. You can override this
* with PGXC_CTL_HOME environment or option.
* Command argument has the highest priority.
*
* -v | --verbose: verbose mode. You can set your default in
* pgxc_ctl_rc file at home.
*
* --silent: Opposite to --verbose.
*
* -V | --version: prints out the version
*
* -l | --logdir dir: Log directory. Default is $home/pgxc_log
*
* -L | --logfile file: log file. Default is the timestamp.
* Relative path starts with --logdir.
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <readline/readline.h>
#include <readline/history.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <getopt.h>
#include "config.h"
#include "variables.h"
#include "pgxc_ctl.h"
#include "bash_handler.h"
#include "signature.h"
#include "pgxc_ctl_log.h"
#include "varnames.h"
#include "do_command.h"
#include "utils.h"
/*
* Common global variable
*/
char pgxc_ctl_home[MAXPATH + 1];
char pgxc_ctl_bash_path[MAXPATH + 1];
char pgxc_ctl_config_path[MAXPATH + 1];
char progname[MAXPATH + 1];
char* myName;
char* defaultDatabase;
#define versionString "V1.0 for Postgres-XC 1.1"
FILE* inF;
FILE* outF;
static void build_pgxc_ctl_home(char* home);
static void trim_trailing_slash(char* path);
static void startLog(char* path, char* logFileNam);
static void print_version(void);
static void print_help(void);
static void trim_trailing_slash(char* path)
{
char* curr = path;
char* last = path;
while (*curr) {
last = curr;
curr++;
}
while (last != path) {
if (*last == '/') {
last = 0;
last--;
continue;
} else
return;
}
}
static void build_pgxc_ctl_home(char* home)
{
char* env_pgxc_ctl_home = getenv(PGXC_CTL_HOME);
char* env_home = getenv(HOME); /* We assume this is always available */
if (home) {
if (home[0] == '/') {
/* Absolute path */
strncpy(pgxc_ctl_home, home, MAXPATH);
goto set_bash;
} else {
/* Relative path */
trim_trailing_slash(home);
snprintf(pgxc_ctl_home, MAXPATH, "%s/%s", env_home, home);
goto set_bash;
}
}
if ((env_pgxc_ctl_home = getenv(PGXC_CTL_HOME)) == NULL) {
snprintf(pgxc_ctl_home, MAXPATH, "%s/%s", env_home, pgxc_ctl_home_def);
goto set_bash;
}
if (env_pgxc_ctl_home[0] == '/') /* Absoute path */
{
strncpy(pgxc_ctl_home, env_pgxc_ctl_home, MAXPATH);
goto set_bash;
}
trim_trailing_slash(env_pgxc_ctl_home);
if (env_pgxc_ctl_home[0] == '\0' || env_pgxc_ctl_home[0] == ' ' || env_pgxc_ctl_home[0] == '\t') {
/* Null environment */
snprintf(pgxc_ctl_home, MAXPATH, "%s/%s", env_home, pgxc_ctl_home_def);
goto set_bash;
}
snprintf(pgxc_ctl_home, MAXPATH, "%s/%s", env_home, home);
goto set_bash;
set_bash:
snprintf(pgxc_ctl_bash_path, MAXPATH, "%s/%s", pgxc_ctl_home, PGXC_CTL_BASH);
/*
* Create home dir if necessary and change current directory to it.
*/
{
struct stat buf;
char cmd[MAXLINE + 1];
if (stat(pgxc_ctl_home, &buf) == 0) {
if (S_ISDIR(buf.st_mode)) {
Chdir(pgxc_ctl_home, TRUE);
return;
} else {
fprintf(stderr, "%s is not directory. Check your configurfation\n", pgxc_ctl_home);
exit(1);
}
}
snprintf(cmd, MAXLINE, "mkdir -p %s", pgxc_ctl_home);
system(cmd);
if (stat(pgxc_ctl_home, &buf) == 0) {
if (S_ISDIR(buf.st_mode)) {
Chdir(pgxc_ctl_home, TRUE);
return;
} else {
fprintf(stderr, "Creating %s directory failed. Check your configuration\n", pgxc_ctl_home);
exit(1);
}
}
fprintf(stderr, "Creating directory %s failed. %s\n", pgxc_ctl_home, strerror(errno));
exit(1);
}
return;
}
static void build_configuration_path(char* path)
{
struct stat statbuf;
int rr;
if (path)
reset_var_val(VAR_configFile, path);
if (!find_var(VAR_configFile) || !sval(VAR_configFile) || (sval(VAR_configFile)[0] == 0)) {
/* Default */
snprintf(pgxc_ctl_config_path, MAXPATH, "%s/%s", pgxc_ctl_home, DEFAULT_CONF_FILE_NAME);
rr = stat(pgxc_ctl_config_path, &statbuf);
if (rr || !S_ISREG(statbuf.st_mode)) {
/* No configuration specified and the default does not apply --> simply ignore */
elog(ERROR,
"ERROR: Default configuration file \"%s\" was not found while no configuration file was specified\n",
pgxc_ctl_config_path);
pgxc_ctl_config_path[0] = 0;
return;
}
} else if (sval(VAR_configFile)[0] == '/') {
/* Absolute path */
strncpy(pgxc_ctl_config_path, sval(VAR_configFile), MAXPATH);
} else {
/* Relative path from $pgxc_ctl_home */
snprintf(pgxc_ctl_config_path, MAXPATH, "%s/%s", pgxc_ctl_home, sval(VAR_configFile));
}
rr = stat(pgxc_ctl_config_path, &statbuf);
if (rr || !S_ISREG(statbuf.st_mode)) {
if (rr)
elog(ERROR,
"ERROR: File \"%s\" not found or not a regular file. %s\n",
pgxc_ctl_config_path,
strerror(errno));
else
elog(ERROR, "ERROR: File \"%s\" not found or not a regular file", pgxc_ctl_config_path);
}
return;
}
static void read_configuration(void)
{
FILE* conf = NULL;
char cmd[MAXPATH + 1];
install_pgxc_ctl_bash(pgxc_ctl_bash_path);
if (pgxc_ctl_config_path[0])
snprintf(
cmd, MAXPATH, "%s --home %s --configuration %s", pgxc_ctl_bash_path, pgxc_ctl_home, pgxc_ctl_config_path);
else
snprintf(cmd, MAXPATH, "%s --home %s", pgxc_ctl_bash_path, pgxc_ctl_home);
elog(NOTICE, "Reading configuration using %s\n", cmd);
conf = popen(cmd, "r");
if (conf == NULL) {
elog(ERROR, "ERROR: Cannot execute %s, %s", cmd, strerror(errno));
return;
}
read_vars(conf);
pclose(conf);
uninstall_pgxc_ctl_bash(pgxc_ctl_bash_path);
elog(INFO, "Finished to read configuration.\n");
}
static void prepare_pgxc_ctl_bash(char* path)
{
struct stat buf;
int rc;
rc = stat(path, &buf);
if (rc)
install_pgxc_ctl_bash(path);
else if (S_ISREG(buf.st_mode))
return;
rc = stat(path, &buf);
if (S_ISREG(buf.st_mode))
return;
fprintf(stderr, "Error: caould not install bash script %s\n", path);
exit(1);
}
static void pgxcCtlMkdir(char* path)
{
char cmd[MAXPATH + 1];
snprintf(cmd, MAXPATH, "mkdir -p %s", path);
system(cmd);
}
static void startLog(char* path, char* logFileNam)
{
char logFilePath[MAXPATH + 1];
if (path) {
trim_trailing_slash(path);
pgxcCtlMkdir(path);
if (logFileNam) {
if (logFileNam[0] == '/') {
fprintf(stderr, "ERROR: both --logdir and --logfile are specified and logfile was abosolute path.\n");
exit(1);
}
if (path[0] == '/')
snprintf(logFilePath, MAXPATH, "%s/%s", path, logFileNam);
else
snprintf(logFilePath, MAXPATH, "%s/%s/%s", pgxc_ctl_home, path, logFileNam);
initLog(NULL, logFilePath);
} else {
if (path[0] == '/')
initLog(path, NULL);
else {
snprintf(logFilePath, MAXPATH, "%s/%s", pgxc_ctl_home, path);
initLog(logFilePath, NULL);
}
}
} else {
if (logFileNam && logFileNam[0] == '/') {
/* This is used as log file path */
initLog(NULL, logFileNam);
return;
} else {
snprintf(logFilePath, MAXPATH, "%s/pgxc_log", pgxc_ctl_home);
pgxcCtlMkdir(logFilePath);
initLog(logFilePath, NULL);
}
}
return;
}
static void setDefaultIfNeeded(char* name, char* val)
{
if (!find_var(name) || !sval(name)) {
if (val)
reset_var_val(name, val);
else
reset_var(name);
}
}
static void setup_my_env(void)
{
char path[MAXPATH + 1];
char* home = NULL;
FILE* ini_env = NULL;
char* selectVarList[] = {VAR_pgxc_ctl_home,
VAR_xc_prompt,
VAR_verbose,
VAR_logDir,
VAR_logFile,
VAR_tmpDir,
VAR_localTmpDir,
VAR_configFile,
VAR_echoAll,
VAR_debug,
VAR_printMessage,
VAR_logMessage,
VAR_defaultDatabase,
VAR_pgxcCtlName,
VAR_printLocation,
VAR_logLocation,
NULL};
ini_env = fopen("/etc/pgxc_ctl", "r");
if (ini_env) {
read_selected_vars(ini_env, selectVarList);
fclose(ini_env);
}
if ((home = getenv("HOME"))) {
snprintf(path, MAXPATH, "%s/.pgxc_ctl", getenv("HOME"));
if ((ini_env = fopen(path, "r"))) {
read_selected_vars(ini_env, selectVarList);
fclose(ini_env);
}
}
/*
* Setup defaults
*/
snprintf(path, MAXPATH, "%s/pgxc_ctl", getenv("HOME"));
setDefaultIfNeeded(VAR_pgxc_ctl_home, path);
setDefaultIfNeeded(VAR_xc_prompt, "PGXC ");
snprintf(path, MAXPATH, "%s/pgxc_ctl/pgxc_log", getenv("HOME"));
setDefaultIfNeeded(VAR_logDir, path);
setDefaultIfNeeded(VAR_logFile, NULL);
setDefaultIfNeeded(VAR_tmpDir, "/tmp");
setDefaultIfNeeded(VAR_localTmpDir, "/tmp");
setDefaultIfNeeded(VAR_configFile, "pgxc_ctl.conf");
setDefaultIfNeeded(VAR_echoAll, "n");
setDefaultIfNeeded(VAR_debug, "n");
setDefaultIfNeeded(VAR_printMessage, "info");
setDefaultIfNeeded(VAR_logMessage, "info");
setDefaultIfNeeded(VAR_pgxcCtlName, DefaultName);
myName = Strdup(sval(VAR_pgxcCtlName));
setDefaultIfNeeded(VAR_defaultDatabase, DefaultDatabase);
defaultDatabase = Strdup(sval(VAR_defaultDatabase));
setDefaultIfNeeded(VAR_printLocation, "n");
setDefaultIfNeeded(VAR_logLocation, "n");
}
int main(int argc, char* argv[])
{
char* configuration = NULL;
char* infile = NULL;
char* outfile = NULL;
char* verbose = NULL;
int version_opt = 0;
char* logdir = NULL;
char* logfile = NULL;
char* home = NULL;
int help_opt = 0;
int c;
static struct option long_options[] = {{"configuration", required_argument, 0, 'c'},
{"silent", no_argument, 0, 1},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
{"logdir", required_argument, 0, 'l'},
{"logfile", required_argument, 0, 'L'},
{"home", required_argument, 0, 2},
{"infile", required_argument, 0, 'i'},
{"outfile", required_argument, 0, 'o'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}};
strcpy(progname, argv[0]);
init_var_hash();
while (1) {
int option_index = 0;
c = getopt_long(argc, argv, "i:o:c:vVl:L:h", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 1:
verbose = "n";
break;
case 2:
if (home)
free(home);
home = strdup(optarg);
if (home == NULL) {
fprintf(stderr, "out of memory\n");
exit(1);
}
break;
case 'i':
if (infile)
free(infile);
infile = strdup(optarg);
if (infile == NULL) {
fprintf(stderr, "out of memory\n");
exit(1);
}
break;
case 'o':
if (outfile)
free(outfile);
outfile = strdup(optarg);
if (outfile == NULL) {
fprintf(stderr, "out of memory\n");
exit(1);
}
break;
case 'v':
verbose = "y";
break;
case 'V':
version_opt = 1;
break;
case 'l':
if (logdir)
free(logdir);
logdir = strdup(optarg);
if (logdir == NULL) {
fprintf(stderr, "out of memory\n");
exit(1);
}
break;
case 'L':
if (logfile)
free(logfile);
logfile = strdup(optarg);
if (logfile == NULL) {
fprintf(stderr, "out of memory\n");
exit(1);
}
break;
case 'c':
if (configuration)
free(configuration);
configuration = strdup(optarg);
if (configuration == NULL) {
fprintf(stderr, "out of memory\n");
exit(1);
}
break;
case 'h':
help_opt = 1;
break;
default:
fprintf(stderr, "Invalid optin value, received code 0%o\n", c);
exit(1);
}
}
if (version_opt || help_opt) {
if (version_opt)
print_version();
if (help_opt)
print_help();
exit(0);
}
setup_my_env(); /* Read $HOME/.pgxc_ctl */
build_pgxc_ctl_home(home);
if (infile)
reset_var_val(VAR_configFile, infile);
if (logdir)
reset_var_val(VAR_logDir, logdir);
if (logfile)
reset_var_val(VAR_logFile, logfile);
startLog(sval(VAR_logDir), sval(VAR_logFile));
prepare_pgxc_ctl_bash(pgxc_ctl_bash_path);
build_configuration_path(configuration);
read_configuration();
check_configuration();
/*
* Setop output
*/
if (outfile) {
elog(INFO, "Output file: %s\n", outfile);
if ((outF = fopen(outfile, "w")))
dup2(fileno(outF), 2);
else
elog(ERROR, "ERROR: Cannot open output file %s, %s\n", outfile, strerror(errno));
} else
outF = stdout;
/*
* Startup Message
*/
elog(NOTICE, " ******** PGXC_CTL START ***************\n\n");
elog(NOTICE, "Current directory: %s\n", pgxc_ctl_home);
/*
* Setup input
*/
if (infile) {
elog(INFO, "Input file: %s\n", infile);
inF = fopen(infile, "r");
if (inF == NULL) {
elog(ERROR, "ERROR: Cannot open input file %s, %s\n", infile, strerror(errno));
exit(1);
}
} else
inF = stdin;
/*
* If we have remaing arguments, they will be treated as a command to do. Do this
* first, then handle the input from input file specified by -i option.
* If it is not found, then exit.
*/
if (optind < argc) {
char orgBuf[MAXLINE + 1];
char wkBuf[MAXLINE + 1];
orgBuf[0] = 0;
while (optind < argc) {
strncat(orgBuf, argv[optind++], MAXLINE);
strncat(orgBuf, " ", MAXLINE);
}
strncpy(wkBuf, orgBuf, MAXLINE);
do_singleLine(orgBuf, wkBuf);
if (infile)
do_command(inF, outF);
} else
do_command(inF, outF);
exit(0);
}
static void print_version(void)
{
printf("Pgxc_ctl %s\n", versionString);
}
static void print_help(void)
{
printf("pgxc_ctl [option ...] [command]\n"
"option:\n"
" -c or --configuration conf_file: Specify configruration file.\n"
" -v or --verbose: Specify verbose output.\n"
" -V or --version: Print version and exit.\n"
" -l or --logdir log_directory: specifies what directory to write logs.\n"
" -L or --logfile log_file: Specifies log file.\n"
" --home home_direcotry: Specifies pgxc_ctl work director.\n"
" -i or --infile input_file: Specifies inptut file.\n"
" -o or --outfile output_file: Specifies output file.\n"
" -h or --help: Prints this message and exits.\n"
"For more deatils, refer to pgxc_ctl reference manual included in\n"
"postgres-xc reference manual.\n");
}
| 30.390071 | 118 | 0.54259 | wotchin |
429b86ff698811c8243208791f035dc1c010f667 | 25,105 | cpp | C++ | platform/mt6592/hardware/m4u/m4u_lib.cpp | touxiong88/92_mediatek | 5e96a7bb778fd9d9b335825584664e0c8b5ff2c7 | [
"Apache-2.0"
] | 1 | 2022-01-07T01:53:19.000Z | 2022-01-07T01:53:19.000Z | platform/mt6592/hardware/m4u/m4u_lib.cpp | touxiong88/92_mediatek | 5e96a7bb778fd9d9b335825584664e0c8b5ff2c7 | [
"Apache-2.0"
] | null | null | null | platform/mt6592/hardware/m4u/m4u_lib.cpp | touxiong88/92_mediatek | 5e96a7bb778fd9d9b335825584664e0c8b5ff2c7 | [
"Apache-2.0"
] | 1 | 2020-02-28T02:48:42.000Z | 2020-02-28T02:48:42.000Z | /* Copyright Statement:
*
* This software/firmware and related documentation ("MediaTek Software") are
* protected under relevant copyright laws. The information contained herein
* is confidential and proprietary to MediaTek Inc. and/or its licensors.
* Without the prior written permission of MediaTek inc. and/or its licensors,
* any reproduction, modification, use or disclosure of MediaTek Software,
* and information contained herein, in whole or in part, shall be strictly prohibited.
*
* MediaTek Inc. (C) 2010. All rights reserved.
*
* BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
* THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
* CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
* SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
* STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
* CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
* The following software/firmware and/or related documentation ("MediaTek Software")
* have been modified by MediaTek Inc. All revisions are subject to any receiver's
* applicable license agreements with MediaTek Inc.
*/
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <fcntl.h>
#include <cutils/log.h>
#include "m4u_lib.h"
#include <string.h>
#include <errno.h>
#undef LOG_TAG
#define LOG_TAG "M4U_L"
#define MTKM4UMSG
#ifdef MTKM4UMSG
#define M4UMSG(...) \
do { \
ALOGE(__VA_ARGS__); \
} while (0)
#else
#define M4UMSG(...)
#endif
#define __M4U_WRAP_LAYER_EN__
#ifdef __M4U_WRAP_LAYER_EN__
bool m4u_en[M4U_CLNTMOD_MAX] = {false};
#endif
//#define __DUMP_BACKTRACE_ON_ERROR__
#ifdef __DUMP_BACKTRACE_ON_ERROR__
extern "C" void rtt_dump_caller_backtrace(const char* tag);
extern "C" int rtt_dump_backtrace(pid_t pid, pid_t tid, const char* file_path);
static void m4u_dump_backtrace(void)
{
char name[35] = "/data/m4u_dump";
//sprintf(name, "/data/m4u_dump_%d_%d.txt", getpid(), gettid());
M4UMSG("m4u dump back trace when error============> \n");
rtt_dump_backtrace(getpid(), gettid(), name);
FILE *fp = fopen(name, "r");
if(fp)
{
char tmp[101] = "";
int cnt=0;
while( (fgets(tmp, 100, fp) != NULL) && (cnt<500) )
{
cnt++;
M4UMSG("[%d]: %s", cnt, tmp);
}
fclose(fp);
}
//unlink(name);
}
#else
static void m4u_dump_backtrace(void)
{
}
#endif
/******************************************************************************
*
*******************************************************************************/
MTKM4UDrv::MTKM4UDrv(void)
{
mFileDescriptor = -1;
mFileDescriptor = open("/dev/M4U_device", O_RDONLY);
if(mFileDescriptor<0)
{
M4UMSG("Open file failed mFileDescriptor=%d, error=%d :%s", mFileDescriptor, errno, strerror(errno));
m4u_dump_backtrace();
}
else
{
if(ioctl(mFileDescriptor, MTK_M4U_T_M4UDrv_CONSTRUCT, NULL))
{
M4UMSG(" ioctl MTK_M4U_T_M4UDrv_CONSTRUCT fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
}
}
}
MTKM4UDrv::~MTKM4UDrv(void)
{
if(-1!=mFileDescriptor)
{
if(ioctl(mFileDescriptor, MTK_M4U_T_M4UDrv_DECONSTRUCT, NULL))
{
M4UMSG(" ioctl MTK_M4U_T_M4UDrv_DECONSTRUCT fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
}
close(mFileDescriptor);
}
mFileDescriptor = -1;
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_power_on(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_power_on failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_POWER_ON, &eModuleID))
{
M4UMSG(" ioctl MTK_M4U_T_POWER_ON fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_power_off(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_power_off failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_POWER_OFF, &eModuleID))
{
M4UMSG(" ioctl MTK_M4U_T_POWER_OFF fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_alloc_mva(M4U_MODULE_ID_ENUM eModuleID,
const unsigned int BufAddr,
const unsigned int BufSize,
int security,
int cache_coherent,
unsigned int *pRetMVAAddr)
{
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.BufAddr = BufAddr;
m4u_module.BufSize = BufSize;
m4u_module.security = security;
m4u_module.cache_coherent = cache_coherent;
if(!m4u_check_m4u_en(eModuleID))
{
//just work around, tell kernel it's pmem, and use wrap layer!!
m4u_module.MVAStart = -1;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_alloc_mva failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_ALLOC_MVA, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_ALLOC_MVA fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
*pRetMVAAddr = m4u_module.MVAStart;
return M4U_STATUS_OK;
}
return M4U_STATUS_OK;
}
else
{
m4u_module.MVAStart = 0;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_alloc_mva failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_ALLOC_MVA, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_ALLOC_MVA fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
*pRetMVAAddr = m4u_module.MVAStart;
return M4U_STATUS_OK;
}
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_query_mva(M4U_MODULE_ID_ENUM eModuleID,
const unsigned int BufAddr,
const unsigned int BufSize,
unsigned int *pRetMVAAddr)
{
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.BufAddr = BufAddr;
m4u_module.BufSize = BufSize;
*pRetMVAAddr = 0;
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_query_mva failed \n");
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_QUERY_MVA, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_QUERY_MVA fail! %d, %s \n", errno, strerror(errno));
return M4U_STATUS_KERNEL_FAULT;
}
else
{
*pRetMVAAddr = m4u_module.MVAStart;
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_dealloc_mva(M4U_MODULE_ID_ENUM eModuleID,
const unsigned int BufAddr,
const unsigned int BufSize,
const unsigned int MVAStart)
{
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.BufAddr = BufAddr;
m4u_module.BufSize = BufSize;
m4u_module.MVAStart = MVAStart;
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_dealloc_mva failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_DEALLOC_MVA, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_DEALLOC_MVA fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_insert_wrapped_range(M4U_MODULE_ID_ENUM eModuleID,
M4U_PORT_ID_ENUM portID,
const unsigned int MVAStart,
const unsigned int MVAEnd)
{
M4U_WRAP_DES_T m4u_wrap;
m4u_wrap.eModuleID = eModuleID;
m4u_wrap.ePortID = portID;
m4u_wrap.MVAStart = MVAStart;
m4u_wrap.MVAEnd = MVAEnd;
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_insert_wrapped_range failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_INSERT_TLB_RANGE, &m4u_wrap))
{
M4UMSG(" ioctl MTK_M4U_T_INSERT_TLB_RANGE fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_insert_tlb_range(M4U_MODULE_ID_ENUM eModuleID,
unsigned int MVAStart,
const unsigned int MVAEnd,
M4U_RANGE_PRIORITY_ENUM ePriority,
unsigned int entryCount)
{
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.MVAStart = MVAStart;
m4u_module.MVAEnd = MVAEnd;
m4u_module.ePriority = ePriority;
m4u_module.entryCount = entryCount;
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_insert_tlb_range failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_INSERT_TLB_RANGE, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_INSERT_TLB_RANGE fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_invalid_tlb_range(M4U_MODULE_ID_ENUM eModuleID,
unsigned int MVAStart,
unsigned int MVAEnd)
{
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.MVAStart = MVAStart;
m4u_module.MVAEnd = MVAEnd;
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_invalid_tlb_range failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_INVALID_TLB_RANGE, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_INVALID_TLB_RANGE fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_invalid_tlb_all(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_invalid_tlb_all failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_INVALID_TLB_ALL, &eModuleID))
{
M4UMSG(" ioctl MTK_M4U_T_INVALID_TLB_ALL fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_manual_insert_entry(M4U_MODULE_ID_ENUM eModuleID,
unsigned int EntryMVA,
bool Lock)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
M4U_MOUDLE_STRUCT m4u_module;
if(0)
{
m4u_module.eModuleID = eModuleID;
m4u_module.EntryMVA = EntryMVA;
m4u_module.Lock = Lock;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_insert_entry failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_MANUAL_INSERT_ENTRY, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_MANUAL_INSERT_ENTRY fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
else
{
return M4U_STATUS_OK;
}
}
static M4U_MODULE_ID_ENUM m4u_get_module_by_port(M4U_PORT_ID_ENUM portID)
{
return portID;
}
///> native
M4U_STATUS_ENUM MTKM4UDrv::m4u_config_port(M4U_PORT_STRUCT* pM4uPort)
{
M4U_MODULE_ID_ENUM eModuleID = m4u_get_module_by_port(pM4uPort->ePortID);
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(NULL==pM4uPort)
{
M4UMSG("m4u_config_port failed, input M4U_PORT_STRUCT* is null! \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(mFileDescriptor<0)
{
M4UMSG("m4u_config_port failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_CONFIG_PORT, pM4uPort))
{
M4UMSG(" ioctl MTK_M4U_T_CONFIG_PORT fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_config_port_rotator(M4U_PORT_STRUCT_ROTATOR* pM4uPort)
{
M4U_MODULE_ID_ENUM eModuleID = m4u_get_module_by_port(pM4uPort->ePortID);
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(NULL==pM4uPort)
{
M4UMSG("m4u_config_port_rotator failed, input M4U_PORT_STRUCT_ROTATOR* is null! \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(mFileDescriptor<0)
{
M4UMSG("m4u_config_port_rotator failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_CONFIG_PORT_ROTATOR, pM4uPort))
{
M4UMSG(" ioctl MTK_M4U_T_CONFIG_PORT_ROTATOR fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_reset_mva_release_tlb(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_reset_mva_release_tlb failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_RESET_MVA_RELEASE_TLB, &eModuleID))
{
M4UMSG(" ioctl MTK_M4U_T_RESET_MVA_RELEASE_TLB fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
///> ------------------- helper function -----------------------------------------------------
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_monitor_start(M4U_PORT_ID_ENUM PortID)
{
M4U_MODULE_ID_ENUM eModuleID = m4u_get_module_by_port(PortID);
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_monitor_start failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_MONITOR_START, &PortID))
{
M4UMSG(" ioctl MTK_M4U_T_MONITOR_START fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_monitor_stop(M4U_PORT_ID_ENUM PortID)
{
M4U_MODULE_ID_ENUM eModuleID = m4u_get_module_by_port(PortID);
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_monitor_stop failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_MONITOR_STOP, &PortID))
{
M4UMSG(" ioctl MTK_M4U_T_MONITOR_STOP fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_dump_reg(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_dump_reg failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
//M4UMSG("before m4u_dump_reg, module=%d", eModuleID);
if(ioctl(mFileDescriptor, MTK_M4U_T_DUMP_REG, &eModuleID))
{
M4UMSG(" ioctl MTK_M4U_T_DUMP_REG fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
//M4UMSG("after m4u_dump_reg, module=%d", eModuleID);
return M4U_STATUS_OK;
}
}
/**
* @brief :
* @param
* @return
*/
M4U_STATUS_ENUM MTKM4UDrv::m4u_dump_info(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_dump_info failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_DUMP_INFO, &eModuleID))
{
M4UMSG(" ioctl MTK_M4U_T_DUMP_INFO fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_cache_sync(M4U_MODULE_ID_ENUM eModuleID,
M4U_CACHE_SYNC_ENUM eCacheSync,
unsigned int BufAddr,
unsigned int BufSize)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
M4U_CACHE_STRUCT m4u_cache;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_cache_sync failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
m4u_cache.eModuleID = eModuleID;
m4u_cache.eCacheSync = eCacheSync;
m4u_cache.BufAddr = BufAddr;
m4u_cache.BufSize = BufSize;
if(ioctl(mFileDescriptor, MTK_M4U_T_CACHE_SYNC, &m4u_cache))
{
M4UMSG(" ioctl MTK_M4U_T_CACHE_SYNC fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_dump_pagetable(M4U_MODULE_ID_ENUM eModuleID,
const unsigned int BufAddr,
const unsigned int BufSize,
unsigned int MVAStart)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.BufAddr = BufAddr;
m4u_module.BufSize = BufSize;
m4u_module.MVAStart = MVAStart;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_dump_pagetable failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_DUMP_PAGETABLE, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_DUMP_PAGETABLE fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_register_buffer(M4U_MODULE_ID_ENUM eModuleID,
const unsigned int BufAddr,
const unsigned int BufSize,
int security,
int cache_coherent,
unsigned int *pRetMVAAddr)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
M4U_MOUDLE_STRUCT m4u_module;
m4u_module.eModuleID = eModuleID;
m4u_module.BufAddr = BufAddr;
m4u_module.BufSize = BufSize;
m4u_module.security = security;
m4u_module.cache_coherent = cache_coherent;
if(mFileDescriptor<0 )
{
M4UMSG("m4u_register_buffer failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_REGISTER_BUFFER, &m4u_module))
{
M4UMSG(" ioctl MTK_M4U_T_REGISTER_BUFFER fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
*pRetMVAAddr = 0;
return M4U_STATUS_OK;
}
}
M4U_STATUS_ENUM MTKM4UDrv::m4u_cache_flush_all(M4U_MODULE_ID_ENUM eModuleID)
{
if(!m4u_check_m4u_en(eModuleID))
{
return M4U_STATUS_OK;
}
if(mFileDescriptor<0 )
{
M4UMSG("m4u_cache_sync failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
if(ioctl(mFileDescriptor, MTK_M4U_T_CACHE_FLUSH_ALL, NULL))
{
M4UMSG(" ioctl MTK_M4U_T_CACHE_FLUSH_ALL fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return M4U_STATUS_OK;
}
}
unsigned int MTKM4UDrv::m4u_set_reg(unsigned int addr, unsigned int val)
{
if(mFileDescriptor<0 )
{
M4UMSG("m4u_reset_mva_release_tlb failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
unsigned int para[2];
para[0] = addr;
para[1] = val;
if(ioctl(mFileDescriptor, MTK_M4U_T_REG_SET, ¶))
{
M4UMSG(" ioctl MTK_M4U_T_RESET_MVA_RELEASE_TLB fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return val;
}
}
unsigned int MTKM4UDrv::m4u_get_reg(unsigned int addr)
{
if(mFileDescriptor<0 )
{
M4UMSG("m4u_reset_mva_release_tlb failed \n");
m4u_dump_backtrace();
return M4U_STATUS_INVALID_HANDLE;
}
unsigned int para[2];
para[0] = addr;
if(ioctl(mFileDescriptor, MTK_M4U_T_REG_GET, ¶))
{
M4UMSG(" ioctl MTK_M4U_T_RESET_MVA_RELEASE_TLB fail! %d, %s \n", errno, strerror(errno));
m4u_dump_backtrace();
return M4U_STATUS_KERNEL_FAULT;
}
else
{
return para[1];
}
}
#ifdef __PMEM_WRAP_LAYER_EN__
bool MTKM4UDrv::mUseM4U[M4U_CLNTMOD_MAX] = {false};
bool MTKM4UDrv::m4u_enable_m4u_func(M4U_MODULE_ID_ENUM eModuleID)
{
bool ret = mUseM4U[eModuleID];
mUseM4U[eModuleID] = true;
return ret;
}
bool MTKM4UDrv::m4u_disable_m4u_func(M4U_MODULE_ID_ENUM eModuleID)
{
bool ret = mUseM4U[eModuleID];
mUseM4U[eModuleID] = false;
return ret;
}
bool MTKM4UDrv::m4u_print_m4u_enable_status()
{
for(int i=0; i<M4U_CLNTMOD_MAX; i++)
{
M4UMSG("module(%d)\t:\t%d\n", i, mUseM4U[i]);
}
return true;
}
bool MTKM4UDrv::m4u_check_m4u_en(M4U_MODULE_ID_ENUM eModuleID)
{
if(!mUseM4U[eModuleID])
{
M4UMSG("warning: call m4u function but didnot enable m4u function. ID: %d\n", eModuleID);
}
return mUseM4U[eModuleID];
}
#endif
| 25.155311 | 109 | 0.631468 | touxiong88 |
429fb6796277573e93d2ffe4dd5fdc517d115921 | 279 | cpp | C++ | src/utilities/utilities.cpp | softwarecapital/geometry-central | b4743b4662018d8fa483b31ff4a3af5699db3e93 | [
"MIT"
] | 539 | 2018-02-19T16:38:26.000Z | 2022-03-31T06:56:22.000Z | src/utilities/utilities.cpp | softwarecapital/geometry-central | b4743b4662018d8fa483b31ff4a3af5699db3e93 | [
"MIT"
] | 88 | 2018-11-30T13:19:35.000Z | 2022-03-23T18:40:33.000Z | src/utilities/utilities.cpp | softwarecapital/geometry-central | b4743b4662018d8fa483b31ff4a3af5699db3e93 | [
"MIT"
] | 74 | 2018-05-12T17:57:04.000Z | 2022-03-21T15:01:26.000Z | #include <geometrycentral/utilities/utilities.h>
namespace geometrycentral {
std::random_device util_random_device;
std::mt19937 util_mersenne_twister(util_random_device());
// std::mt19937 util_mersenne_twister(0); // uncomment for determinism
} // namespace geometrycentral
| 27.9 | 70 | 0.81362 | softwarecapital |
42a380fa59cc68005ee814d9122db6475cdc93b0 | 3,794 | cc | C++ | release/src/router/aria2-1.18.1/src/DHTGetPeersMessage.cc | ghsecuritylab/bcwifi | 4cd7a6989921930f39816583014728b9f07a09a3 | [
"FSFAP"
] | 18 | 2015-12-08T17:31:49.000Z | 2022-03-21T19:02:11.000Z | release/src/router/aria2-1.18.1/src/DHTGetPeersMessage.cc | ghsecuritylab/bcwifi | 4cd7a6989921930f39816583014728b9f07a09a3 | [
"FSFAP"
] | null | null | null | release/src/router/aria2-1.18.1/src/DHTGetPeersMessage.cc | ghsecuritylab/bcwifi | 4cd7a6989921930f39816583014728b9f07a09a3 | [
"FSFAP"
] | 8 | 2015-07-12T14:37:46.000Z | 2019-03-05T10:07:33.000Z | /* <!-- copyright */
/*
* aria2 - The high speed download utility
*
* Copyright (C) 2006 Tatsuhiro Tsujikawa
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* In addition, 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 two.
* You must obey the GNU General Public License in all respects
* for all of the code used other than OpenSSL. 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 here.
*/
/* copyright --> */
#include "DHTGetPeersMessage.h"
#include <cstring>
#include "DHTNode.h"
#include "DHTRoutingTable.h"
#include "DHTMessageFactory.h"
#include "DHTMessageDispatcher.h"
#include "DHTMessageCallback.h"
#include "DHTPeerAnnounceStorage.h"
#include "Peer.h"
#include "DHTTokenTracker.h"
#include "DHTGetPeersReplyMessage.h"
#include "util.h"
namespace aria2 {
const std::string DHTGetPeersMessage::GET_PEERS("get_peers");
const std::string DHTGetPeersMessage::INFO_HASH("info_hash");
DHTGetPeersMessage::DHTGetPeersMessage
(const std::shared_ptr<DHTNode>& localNode,
const std::shared_ptr<DHTNode>& remoteNode,
const unsigned char* infoHash,
const std::string& transactionID)
: DHTQueryMessage{localNode, remoteNode, transactionID},
peerAnnounceStorage_{nullptr},
tokenTracker_{nullptr}
{
memcpy(infoHash_, infoHash, DHT_ID_LENGTH);
}
void DHTGetPeersMessage::doReceivedAction()
{
std::string token = tokenTracker_->generateToken
(infoHash_, getRemoteNode()->getIPAddress(), getRemoteNode()->getPort());
// Check to see localhost has the contents which has same infohash
std::vector<std::shared_ptr<Peer>> peers;
peerAnnounceStorage_->getPeers(peers, infoHash_);
std::vector<std::shared_ptr<DHTNode>> nodes;
getRoutingTable()->getClosestKNodes(nodes, infoHash_);
getMessageDispatcher()->addMessageToQueue
(getMessageFactory()->createGetPeersReplyMessage
(getRemoteNode(), std::move(nodes), std::move(peers), token,
getTransactionID()));
}
std::unique_ptr<Dict> DHTGetPeersMessage::getArgument()
{
auto aDict = Dict::g();
aDict->put(DHTMessage::ID, String::g(getLocalNode()->getID(), DHT_ID_LENGTH));
aDict->put(INFO_HASH, String::g(infoHash_, DHT_ID_LENGTH));
return aDict;
}
const std::string& DHTGetPeersMessage::getMessageType() const
{
return GET_PEERS;
}
void DHTGetPeersMessage::setPeerAnnounceStorage(DHTPeerAnnounceStorage* storage)
{
peerAnnounceStorage_ = storage;
}
void DHTGetPeersMessage::setTokenTracker(DHTTokenTracker* tokenTracker)
{
tokenTracker_ = tokenTracker;
}
std::string DHTGetPeersMessage::toStringOptional() const
{
return "info_hash="+util::toHex(infoHash_, INFO_HASH_LENGTH);
}
} // namespace aria2
| 33.875 | 80 | 0.756194 | ghsecuritylab |
42a874139c83963dcdf592be1b2162e2482cc6ad | 549 | hpp | C++ | src/InputSystem.DirectInput/PrerequisitesDirectInput.hpp | bis83/pomdog | 133a9262958d539ae6d93664e6cb2207b5b6c7ff | [
"MIT"
] | null | null | null | src/InputSystem.DirectInput/PrerequisitesDirectInput.hpp | bis83/pomdog | 133a9262958d539ae6d93664e6cb2207b5b6c7ff | [
"MIT"
] | null | null | null | src/InputSystem.DirectInput/PrerequisitesDirectInput.hpp | bis83/pomdog | 133a9262958d539ae6d93664e6cb2207b5b6c7ff | [
"MIT"
] | null | null | null | // Copyright (c) 2013-2015 mogemimi.
// Distributed under the MIT license. See LICENSE.md file for details.
#ifndef POMDOG_PREREQUISITESDIRECTINPUT_98459263_HPP
#define POMDOG_PREREQUISITESDIRECTINPUT_98459263_HPP
#include "Pomdog/Platform/Win32/PrerequisitesWin32.hpp"
#ifndef DIRECTINPUT_VERSION
# ifdef DIRECTINPUT_HEADER_VERSION
# define DIRECTINPUT_VERSION DIRECTINPUT_HEADER_VERSION
# else
# define DIRECTINPUT_VERSION 0x0800
# endif
#endif
#include <dinput.h>
#endif // POMDOG_PREREQUISITESDIRECTINPUT_98459263_HPP
| 28.894737 | 70 | 0.806922 | bis83 |
42b528f5b0237210b934945b21c372a93b872d34 | 3,544 | hpp | C++ | graph/dfs.hpp | linqingwudiv1/cxx14-graph | 11aaa360738f9b40c1994dfede831485f16b9de1 | [
"MIT"
] | 37 | 2016-10-06T12:54:20.000Z | 2022-03-04T08:26:30.000Z | graph/dfs.hpp | crysisfarcry222/cxx14-graph | 5f1866883cb4c048f57c858a25a4ead88b90cb90 | [
"MIT"
] | null | null | null | graph/dfs.hpp | crysisfarcry222/cxx14-graph | 5f1866883cb4c048f57c858a25a4ead88b90cb90 | [
"MIT"
] | 7 | 2017-02-20T16:23:55.000Z | 2022-02-14T07:26:38.000Z | // Copyright (c) 2016 Andrew Sutton
// All rights reserved
#ifndef GRAPH_DFS_HPP
#define GRAPH_DFS_HPP
#include "common.hpp"
namespace origin {
// A basic DFS implementation for directed graphs.
template<typename G>
struct directed_dfs
{
directed_dfs(G& g)
: graph(g),
colors(graph.num_vertices(), 0),
pre_times(graph.num_vertices(), -1),
post_times(graph.num_vertices(), -1),
parents(graph.num_vertices()),
clock(0)
{ }
void operator()()
{
auto color = vertex_label(colors);
auto pre = vertex_label(pre_times);
auto post = vertex_label(post_times);
auto parent = vertex_label(parents);
// Extra initialization.
for (vertex_t v : graph.vertices())
parent(v) = v;
search(color, pre, post, parent);
}
template<typename L1, typename L2>
void search(L1 color, L1 pre, L1 post, L2 parent)
{
for (vertex_t v : graph.vertices()) {
if (color(v) == 0)
explore(v, color, pre, post, parent);
}
}
template<typename L1, typename L2>
void explore(vertex_t u, L1 color, L1 pre, L1 post, L2 parent)
{
color(u) = 1; // color u gray (on stack)
pre(u) = clock++;
for (edge_t e : graph.out_edges(u)) {
vertex_t v = graph.target(e);
if (color(v) == 0) {
// (u, v) is a tree edge
parent(v) = u;
explore(v, color, pre, post, parent);
}
else if (color(v) == 1) {
// (u, v) is a back edge
}
else {
// (u, v) is a cross or forward edge
}
}
post(u) = clock++;
color(u) = 2; // color u black (done).
}
G& graph;
std::vector<int> colors;
std::vector<int> pre_times;
std::vector<int> post_times;
std::vector<vertex_t> parents;
int clock;
};
// A basic DFS implementation for undirected graphs.
//
// TODO: If undirected graphs don't have forward or cross edges, then
// what's the purpose of maintaining an extra state in order to recover
// that information? Consider reducing colors to a simple
template<typename G>
struct undirected_dfs
{
undirected_dfs(G& g)
: graph(g),
colors(graph.num_vertices(), 0),
pre_times(graph.num_vertices(), -1),
post_times(graph.num_vertices(), -1),
parents(graph.num_vertices()),
clock(0)
{ }
void operator()()
{
auto color = vertex_label(colors);
auto pre = vertex_label(pre_times);
auto post = vertex_label(post_times);
auto parent = vertex_label(parents);
// Extra initialization.
for (vertex_t v : graph.vertices())
parent(v) = v;
search(color, pre, post, parent);
}
template<typename L1, typename L2>
void search(L1 color, L1 pre, L1 post, L2 parent)
{
for (vertex_t v : graph.vertices()) {
if (color(v) == 0)
explore(v, color, pre, post, parent);
}
}
template<typename L1, typename L2>
void explore(vertex_t u, L1 color, L1 pre, L1 post, L2 parent)
{
color(u) = 1; // color u gray (on stack)
pre(u) = clock++;
for (edge_t e : graph.edges(u)) {
vertex_t v = graph.opposite(e, u);
if (color(v) == 0) {
// (u, v) is a tree edge
parent(v) = u;
explore(v, color, pre, post, parent);
}
else {
// (u, v) is a back edge
}
}
post(u) = clock++;
color(u) = 2; // color u black (done)
}
G& graph;
std::vector<int> colors;
std::vector<int> pre_times;
std::vector<int> post_times;
std::vector<vertex_t> parents;
int clock;
};
} // namespace origin
#endif
| 22.573248 | 71 | 0.593115 | linqingwudiv1 |
42b76cd3045a32292e36e2da56826dda7b1f03c3 | 177 | cpp | C++ | c++/1073.cpp | RitamDey/My-Simple-Programs | 147b455a6a40c371ec894ce979e8a61d242e03bd | [
"Unlicense"
] | 2 | 2016-10-14T16:58:05.000Z | 2017-05-04T04:59:18.000Z | c++/1073.cpp | GreenJoey/My-Simple-Programs | 147b455a6a40c371ec894ce979e8a61d242e03bd | [
"Unlicense"
] | null | null | null | c++/1073.cpp | GreenJoey/My-Simple-Programs | 147b455a6a40c371ec894ce979e8a61d242e03bd | [
"Unlicense"
] | null | null | null | #include <iostream>
using namespace std;
int main(int argc, char const *argv[]) {
int num;
cin>>num;
for(int a=2;a<=num;a+=2)
cout<<a<<"^"<<a<<pow(a,2);
return 0;
}
| 16.090909 | 40 | 0.581921 | RitamDey |
42b88474883c49269c9e32a5acef06297f4b5bf7 | 3,676 | cpp | C++ | src/sound.cpp | bsegovia/cube | 3442b7f62feeda67a66648d2aca8644f39b9ff03 | [
"Cube",
"Zlib"
] | 18 | 2015-12-01T23:52:21.000Z | 2021-11-27T18:15:28.000Z | src/sound.cpp | bsegovia/cube | 3442b7f62feeda67a66648d2aca8644f39b9ff03 | [
"Cube",
"Zlib"
] | null | null | null | src/sound.cpp | bsegovia/cube | 3442b7f62feeda67a66648d2aca8644f39b9ff03 | [
"Cube",
"Zlib"
] | 6 | 2015-09-22T13:26:47.000Z | 2021-11-04T12:44:43.000Z | #include "cube.h"
#include "SDL/SDL_mixer.h"
#define MAXCHAN 32
#define SOUNDFREQ 22050
#define MAXVOL MIX_MAX_VOLUME
namespace sound
{
VARP(soundvol, 0, 255, 255);
VARP(musicvol, 0, 128, 255);
VAR(soundbufferlen, 128, 1024, 4096);
VAR(stereo, 0, 1, 1);
static bool nosound = false;
static Mix_Music *mod = NULL;
static void *stream = NULL;
static vector<Mix_Chunk *> samples;
static cvector snames;
static int soundsatonce = 0, lastsoundmillis = 0;
struct soundloc { vec loc; bool inuse; } soundlocs[MAXCHAN];
void sound_stop(void)
{
if (nosound) return;
if (mod) {
Mix_HaltMusic();
Mix_FreeMusic(mod);
mod = NULL;
}
if (stream) stream = NULL;
}
void init(void)
{
memset(soundlocs, 0, sizeof(soundlocs));
if (Mix_OpenAudio(SOUNDFREQ, MIX_DEFAULT_FORMAT, 2, soundbufferlen) < 0) {
console::out("sound init failed (SDL_mixer): %s", (size_t)Mix_GetError());
nosound = true;
}
Mix_AllocateChannels(MAXCHAN);
}
static void music(const char *name)
{
if (nosound) return;
sound_stop();
if (soundvol && musicvol) {
string sn;
strcpy_s(sn, "packages/");
strcat_s(sn, name);
if ((mod = Mix_LoadMUS(path(sn)))) {
Mix_PlayMusic(mod, -1);
Mix_VolumeMusic((musicvol*MAXVOL)/255);
}
}
}
static int registersound(const char *name)
{
loopv(snames) if (strcmp(snames[i], name)==0) return i;
snames.add(newstring(name));
samples.add(NULL);
return samples.length()-1;
}
void clean(void)
{
if (nosound) return;
sound_stop();
Mix_CloseAudio();
}
static void sound_updatechanvol(int chan, const vec *loc)
{
int vol = soundvol, pan = 255/2;
if (loc) {
vdist(dist, v, *loc, player1->o);
vol -= (int)(dist*3*soundvol/255); // simple mono distance attenuation
if (stereo && (v.x != 0 || v.y != 0)) {
// relative angle of sound along X-Y axis
const float yaw = -atan2(v.x, v.y) - player1->yaw*(PI / 180.0f);
// range is from 0 (left) to 255 (right)
pan = int(255.9f*(0.5*sin(yaw)+0.5f));
}
}
vol = (vol*MAXVOL)/255;
Mix_Volume(chan, vol);
Mix_SetPanning(chan, 255-pan, pan);
}
static void sound_newsoundloc(int chan, const vec *loc)
{
assert(chan>=0 && chan<MAXCHAN);
soundlocs[chan].loc = *loc;
soundlocs[chan].inuse = true;
}
void updatevol(void)
{
if (nosound) return;
loopi(MAXCHAN)
if (soundlocs[i].inuse) {
if (Mix_Playing(i))
sound_updatechanvol(i, &soundlocs[i].loc);
else
soundlocs[i].inuse = false;
}
}
void playc(int n) { addmsg(0, 2, SV_SOUND, n); play(n); }
void play(int n, const vec *loc)
{
if (nosound) return;
if (!soundvol) return;
if (lastmillis==lastsoundmillis)
soundsatonce++;
else
soundsatonce = 1;
lastsoundmillis = lastmillis;
if (soundsatonce>5) return; // avoid bursts of sounds with heavy packetloss and in sp
if (n<0 || n>=samples.length()) { console::out("unregistered sound: %d", n); return; }
if (!samples[n]) {
sprintf_sd(buf)("packages/sounds/%s.wav", snames[n]);
samples[n] = Mix_LoadWAV(path(buf));
if (!samples[n]) {
console::out("failed to load sample: %s", buf);
return;
}
}
const int chan = Mix_PlayChannel(-1, samples[n], 0);
if (chan<0) return;
if (loc) sound_newsoundloc(chan, loc);
sound_updatechanvol(chan, loc);
}
static void sound(int n) { play(n, NULL); }
COMMAND(music, ARG_1STR);
COMMAND(registersound, ARG_1EST);
COMMAND(sound, ARG_1INT);
}
| 24.837838 | 90 | 0.602285 | bsegovia |
42bae9f9a890bc25aa842aa4cb7032e46c5d85ec | 6,714 | hpp | C++ | ThirdParty-mod/java2cpp/android/widget/ResourceCursorTreeAdapter.hpp | kakashidinho/HQEngine | 8125b290afa7c62db6cc6eac14e964d8138c7fd0 | [
"MIT"
] | 1 | 2019-04-03T01:53:28.000Z | 2019-04-03T01:53:28.000Z | ThirdParty-mod/java2cpp/android/widget/ResourceCursorTreeAdapter.hpp | kakashidinho/HQEngine | 8125b290afa7c62db6cc6eac14e964d8138c7fd0 | [
"MIT"
] | null | null | null | ThirdParty-mod/java2cpp/android/widget/ResourceCursorTreeAdapter.hpp | kakashidinho/HQEngine | 8125b290afa7c62db6cc6eac14e964d8138c7fd0 | [
"MIT"
] | null | null | null | /*================================================================================
code generated by: java2cpp
author: Zoran Angelov, mailto://baldzar@gmail.com
class: android.widget.ResourceCursorTreeAdapter
================================================================================*/
#ifndef J2CPP_INCLUDE_IMPLEMENTATION
#ifndef J2CPP_ANDROID_WIDGET_RESOURCECURSORTREEADAPTER_HPP_DECL
#define J2CPP_ANDROID_WIDGET_RESOURCECURSORTREEADAPTER_HPP_DECL
namespace j2cpp { namespace android { namespace database { class Cursor; } } }
namespace j2cpp { namespace android { namespace content { class Context; } } }
namespace j2cpp { namespace android { namespace view { class View; } } }
namespace j2cpp { namespace android { namespace view { class ViewGroup; } } }
namespace j2cpp { namespace android { namespace widget { class CursorTreeAdapter; } } }
#include <android/content/Context.hpp>
#include <android/database/Cursor.hpp>
#include <android/view/View.hpp>
#include <android/view/ViewGroup.hpp>
#include <android/widget/CursorTreeAdapter.hpp>
namespace j2cpp {
namespace android { namespace widget {
class ResourceCursorTreeAdapter;
class ResourceCursorTreeAdapter
: public object<ResourceCursorTreeAdapter>
{
public:
J2CPP_DECLARE_CLASS
J2CPP_DECLARE_METHOD(0)
J2CPP_DECLARE_METHOD(1)
J2CPP_DECLARE_METHOD(2)
J2CPP_DECLARE_METHOD(3)
J2CPP_DECLARE_METHOD(4)
explicit ResourceCursorTreeAdapter(jobject jobj)
: object<ResourceCursorTreeAdapter>(jobj)
{
}
operator local_ref<android::widget::CursorTreeAdapter>() const;
ResourceCursorTreeAdapter(local_ref< android::content::Context > const&, local_ref< android::database::Cursor > const&, jint, jint, jint, jint);
ResourceCursorTreeAdapter(local_ref< android::content::Context > const&, local_ref< android::database::Cursor > const&, jint, jint, jint);
ResourceCursorTreeAdapter(local_ref< android::content::Context > const&, local_ref< android::database::Cursor > const&, jint, jint);
local_ref< android::view::View > newChildView(local_ref< android::content::Context > const&, local_ref< android::database::Cursor > const&, jboolean, local_ref< android::view::ViewGroup > const&);
local_ref< android::view::View > newGroupView(local_ref< android::content::Context > const&, local_ref< android::database::Cursor > const&, jboolean, local_ref< android::view::ViewGroup > const&);
}; //class ResourceCursorTreeAdapter
} //namespace widget
} //namespace android
} //namespace j2cpp
#endif //J2CPP_ANDROID_WIDGET_RESOURCECURSORTREEADAPTER_HPP_DECL
#else //J2CPP_INCLUDE_IMPLEMENTATION
#ifndef J2CPP_ANDROID_WIDGET_RESOURCECURSORTREEADAPTER_HPP_IMPL
#define J2CPP_ANDROID_WIDGET_RESOURCECURSORTREEADAPTER_HPP_IMPL
namespace j2cpp {
android::widget::ResourceCursorTreeAdapter::operator local_ref<android::widget::CursorTreeAdapter>() const
{
return local_ref<android::widget::CursorTreeAdapter>(get_jobject());
}
android::widget::ResourceCursorTreeAdapter::ResourceCursorTreeAdapter(local_ref< android::content::Context > const &a0, local_ref< android::database::Cursor > const &a1, jint a2, jint a3, jint a4, jint a5)
: object<android::widget::ResourceCursorTreeAdapter>(
call_new_object<
android::widget::ResourceCursorTreeAdapter::J2CPP_CLASS_NAME,
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_NAME(0),
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_SIGNATURE(0)
>(a0, a1, a2, a3, a4, a5)
)
{
}
android::widget::ResourceCursorTreeAdapter::ResourceCursorTreeAdapter(local_ref< android::content::Context > const &a0, local_ref< android::database::Cursor > const &a1, jint a2, jint a3, jint a4)
: object<android::widget::ResourceCursorTreeAdapter>(
call_new_object<
android::widget::ResourceCursorTreeAdapter::J2CPP_CLASS_NAME,
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_NAME(1),
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_SIGNATURE(1)
>(a0, a1, a2, a3, a4)
)
{
}
android::widget::ResourceCursorTreeAdapter::ResourceCursorTreeAdapter(local_ref< android::content::Context > const &a0, local_ref< android::database::Cursor > const &a1, jint a2, jint a3)
: object<android::widget::ResourceCursorTreeAdapter>(
call_new_object<
android::widget::ResourceCursorTreeAdapter::J2CPP_CLASS_NAME,
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_NAME(2),
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_SIGNATURE(2)
>(a0, a1, a2, a3)
)
{
}
local_ref< android::view::View > android::widget::ResourceCursorTreeAdapter::newChildView(local_ref< android::content::Context > const &a0, local_ref< android::database::Cursor > const &a1, jboolean a2, local_ref< android::view::ViewGroup > const &a3)
{
return call_method<
android::widget::ResourceCursorTreeAdapter::J2CPP_CLASS_NAME,
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_NAME(3),
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_SIGNATURE(3),
local_ref< android::view::View >
>(get_jobject(), a0, a1, a2, a3);
}
local_ref< android::view::View > android::widget::ResourceCursorTreeAdapter::newGroupView(local_ref< android::content::Context > const &a0, local_ref< android::database::Cursor > const &a1, jboolean a2, local_ref< android::view::ViewGroup > const &a3)
{
return call_method<
android::widget::ResourceCursorTreeAdapter::J2CPP_CLASS_NAME,
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_NAME(4),
android::widget::ResourceCursorTreeAdapter::J2CPP_METHOD_SIGNATURE(4),
local_ref< android::view::View >
>(get_jobject(), a0, a1, a2, a3);
}
J2CPP_DEFINE_CLASS(android::widget::ResourceCursorTreeAdapter,"android/widget/ResourceCursorTreeAdapter")
J2CPP_DEFINE_METHOD(android::widget::ResourceCursorTreeAdapter,0,"<init>","(Landroid/content/Context;Landroid/database/Cursor;IIII)V")
J2CPP_DEFINE_METHOD(android::widget::ResourceCursorTreeAdapter,1,"<init>","(Landroid/content/Context;Landroid/database/Cursor;III)V")
J2CPP_DEFINE_METHOD(android::widget::ResourceCursorTreeAdapter,2,"<init>","(Landroid/content/Context;Landroid/database/Cursor;II)V")
J2CPP_DEFINE_METHOD(android::widget::ResourceCursorTreeAdapter,3,"newChildView","(Landroid/content/Context;Landroid/database/Cursor;ZLandroid/view/ViewGroup;)Landroid/view/View;")
J2CPP_DEFINE_METHOD(android::widget::ResourceCursorTreeAdapter,4,"newGroupView","(Landroid/content/Context;Landroid/database/Cursor;ZLandroid/view/ViewGroup;)Landroid/view/View;")
} //namespace j2cpp
#endif //J2CPP_ANDROID_WIDGET_RESOURCECURSORTREEADAPTER_HPP_IMPL
#endif //J2CPP_INCLUDE_IMPLEMENTATION
| 43.597403 | 252 | 0.752011 | kakashidinho |
42bbb028fafac8ea0fb7f717bcf95d3d367bd700 | 15,465 | cc | C++ | rsm.cc | vinx13/SE227 | 397d9efe403becd48db5ffd65d48af9e7126b6a2 | [
"BSD-3-Clause"
] | null | null | null | rsm.cc | vinx13/SE227 | 397d9efe403becd48db5ffd65d48af9e7126b6a2 | [
"BSD-3-Clause"
] | null | null | null | rsm.cc | vinx13/SE227 | 397d9efe403becd48db5ffd65d48af9e7126b6a2 | [
"BSD-3-Clause"
] | 2 | 2019-09-18T14:09:39.000Z | 2019-09-25T04:13:59.000Z | //
// Replicated state machine implementation with a primary and several
// backups. The primary receives requests, assigns each a view stamp (a
// vid, and a sequence number) in the order of reception, and forwards
// them to all backups. A backup executes requests in the order that
// the primary stamps them and replies with an OK to the primary. The
// primary executes the request after it receives OKs from all backups,
// and sends the reply back to the client.
//
// The config module will tell the RSM about a new view. If the
// primary in the previous view is a member of the new view, then it
// will stay the primary. Otherwise, the smallest numbered node of
// the previous view will be the new primary. In either case, the new
// primary will be a node from the previous view. The configuration
// module constructs the sequence of views for the RSM and the RSM
// ensures there will be always one primary, who was a member of the
// last view.
//
// When a new node starts, the recovery thread is in charge of joining
// the RSM. It will collect the internal RSM state from the primary;
// the primary asks the config module to add the new node and returns
// to the joining the internal RSM state (e.g., paxos log). Since
// there is only one primary, all joins happen in well-defined total
// order.
//
// The recovery thread also runs during a view change (e.g, when a node
// has failed). After a failure some of the backups could have
// processed a request that the primary has not, but those results are
// not visible to clients (since the primary responds). If the
// primary of the previous view is in the current view, then it will
// be the primary and its state is authoritive: the backups download
// from the primary the current state. A primary waits until all
// backups have downloaded the state. Once the RSM is in sync, the
// primary accepts requests again from clients. If one of the backups
// is the new primary, then its state is authoritative. In either
// scenario, the next view uses a node as primary that has the state
// resulting from processing all acknowledged client requests.
// Therefore, if the nodes sync up before processing the next request,
// the next view will have the correct state.
//
// While the RSM in a view change (i.e., a node has failed, a new view
// has been formed, but the sync hasn't completed), another failure
// could happen, which complicates a view change. During syncing the
// primary or backups can timeout, and initiate another Paxos round.
// There are 2 variables that RSM uses to keep track in what state it
// is:
// - inviewchange: a node has failed and the RSM is performing a view change
// - insync: this node is syncing its state
//
// If inviewchange is false and a node is the primary, then it can
// process client requests. If it is true, clients are told to retry
// later again. While inviewchange is true, the RSM may go through several
// member list changes, one by one. After a member list
// change completes, the nodes tries to sync. If the sync complets,
// the view change completes (and inviewchange is set to false). If
// the sync fails, the node may start another member list change
// (inviewchange = true and insync = false).
//
// The implementation should be used only with servers that run all
// requests run to completion; in particular, a request shouldn't
// block. If a request blocks, the backup won't respond to the
// primary, and the primary won't execute the request. A request may
// send an RPC to another host, but the RPC should be a one-way
// message to that host; the backup shouldn't do anything based on the
// response or execute after the response, because it is not
// guaranteed that all backup will receive the same response and
// execute in the same order.
//
// The implementation can be viewed as a layered system:
// RSM module ---- in charge of replication
// config module ---- in charge of view management
// Paxos module ---- in charge of running Paxos to agree on a value
//
// Each module has threads and internal locks. Furthermore, a thread
// may call down through the layers (e.g., to run Paxos's proposer).
// When Paxos's acceptor accepts a new value for an instance, a thread
// will invoke an upcall to inform higher layers of the new value.
// The rule is that a module releases its internal locks before it
// upcalls, but can keep its locks when calling down.
#include <fstream>
#include <iostream>
#include <unistd.h>
#include "handle.h"
#include "rsm.h"
#include "tprintf.h"
#include "lang/verify.h"
static void *
recoverythread(void *x)
{
rsm *r = (rsm *) x;
r->recovery();
return 0;
}
rsm::rsm(std::string _first, std::string _me)
: stf(0), primary(_first), insync (false), inviewchange (true), vid_commit(0),
partitioned (false), dopartition(false), break1(false), break2(false)
{
pthread_t th;
last_myvs.vid = 0;
last_myvs.seqno = 0;
myvs = last_myvs;
myvs.seqno = 1;
pthread_mutex_init(&rsm_mutex, NULL);
pthread_mutex_init(&invoke_mutex, NULL);
pthread_cond_init(&recovery_cond, NULL);
pthread_cond_init(&sync_cond, NULL);
cfg = new config(_first, _me, this);
if (_first == _me) {
// Commit the first view here. We can not have acceptor::acceptor
// do the commit, since at that time this->cfg is not initialized
commit_change(1);
}
rsmrpc = cfg->get_rpcs();
rsmrpc->reg(rsm_client_protocol::invoke, this, &rsm::client_invoke);
rsmrpc->reg(rsm_client_protocol::members, this, &rsm::client_members);
rsmrpc->reg(rsm_protocol::invoke, this, &rsm::invoke);
rsmrpc->reg(rsm_protocol::transferreq, this, &rsm::transferreq);
rsmrpc->reg(rsm_protocol::transferdonereq, this, &rsm::transferdonereq);
rsmrpc->reg(rsm_protocol::joinreq, this, &rsm::joinreq);
// tester must be on different port, otherwise it may partition itself
testsvr = new rpcs(atoi(_me.c_str()) + 1);
testsvr->reg(rsm_test_protocol::net_repair, this, &rsm::test_net_repairreq);
testsvr->reg(rsm_test_protocol::breakpoint, this, &rsm::breakpointreq);
{
ScopedLock ml(&rsm_mutex);
VERIFY(pthread_create(&th, NULL, &recoverythread, (void *) this) == 0);
}
}
// The recovery thread runs this function
void
rsm::recovery()
{
bool r = true;
ScopedLock ml(&rsm_mutex);
while (1) {
while (!cfg->ismember(cfg->myaddr(), vid_commit)) {
if (join(primary)) {
tprintf("recovery: joined\n");
commit_change_wo(cfg->vid());
} else {
VERIFY(pthread_mutex_unlock(&rsm_mutex)==0);
sleep (30); // XXX make another node in cfg primary?
VERIFY(pthread_mutex_lock(&rsm_mutex)==0);
}
}
vid_insync = vid_commit;
tprintf("recovery: sync vid_insync %d\n", vid_insync);
if (primary == cfg->myaddr()) {
r = sync_with_backups();
} else {
r = sync_with_primary();
}
tprintf("recovery: sync done\n");
// If there was a commited viewchange during the synchronization, restart
// the recovery
if (vid_insync != vid_commit)
continue;
if (r) {
myvs.vid = vid_commit;
myvs.seqno = 1;
inviewchange = false;
}
tprintf("recovery: go to sleep %d %d\n", insync, inviewchange);
pthread_cond_wait(&recovery_cond, &rsm_mutex);
}
}
bool
rsm::sync_with_backups()
{
pthread_mutex_unlock(&rsm_mutex);
{
// Make sure that the state of lock_server_cache_rsm is stable during
// synchronization; otherwise, the primary's state may be more recent
// than replicas after the synchronization.
ScopedLock ml(&invoke_mutex);
// By acquiring and releasing the invoke_mutex once, we make sure that
// the state of lock_server_cache_rsm will not be changed until all
// replicas are synchronized. The reason is that client_invoke arrives
// after this point of time will see inviewchange == true, and returns
// BUSY.
}
pthread_mutex_lock(&rsm_mutex);
// Start accepting synchronization request (statetransferreq) now!
insync = true;
// Wait until
// - all backups in view vid_insync are synchronized
// - or there is a committed viewchange
insync = false;
return true;
}
bool
rsm::sync_with_primary()
{
// Remember the primary of vid_insync
std::string m = primary;
// Keep synchronizing with primary until the synchronization succeeds,
// or there is a commited viewchange
return true;
}
/**
* Call to transfer state from m to the local node.
* Assumes that rsm_mutex is already held.
*/
bool
rsm::statetransfer(std::string m)
{
return true;
}
bool
rsm::statetransferdone(std::string m) {
// - Inform primary that this slave has synchronized for vid_insync
return true;
}
bool
rsm::join(std::string m) {
handle h(m);
int ret;
rsm_protocol::joinres r;
tprintf("rsm::join: %s mylast (%d,%d)\n", m.c_str(), last_myvs.vid,
last_myvs.seqno);
VERIFY(pthread_mutex_unlock(&rsm_mutex)==0);
rpcc *cl = h.safebind();
if (cl != 0) {
ret = cl->call(rsm_protocol::joinreq, cfg->myaddr(), last_myvs,
r, rpcc::to(120000));
}
VERIFY(pthread_mutex_lock(&rsm_mutex)==0);
if (cl == 0 || ret != rsm_protocol::OK) {
tprintf("rsm::join: couldn't reach %s %p %d\n", m.c_str(),
cl, ret);
return false;
}
tprintf("rsm::join: succeeded %s\n", r.log.c_str());
cfg->restore(r.log);
return true;
}
/*
* Config informs rsm whenever it has successfully
* completed a view change
*/
void
rsm::commit_change(unsigned vid)
{
ScopedLock ml(&rsm_mutex);
commit_change_wo(vid);
}
void
rsm::commit_change_wo(unsigned vid)
{
if (vid <= vid_commit)
return;
tprintf("commit_change: new view (%d) last vs (%d,%d) %s insync %d\n",
vid, last_myvs.vid, last_myvs.seqno, primary.c_str(), insync);
vid_commit = vid;
inviewchange = true;
set_primary(vid);
pthread_cond_signal(&recovery_cond);
if (cfg->ismember(cfg->myaddr(), vid_commit))
breakpoint2();
}
//
// Clients call client_invoke to invoke a procedure on the replicated state
// machine: the primary receives the request, assigns it a sequence
// number, and invokes it on all members of the replicated state
// machine.
//
rsm_client_protocol::status
rsm::client_invoke(int procno, std::string req, std::string &r)
{
int ret = rsm_client_protocol::OK;
return ret;
}
//
// The primary calls the internal invoke at each member of the
// replicated state machine
//
// the replica must execute requests in order (with no gaps)
// according to requests' seqno
rsm_protocol::status
rsm::invoke(int proc, viewstamp vs, std::string req, int &dummy)
{
rsm_protocol::status ret = rsm_protocol::OK;
return ret;
}
/**
* RPC handler: Send back the local node's state to the caller
*/
rsm_protocol::status
rsm::transferreq(std::string src, viewstamp last, unsigned vid,
rsm_protocol::transferres &r)
{
ScopedLock ml(&rsm_mutex);
int ret = rsm_protocol::OK;
return ret;
}
/**
* RPC handler: Inform the local node (the primary) that node m has synchronized
* for view vid
*/
rsm_protocol::status
rsm::transferdonereq(std::string m, unsigned vid, int &)
{
int ret = rsm_protocol::OK;
ScopedLock ml(&rsm_mutex);
// - Return BUSY if I am not insync, or if the slave is not synchronizing
// for the same view with me
// - Remove the slave from the list of unsynchronized backups
// - Wake up recovery thread if all backups are synchronized
return ret;
}
// a node that wants to join an RSM as a server sends a
// joinreq to the RSM's current primary; this is the
// handler for that RPC.
rsm_protocol::status
rsm::joinreq(std::string m, viewstamp last, rsm_protocol::joinres &r)
{
int ret = rsm_protocol::OK;
ScopedLock ml(&rsm_mutex);
tprintf("joinreq: src %s last (%d,%d) mylast (%d,%d)\n", m.c_str(),
last.vid, last.seqno, last_myvs.vid, last_myvs.seqno);
if (cfg->ismember(m, vid_commit)) {
tprintf("joinreq: is still a member\n");
r.log = cfg->dump();
} else if (cfg->myaddr() != primary) {
tprintf("joinreq: busy\n");
ret = rsm_protocol::BUSY;
} else {
// We cache vid_commit to avoid adding m to a view which already contains
// m due to race condition
unsigned vid_cache = vid_commit;
VERIFY (pthread_mutex_unlock(&rsm_mutex) == 0);
bool succ = cfg->add(m, vid_cache);
VERIFY (pthread_mutex_lock(&rsm_mutex) == 0);
if (cfg->ismember(m, cfg->vid())) {
r.log = cfg->dump();
tprintf("joinreq: ret %d log %s\n:", ret, r.log.c_str());
} else {
tprintf("joinreq: failed; proposer couldn't add %d\n", succ);
ret = rsm_protocol::BUSY;
}
}
return ret;
}
/*
* RPC handler: Send back all the nodes this local knows about to client
* so the client can switch to a different primary
* when it existing primary fails
*/
rsm_client_protocol::status
rsm::client_members(int i, std::vector<std::string> &r)
{
std::vector<std::string> m;
ScopedLock ml(&rsm_mutex);
m = cfg->get_view(vid_commit);
m.push_back(primary);
r = m;
tprintf("rsm::client_members return %s m %s\n", print_members(m).c_str(),
primary.c_str());
return rsm_client_protocol::OK;
}
// if primary is member of new view, that node is primary
// otherwise, the lowest number node of the previous view.
// caller should hold rsm_mutex
void
rsm::set_primary(unsigned vid)
{
std::vector<std::string> c = cfg->get_view(vid);
std::vector<std::string> p = cfg->get_view(vid - 1);
VERIFY (c.size() > 0);
if (isamember(primary,c)) {
tprintf("set_primary: primary stays %s\n", primary.c_str());
return;
}
VERIFY(p.size() > 0);
for (unsigned i = 0; i < p.size(); i++) {
if (isamember(p[i], c)) {
primary = p[i];
tprintf("set_primary: primary is %s\n", primary.c_str());
return;
}
}
VERIFY(0);
}
bool
rsm::amiprimary()
{
ScopedLock ml(&rsm_mutex);
return primary == cfg->myaddr() && !inviewchange;
}
// Testing server
// Simulate partitions
// assumes caller holds rsm_mutex
void
rsm::net_repair_wo(bool heal)
{
std::vector<std::string> m;
m = cfg->get_view(vid_commit);
for (unsigned i = 0; i < m.size(); i++) {
if (m[i] != cfg->myaddr()) {
handle h(m[i]);
tprintf("rsm::net_repair_wo: %s %d\n", m[i].c_str(), heal);
if (h.safebind()) h.safebind()->set_reachable(heal);
}
}
rsmrpc->set_reachable(heal);
}
rsm_test_protocol::status
rsm::test_net_repairreq(int heal, int &r)
{
ScopedLock ml(&rsm_mutex);
tprintf("rsm::test_net_repairreq: %d (dopartition %d, partitioned %d)\n",
heal, dopartition, partitioned);
if (heal) {
net_repair_wo(heal);
partitioned = false;
} else {
dopartition = true;
partitioned = false;
}
r = rsm_test_protocol::OK;
return r;
}
// simulate failure at breakpoint 1 and 2
void
rsm::breakpoint1()
{
if (break1) {
tprintf("Dying at breakpoint 1 in rsm!\n");
exit(1);
}
}
void
rsm::breakpoint2()
{
if (break2) {
tprintf("Dying at breakpoint 2 in rsm!\n");
exit(1);
}
}
void
rsm::partition1()
{
if (dopartition) {
net_repair_wo(false);
dopartition = false;
partitioned = true;
}
}
rsm_test_protocol::status
rsm::breakpointreq(int b, int &r)
{
r = rsm_test_protocol::OK;
ScopedLock ml(&rsm_mutex);
tprintf("rsm::breakpointreq: %d\n", b);
if (b == 1) break1 = true;
else if (b == 2) break2 = true;
else if (b == 3 || b == 4) cfg->breakpoint(b);
else r = rsm_test_protocol::ERR;
return r;
}
| 30.087549 | 81 | 0.686906 | vinx13 |
42bdcb373dcf1516159b7cc72fca4ba3bfddc909 | 1,432 | cpp | C++ | test/qt/remote_device/messages/test_IfdVersion.cpp | misery/AusweisApp2 | dab96eb2bdd8a132023964d4aeecc7069d12a244 | [
"Apache-2.0"
] | null | null | null | test/qt/remote_device/messages/test_IfdVersion.cpp | misery/AusweisApp2 | dab96eb2bdd8a132023964d4aeecc7069d12a244 | [
"Apache-2.0"
] | null | null | null | test/qt/remote_device/messages/test_IfdVersion.cpp | misery/AusweisApp2 | dab96eb2bdd8a132023964d4aeecc7069d12a244 | [
"Apache-2.0"
] | null | null | null | /*!
* \copyright Copyright (c) 2018 Governikus GmbH & Co. KG, Germany
*/
#include "messages/IfdVersion.h"
#include <QtTest>
using namespace governikus;
class test_IfdVersion
: public QObject
{
Q_OBJECT
private Q_SLOTS:
void stringParsing()
{
QCOMPARE(IfdVersion::fromString("IFDInterface_WebSocket_v0"), IfdVersion::Version::v0);
QCOMPARE(IfdVersion::fromString("IFDInterface_WebSocket_v9001"), IfdVersion::Version::Unknown);
}
void isValid()
{
QCOMPARE(IfdVersion(IfdVersion::Version::Unknown).isValid(), false);
QCOMPARE(IfdVersion(IfdVersion::Version::v0).isValid(), true);
}
void isSupported()
{
QCOMPARE(IfdVersion(IfdVersion::Version::Unknown).isSupported(), false);
QCOMPARE(IfdVersion(IfdVersion::Version::v0).isSupported(), true);
}
void supportedVersions()
{
QCOMPARE(IfdVersion::supported(), {IfdVersion::Version::v0});
}
void selectSupportedVersions()
{
QCOMPARE(IfdVersion::selectLatestSupported({}), IfdVersion::Version::Unknown);
QCOMPARE(IfdVersion::selectLatestSupported({IfdVersion::Version::v_test}), IfdVersion::Version::Unknown);
QCOMPARE(IfdVersion::selectLatestSupported({IfdVersion::Version::v0}), IfdVersion::Version::v0);
QCOMPARE(IfdVersion::selectLatestSupported({IfdVersion::Version::v0, IfdVersion::Version::v_test}), IfdVersion::Version::v0);
}
};
QTEST_GUILESS_MAIN(test_IfdVersion)
#include "test_IfdVersion.moc"
| 24.271186 | 128 | 0.733939 | misery |
42be4f01f8d6a8048f7a8ffd8482e4c637d69de2 | 11,234 | cpp | C++ | sources/UEAA/Core/Enrollee/Enrollee.cpp | KonstantinTomashevich/university-enrollee-apllication-algorithm | 75f3da7d84d931401d8ce6ab79344018417ae03e | [
"MIT"
] | null | null | null | sources/UEAA/Core/Enrollee/Enrollee.cpp | KonstantinTomashevich/university-enrollee-apllication-algorithm | 75f3da7d84d931401d8ce6ab79344018417ae03e | [
"MIT"
] | null | null | null | sources/UEAA/Core/Enrollee/Enrollee.cpp | KonstantinTomashevich/university-enrollee-apllication-algorithm | 75f3da7d84d931401d8ce6ab79344018417ae03e | [
"MIT"
] | null | null | null | #include <UEAA/BuildConfiguration.hpp>
#include "Enrollee.hpp"
#include <algorithm>
#include <cmath>
#include <UEAA/Core/Enrollee/EnrolleeHelpers.hpp>
#include <UEAA/Utils/CStringToHash.hpp>
namespace UEAA
{
Enrollee::Enrollee (unsigned id) :
XMLSerializable (),
id_ (id),
examsResults_ (),
currentChoiceIndex_ (0),
choices_ (0),
lastUpdateResult_ (nullptr),
certificateMarks_ (),
certificateMedianMark_ (),
hasSchoolGoldMedal_ (false),
rodSubject_ (0),
rodType_ (ROD_NONE)
{
}
Enrollee::~Enrollee ()
{
}
unsigned Enrollee::GetId () const
{
return id_;
}
unsigned char Enrollee::GetExamResult (unsigned examSubjectNameHash) const
{
try
{
return examsResults_.at (examSubjectNameHash);
}
catch (std::out_of_range &exception)
{
return 0;
}
}
void Enrollee::SetExamResult (unsigned examSubjectNameHash, unsigned char examResult)
{
examsResults_ [examSubjectNameHash] = examResult;
}
std::vector <unsigned> Enrollee::GetPassedExamsSubjects () const
{
std::vector <unsigned> subjects;
for (auto iterator = examsResults_.begin (); iterator != examsResults_.end (); iterator++)
{
subjects.push_back (iterator->first);
}
return subjects;
}
bool Enrollee::HasMoreChoices () const
{
return currentChoiceIndex_ < choices_.size ();
}
unsigned Enrollee::GetCurrentChoiceIndex () const
{
return currentChoiceIndex_;
}
void Enrollee::IncreaseChoiceIndex ()
{
currentChoiceIndex_++;
}
void Enrollee::RefreshChoiceIndex ()
{
currentChoiceIndex_ = 0;
}
unsigned Enrollee::GetChoicesCount () const
{
return choices_.size ();
}
const std::list <SharedPointer <EnrolleeChoice> > &Enrollee::GetChoices () const
{
return choices_;
}
EnrolleeChoice *Enrollee::GetCurrentChoice () const
{
return GetChoiceByIndex (currentChoiceIndex_);
}
EnrolleeChoice *Enrollee::GetChoiceByIndex (unsigned index) const
{
if (index < choices_.size ())
{
auto iterator = choices_.begin ();
for (; index > 0; iterator++, index--) {}
return *iterator;
}
else
{
return nullptr;
}
}
void Enrollee::AddChoiceToBack (EnrolleeChoice *choice)
{
choices_.push_back (SharedPointer <EnrolleeChoice> (choice));
}
void Enrollee::RemoveChoiceByIndex (unsigned index)
{
if (index < choices_.size ())
{
auto iterator = choices_.begin ();
for (; index > 0; iterator++, index--) {}
choices_.erase (iterator);
}
}
void Enrollee::SwapChoicesAtIndexes (unsigned firstIndex, unsigned secondIndex)
{
auto firstIterator = choices_.begin ();
for (; firstIndex > 0; firstIterator++, firstIndex--) {}
auto secondIterator = choices_.begin ();
for (; secondIndex > 0; secondIterator++, secondIndex--) {}
SharedPointer <EnrolleeChoice> temp (firstIterator->GetTrackingObject ());
firstIterator->SetTrackingObject (secondIterator->GetTrackingObject ());
secondIterator->SetTrackingObject (temp.GetTrackingObject ());
}
EnrolleeChoice *Enrollee::GetLastUpdateResult () const
{
return lastUpdateResult_;
}
void Enrollee::SetLastUpdateResult (EnrolleeChoice *lastUpdateResult)
{
lastUpdateResult_.SetTrackingObject (lastUpdateResult);
}
unsigned char Enrollee::GetCertificateMark (unsigned subjectNameHash) const
{
return certificateMarks_.at (subjectNameHash);
}
void Enrollee::SetCertificateMark (unsigned subjectNameHash, unsigned char mark)
{
certificateMarks_ [subjectNameHash] = mark;
}
std::vector <unsigned> Enrollee::GetCertificateMarksSubjects () const
{
std::vector <unsigned> subjects;
for (auto iterator = certificateMarks_.cbegin (); iterator != certificateMarks_.cend (); iterator++)
{
subjects.push_back (iterator->first);
}
return subjects;
}
float Enrollee::GetCertificateMedianMark () const
{
return certificateMedianMark_;
}
void Enrollee::CalculateCertificateMedianMark ()
{
int sum = 0;
for (auto iterator = certificateMarks_.cbegin (); iterator != certificateMarks_.cend (); iterator++)
{
sum += iterator->second;
}
certificateMedianMark_ = std::round (sum * 10.0f / certificateMarks_.size ()) / 10.0f;
}
bool Enrollee::HasSchoolGoldMedal () const
{
return hasSchoolGoldMedal_;
}
void Enrollee::CheckIsHasSchoolGoldMedal ()
{
hasSchoolGoldMedal_ = true;
for (auto iterator = certificateMarks_.cbegin (); iterator != certificateMarks_.cend (); iterator++)
{
if (iterator->second < 9)
{
hasSchoolGoldMedal_ = false;
return;
}
}
}
unsigned Enrollee::GetRODSubject () const
{
return rodSubject_;
}
void Enrollee::SetRODSubject (unsigned rodSubject)
{
rodSubject_ = rodSubject;
}
RODType Enrollee::GetRODType () const
{
return rodType_;
}
void Enrollee::SetRODType (RODType rodType)
{
rodType_ = rodType;
}
void Enrollee::SaveToXML (tinyxml2::XMLDocument &document, tinyxml2::XMLElement *output, DeHashTable *deHashTable) const
{
output->SetAttribute ("passport", deHashTable->DeHash (id_).c_str ());
output->SetAttribute ("rodSubject", deHashTable->DeHash (rodSubject_).c_str ());
output->SetAttribute ("rodType", rodType_);
tinyxml2::XMLElement *examsResultsElement = document.NewElement ("examsResults");
output->InsertEndChild (examsResultsElement);
for (auto iterator = examsResults_.cbegin (); iterator != examsResults_.cend (); iterator++)
{
tinyxml2::XMLElement *examElement = document.NewElement ("exam");
examsResultsElement->InsertEndChild (examElement);
examElement->SetAttribute ("subject", deHashTable->DeHash (iterator->first).c_str ());
examElement->SetAttribute ("result", iterator->second);
}
tinyxml2::XMLElement *certificateMarksElement = document.NewElement ("certificateMarks");
output->InsertEndChild (certificateMarksElement);
for (auto iterator = certificateMarks_.cbegin (); iterator != certificateMarks_.cend (); iterator++)
{
tinyxml2::XMLElement *markElement = document.NewElement ("mark");
certificateMarksElement->InsertEndChild (markElement);
markElement->SetAttribute ("subject", deHashTable->DeHash (iterator->first).c_str ());
markElement->SetAttribute ("result", iterator->second);
}
tinyxml2::XMLElement *choicesElement = document.NewElement ("choices");
output->InsertEndChild (choicesElement);
for (auto iterator = choices_.cbegin (); iterator != choices_.cend (); iterator++)
{
EnrolleeChoice *choice = *iterator;
tinyxml2::XMLElement *choiceElement = document.NewElement ("choice");
choicesElement->InsertEndChild (choiceElement);
choice->SaveToXML (document, choiceElement, deHashTable);
}
if (lastUpdateResult_.GetTrackingObject () != nullptr)
{
tinyxml2::XMLElement *lastUpdateResultElement = document.NewElement ("lastUpdateResult");
output->InsertEndChild (lastUpdateResultElement);
lastUpdateResult_->SaveToXML (document, lastUpdateResultElement, deHashTable);
}
}
void Enrollee::LoadFromXML (tinyxml2::XMLElement *input, DeHashTable *deHashTable)
{
Clear ();
rodSubject_ = CStringToHash (input->Attribute ("rodSubject"), deHashTable);
rodType_ = static_cast <RODType> (atoi (input->Attribute ("rodType")));
tinyxml2::XMLElement *examsResultsElement = input->FirstChildElement ("examsResults");
if (examsResultsElement != nullptr)
{
for (tinyxml2::XMLElement *element = examsResultsElement->FirstChildElement ("exam");
element != nullptr; element = element->NextSiblingElement ("exam"))
{
unsigned subject = CStringToHash (element->Attribute ("subject"), deHashTable);
unsigned result = 0;
tinyxml2::XMLUtil::ToUnsigned (element->Attribute ("result"), &result);
examsResults_ [subject] = static_cast <unsigned char> (result);
}
}
tinyxml2::XMLElement *certificateMarksElement = input->FirstChildElement ("certificateMarks");
if (certificateMarksElement != nullptr)
{
for (tinyxml2::XMLElement *element = certificateMarksElement->FirstChildElement ("mark");
element != nullptr; element = element->NextSiblingElement ("mark"))
{
unsigned subject = CStringToHash (element->Attribute ("subject"), deHashTable);
unsigned result = 0;
tinyxml2::XMLUtil::ToUnsigned (element->Attribute ("result"), &result);
certificateMarks_ [subject] = static_cast <unsigned char> (result);
}
}
CalculateCertificateMedianMark ();
CheckIsHasSchoolGoldMedal ();
tinyxml2::XMLElement *choicesElement = input->FirstChildElement ("choices");
if (choicesElement != nullptr)
{
for (tinyxml2::XMLElement *element = choicesElement->FirstChildElement ("choice");
element != nullptr; element = element->NextSiblingElement ("choice"))
{
SharedPointer <EnrolleeChoice> choice (new EnrolleeChoice ());
choice->LoadFromXML (element, deHashTable);
AddChoiceToBack (choice);
}
}
tinyxml2::XMLElement *lastUpdateResultElement = input->FirstChildElement ("lastUpdateResult");
if (lastUpdateResultElement != nullptr)
{
lastUpdateResult_.SetTrackingObject (new EnrolleeChoice ());
lastUpdateResult_->LoadFromXML (lastUpdateResultElement, deHashTable);
}
}
void Enrollee::Clear ()
{
examsResults_.clear ();
currentChoiceIndex_ = 0;
choices_.clear ();
lastUpdateResult_.SetTrackingObject (nullptr);
certificateMarks_.clear ();
certificateMedianMark_ = 0.0f;
hasSchoolGoldMedal_ = false;
rodSubject_ = 0;
rodType_ = ROD_NONE;
}
bool Enrollee::operator == (const Enrollee &rhs) const
{
if (id_ != rhs.id_ ||
examsResults_ != rhs.examsResults_ ||
certificateMarks_ != rhs.certificateMarks_ ||
certificateMedianMark_ != rhs.certificateMedianMark_ ||
hasSchoolGoldMedal_ != rhs.hasSchoolGoldMedal_ ||
rodSubject_ != rhs.rodSubject_ ||
rodType_ != rhs.rodType_)
{
return false;
}
if (choices_.size () == rhs.choices_.size ())
{
auto firstIterator = choices_.cbegin ();
auto secondIterator = rhs.choices_.cbegin ();
for (; firstIterator != choices_.cend () && secondIterator != rhs.choices_.cend ();
firstIterator++, secondIterator++)
{
if (*firstIterator->GetTrackingObject () != *secondIterator->GetTrackingObject ())
{
return false;
}
}
}
else
{
return false;
}
if (lastUpdateResult_.GetTrackingObject () != nullptr && rhs.lastUpdateResult_.GetTrackingObject () != nullptr)
{
return *lastUpdateResult_.GetTrackingObject () == *lastUpdateResult_.GetTrackingObject ();
}
else
{
return lastUpdateResult_.GetTrackingObject () == rhs.lastUpdateResult_.GetTrackingObject ();
}
}
bool Enrollee::operator != (const Enrollee &rhs) const
{
return !(rhs == *this);
}
}
| 28.440506 | 120 | 0.674203 | KonstantinTomashevich |
42bf7a607e81b1fce155442d5071798a9f901291 | 3,463 | hpp | C++ | include/gtirb_pprinter/Mips32PrettyPrinter.hpp | clayne/gtirb-pprinter | 97b6f88d527e1dffbb41c56c267ccd58ca270ba7 | [
"MIT"
] | null | null | null | include/gtirb_pprinter/Mips32PrettyPrinter.hpp | clayne/gtirb-pprinter | 97b6f88d527e1dffbb41c56c267ccd58ca270ba7 | [
"MIT"
] | null | null | null | include/gtirb_pprinter/Mips32PrettyPrinter.hpp | clayne/gtirb-pprinter | 97b6f88d527e1dffbb41c56c267ccd58ca270ba7 | [
"MIT"
] | null | null | null | //===- Mips32PrettyPrinter.hpp ----------------------------------*- C++ -*-===//
//
// Copyright (c) 2020 GrammaTech, Inc.
//
// This code is licensed under the MIT license. See the LICENSE file in the
// project root for license terms.
//
// This project is sponsored by the Office of Naval Research, One Liberty
// Center, 875 N. Randolph Street, Arlington, VA 22203 under contract #
// N68335-17-C-0700. The content of the information does not necessarily
// reflect the position or policy of the Government and no official
// endorsement should be inferred.
//
//===----------------------------------------------------------------------===//
#ifndef GTIRB_PP_MIPS32_ASM_PRINTER_H
#define GTIRB_PP_MIPS32_ASM_PRINTER_H
#include "ElfPrettyPrinter.hpp"
namespace gtirb_pprint {
class Mips32Syntax : public ElfSyntax {
public:
SyntaxAlignmentStyle alignmentStyle() const override {
return SyntaxAlignmentZeros;
};
};
class DEBLOAT_PRETTYPRINTER_EXPORT_API Mips32PrettyPrinter
: public ElfPrettyPrinter {
public:
Mips32PrettyPrinter(gtirb::Context& context, gtirb::Module& module,
const ElfSyntax& syntax, const GasAssembler& assembler,
const PrintingPolicy& policy);
protected:
void printHeader(std::ostream& os) override;
void printOpRegdirect(std::ostream& os, const cs_insn& inst,
uint64_t index) override;
void printOpImmediate(std::ostream& os,
const gtirb::SymbolicExpression* symbolic,
const cs_insn& inst, uint64_t index) override;
void printOpIndirect(std::ostream& os,
const gtirb::SymbolicExpression* symbolic,
const cs_insn& inst, uint64_t index) override;
std::string getRegisterName(unsigned int reg) const override;
void printOperand(std::ostream& os, const gtirb::CodeBlock& block,
const cs_insn& inst, uint64_t index) override;
void printInstruction(std::ostream& os, const gtirb::CodeBlock& block,
const cs_insn& inst,
const gtirb::Offset& offset) override;
void printOperandList(std::ostream& os, const gtirb::CodeBlock& block,
const cs_insn& inst) override;
void printSymExprPrefix(std::ostream& OS, const gtirb::SymAttributeSet& Attrs,
bool IsNotBranch = false) override;
void printSymExprSuffix(std::ostream& OS, const gtirb::SymAttributeSet& Attrs,
bool IsNotBranch = false) override;
void printIntegralSymbol(std::ostream& os, const gtirb::Symbol& sym) override;
void printSymbolicExpression(std::ostream& os,
const gtirb::SymAddrConst* sexpr,
bool IsNotBranch = false) override;
void printSymbolicExpression(std::ostream& os,
const gtirb::SymAddrAddr* sexpr,
bool IsNotBranch = false) override;
};
class DEBLOAT_PRETTYPRINTER_EXPORT_API Mips32PrettyPrinterFactory
: public ElfPrettyPrinterFactory {
public:
Mips32PrettyPrinterFactory();
const PrintingPolicy&
defaultPrintingPolicy(gtirb::Module& Module) const override;
std::unique_ptr<PrettyPrinterBase>
create(gtirb::Context& context, gtirb::Module& module,
const PrintingPolicy& policy) override;
};
} // namespace gtirb_pprint
#endif /* GTIRB_PP_MIPS32_ASM_PRINTER_H */
| 40.741176 | 80 | 0.650303 | clayne |
42c47a6bdc233c1aec6d6c079f162658a30e50d9 | 900 | cpp | C++ | Chapter08/type_traits.cpp | markusbuchholz/Cpp-High-Performance-Second-Edition | 9d8ce97fae15a5f893a780fb3f8b187d11961a43 | [
"MIT"
] | 57 | 2020-07-09T22:54:31.000Z | 2022-03-31T14:18:41.000Z | Chapter08/type_traits.cpp | markusbuchholz/Cpp-High-Performance-Second-Edition | 9d8ce97fae15a5f893a780fb3f8b187d11961a43 | [
"MIT"
] | 5 | 2021-04-02T17:25:31.000Z | 2021-07-30T09:38:42.000Z | Chapter08/type_traits.cpp | PacktPublishing/Cpp-High-Performance-Second-Edition | 9d8ce97fae15a5f893a780fb3f8b187d11961a43 | [
"MIT"
] | 36 | 2019-12-25T19:30:47.000Z | 2022-03-16T16:41:02.000Z | #include <gtest/gtest.h>
#include <cstdint>
#include <type_traits>
TEST(TypeTraits, Categories) {
[[maybe_unused]] auto same_type = std::is_same_v<uint8_t, unsigned char>;
const auto is_float_or_double = std::is_floating_point_v<decltype(3.f)>;
static_assert(is_float_or_double);
}
TEST(TypeTraits, UserDefinedTypes) {
class Planet {};
class Mars : public Planet {};
class Sun {};
static_assert(std::is_base_of_v<Planet, Mars>);
static_assert(!std::is_base_of_v<Planet, Sun>);
}
template <typename T>
auto sign_func(const T& v) -> int {
if (std::is_unsigned_v<T>) {
return 1;
}
return v < 0 ? -1 : 1;
}
TEST(TypeTraits, SignFunction) {
{
auto unsigned_value = uint32_t{42};
auto sign = sign_func(unsigned_value);
ASSERT_EQ(1, sign);
}
{
auto signed_value = int32_t{-42};
auto sign = sign_func(signed_value);
ASSERT_EQ(-1, sign);
}
}
| 20.930233 | 75 | 0.675556 | markusbuchholz |
42c4e47992a1a973e9c225d979265980374d7035 | 27,577 | cpp | C++ | src/map.cpp | mokoi/luxengine | 965532784c4e6112141313997d040beda4b56d07 | [
"MIT"
] | null | null | null | src/map.cpp | mokoi/luxengine | 965532784c4e6112141313997d040beda4b56d07 | [
"MIT"
] | null | null | null | src/map.cpp | mokoi/luxengine | 965532784c4e6112141313997d040beda4b56d07 | [
"MIT"
] | null | null | null | /****************************
Copyright © 2006-2015 Luke Salisbury
This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
****************************/
#include "engine.h"
#include "elix/elix_string.hpp"
#include "display/display.h"
#include "mokoi_game.h"
#include "map_object.h"
#include "masks.h"
#include "map.h"
#include "entity.h"
#include "entity_manager.h"
#include "game_config.h"
#include "core.h"
#include "map_internal.h"
#include "map_xml_reader.h"
#include <algorithm>
bool ObjectSort(MapObject * a, MapObject * b );
/**
* @brief MokoiMap::MokoiMap
* @param name
* @param width
* @param height
*/
MokoiMap::MokoiMap( std::string name, uint32_t width, uint32_t height)
{
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_LOG) << " > Opening map '" << name << "'" << std::endl;
this->InitialSetup(name);
if ( width )
this->map_width = MAKE_INT_FIXED(width);
if ( height )
this->map_height = MAKE_INT_FIXED(height);
}
/**
* @brief MokoiMap::MokoiMap
* @param current_save_file
*/
MokoiMap::MokoiMap( elix::File * current_save_file )
{
if ( this->Restore( current_save_file ) )
{
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_LOG) << " > Restore map '" << this->map_name << "'" << std::endl;
}
}
/**
* @brief MokoiMap::~MokoiMap
*/
MokoiMap::~MokoiMap()
{
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_LOG) << " < Closing Map '" << this->map_name << "'"<< std::endl;
for ( MapObjectListIter p = this->object_cache.begin(); p != this->object_cache.end(); p++ )
{
delete p->second;
}
this->object_cache.clear();
if ( !this->screens.empty() )
{
for ( std::map<uint32_t, MokoiMapScreen *>::iterator q = this->screens.begin(); q != this->screens.end(); q++ )
{
delete q->second;
}
}
this->screens.clear();
if ( this->entities )
{
delete this->entities;
}
}
/**
* @brief MokoiMap::InitialSetup
* @param map_name
*/
void MokoiMap::InitialSetup( std::string map_name )
{
this->map_name = map_name;
this->loaded = false;
this->active = false;
this->reset_map = false;
this->keep_savedata = false;
this->keep_memory = false;
this->ident.value = 0;
this->centered_view = lux::config->GetBoolean("map.centerview");
this->object_cache_count = 0;
this->entities = NULL;
this->wrap_mode = MAP_WRAPNONE;
this->server = false;
this->entity_file_name = "maps/" + this->map_name;
this->screen_width = lux::config->GetFixed("screen.width");
this->screen_height = lux::config->GetFixed("screen.height");
this->default_map_width = lux::config->GetFixed("map.width");
this->default_map_height = lux::config->GetFixed("map.height");
this->dimension_width = 1;
this->dimension_height = 1;
this->has_width_different = ( this->default_map_width != this->screen_width );
this->has_height_different = ( this->default_map_height != this->screen_height );
this->map_width = this->default_map_width;
this->map_height = this->default_map_height;
this->offset_position[0] = 0;
this->offset_position[1] = 0;
this->offset_position[2] = 0;
this->grid[0] = 0;
this->grid[1] = 0;
}
/* Settings */
/**
* @brief MokoiMap::SetIdent
* @param ident
*/
void MokoiMap::SetIdent( uint32_t ident )
{
this->ident.value = ident;
}
/**
* @brief MokoiMap::SetGridIdent
* @param local
* @param section
*/
void MokoiMap::SetGridIdent( uint32_t local, uint32_t section )
{
this->ident.value = 0;
this->ident.grid.map = local;
this->ident.grid.section = section;
}
/**
* @brief MokoiMap::Ident
* @return
*/
uint32_t MokoiMap::Ident()
{
return this->ident.value;
}
/**
* @brief MokoiMap::GridIdent
* @return
*/
uint32_t MokoiMap::GridIdent()
{
return this->ident.grid.section;
}
/**
* @brief MokoiMap::InSection
* @param section
* @return
*/
bool MokoiMap::InSection(uint32_t section)
{
return (this->ident.grid.section == section);
}
/**
* @brief MokoiMap::Name
* @return
*/
std::string MokoiMap::Name()
{
return this->map_name;
}
/**
* @brief modify background colour
* @param mod LuxColour
*/
void MokoiMap::SetBackgroundModifier( LuxColour mod )
{
float fr, fg, fb;
fr = (float)mod.r / 255;
fg = (float)mod.g / 255;
fb = (float)mod.b / 255;
this->background_object.effects.primary_colour.r = (uint8_t)((float)this->base_background_colour.r * fr);
this->background_object.effects.primary_colour.g = (uint8_t)((float)this->base_background_colour.g * fg);
this->background_object.effects.primary_colour.b = (uint8_t)((float)this->base_background_colour.b * fb);
}
/**
* @brief MokoiMap::GetGrid
* @param axis
* @return
*/
uint8_t MokoiMap::GetGrid( uint8_t axis )
{
if ( axis == 'x')
return this->grid[0];
else
return this->grid[1];
}
/**
* @brief MokoiMap::Init
* @return
*/
bool MokoiMap::Init()
{
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_LOG) << " > MokoiMap Init " << this->map_name << std::endl;
lux::screen::display("Loading Map: " + this->map_name);
if ( this->LoadFile() )
{
lux::display->SetBackgroundObject( this->background_object );
this->active = true;
this->entities->Init();
this->NetworkMapSwitch();
}
else
{
lux::engine->FatalError("Map " + this->map_name + ".xml can't be loaded");
this->active = false;
}
return this->active;
}
/**
* @brief MokoiMap::Loop
* @return
*/
bool MokoiMap::Loop()
{
if ( !this->loaded )
{
lux::engine->ShowDialog("Map not loaded\nFile Name: " + this->map_name + "\n", DIALOGOK);
return false;
}
lux::display->SetBackgroundObject( this->background_object );
/* Cheats way of reseting map */
if ( this->reset_map )
{
this->Close();
this->LoadFile();
this->reset_map = false;
}
this->NetworkMapLoop();
this->entities->Loop();
/* Screens */
uint32_t screen_number = 0;
MokoiMapScreen * screen = NULL;
if ( this->dimension_width == 1 && this->dimension_height == 1 )
{
screen = this->GetScreen(screen_number);
if ( screen )
{
screen->Init();
}
}
else if ( this->wrap_mode )
{
/* Make sure the current screen and the 8 surround screens are loaded
todo: unload non-active screens
*/
screen_number = this->XY2Screen( MAKE_FIXED_INT(this->offset_position[0]), MAKE_FIXED_INT(this->offset_position[1]), this->dimension_width );
int32_t x = -1;
int32_t y = -1;
int32_t cx = 2;
int32_t cy = 2;
int32_t ty = -1;
if ( !(screen_number % this->dimension_width) ) // Left Row
x = 0;
if ( screen_number % (this->dimension_width-1) ) // Right Row
cx = 1;
if ( screen_number < this->dimension_width ) // Top Row
y = 0;
if ( screen_number > (this->dimension_height * (this->dimension_width-1))) // Bottom row
cy = 1;
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_DEBUG) << "Screen Loaded:";
for (; x < cx; x++)
{
for (ty = y; ty < cy; ty++)
{
screen = this->GetScreen( (screen_number+x) + (ty*this->dimension_width) );
if ( screen )
{
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_DEBUG) << (int)((screen_number+x) + (ty*this->dimension_width)) << "(" << Screen2X(screen_number,this->dimension_width)+x << "x" << Screen2Y(screen_number,this->dimension_width)+ty << "),";
screen->Init();
}
}
}
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_DEBUG) << std::endl;
}
else
{
/* Make sure the current screen and the 8 surround screens are loaded
todo: unload non-active screens
*/
screen_number = this->XY2Screen( MAKE_FIXED_INT(this->offset_position[0]), MAKE_FIXED_INT(this->offset_position[1]), this->dimension_width );
int32_t x = -1;
int32_t y = -1;
int32_t cx = 2;
int32_t cy = 2;
int32_t ty = -1;
if ( !(screen_number % this->dimension_width) ) // Left Row
x = 0;
if ( screen_number % (this->dimension_width-1) ) // Right Row
cx = 1;
if ( screen_number < this->dimension_width ) // Top Row
y = 0;
if ( screen_number > (this->dimension_height * (this->dimension_width-1))) // Bottom row
cy = 1;
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_DEBUG) << "Screen Loaded:";
for (; x < cx; x++)
{
for (ty = y; ty < cy; ty++)
{
screen = this->GetScreen( (screen_number+x) + (ty*this->dimension_width) );
if ( screen )
{
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_DEBUG) << (int)((screen_number+x) + (ty*this->dimension_width)) << "(" << Screen2X(screen_number,this->dimension_width)+x << "x" << Screen2Y(screen_number,this->dimension_width)+ty << "),";
screen->Init();
}
}
}
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_DEBUG) << std::endl;
}
return true;
}
/*
* MokoiMap::Close()
* Keeps Map in memory, just unload every thing else.
*/
bool MokoiMap::Close()
{
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_LOG) << " < MokoiMap Close " << this->map_name << std::endl;
this->active = false;
this->server = false;
/* Reset Display */
lux::display->ClearLayers(true);
lux::display->SetCameraView( 0, 0 );
lux::display->ResetBackgroundObject( );
/* Clean up Screens */
std::map<uint32_t, MokoiMapScreen *>::iterator q = this->screens.begin();
for ( ; q != this->screens.end(); q++ )
{
q->second->Close();
}
/* Clean Up Map Object */
for ( MapObjectListIter p = this->object_cache.begin(); p != this->object_cache.end(); p++ )
{
p->second->FreeData();
}
/* Clean Up Entity */
this->entities->Close();
return true;
}
std::string MokoiMap::GetInfo()
{
std::stringstream s;
s << "§6Objects:" << this->object_cache.size()<< " §cEntities:" << this->entities->children.size() << " §aScreen:" << this->screens.size();
return s.str();
}
bool MokoiMap::Reset()
{
this->reset_map = true;
return true;
}
/* Object Handling */
void MokoiMap::AddObjectToScreens( MapObject * object )
{
uint32_t screen_number = 0;
MokoiMapScreen * screen = NULL;
int32_t sx = (object->position.x/this->default_map_width)*this->default_map_width;
int32_t sy = (object->position.y/this->default_map_height)*this->default_map_height;
int32_t sw = object->position.w ? object->position.w : object->sprite_width;
int32_t sh = object->position.h ? object->position.h : object->sprite_height;
//note to self: may be wrong for lines
if ( this->dimension_width > 1 || this->dimension_height > 1 )
{
while ( sx < object->position.x + sw )
{
sy = object->position.y;
while ( sy < object->position.y + sh )
{
screen_number = XY2Screen( sx, sy, this->dimension_width );
screen = this->GetScreen(screen_number);
if ( screen )
{
screen->_objects.push_back(object);
}
sy += this->default_map_height;
}
sx += this->default_map_width;
}
}
else
{
screen_number = XY2Screen( object->position.x, object->position.y, this->dimension_width );
screen = this->GetScreen(screen_number);
if ( screen )
screen->_objects.push_back(object);
}
}
uint32_t MokoiMap::AddObject(MapObject * object, bool is_static )
{
uint32_t object_id = 0;
object->SetData( object->type );
if ( object->has_data )
{
this->object_cache_count++;
if ( is_static )
{
object->SetStaticMapID( this->object_cache_count, false );
object_id = object->GetStaticMapID();
this->object_cache[object_id] = object;
}
if ( this->active )
{
lux::display->AddObjectToLayer(object->layer, object, is_static );
}
}
return object_id;
}
MapObject * MokoiMap::GetObject( uint32_t ident )
{
if ( !this->object_cache.empty() )
{
MapObjectListIter iter = this->object_cache.find(ident);
if( iter != this->object_cache.end() )
return iter->second;
}
return NULL;
}
void MokoiMap::ReplaceObjectsSheets( std::string old_sheet, std::string new_sheet )
{
for ( MapObjectListIter p = this->object_cache.begin(); p != this->object_cache.end(); p++ )
{
MapObject * object = p->second;
if ( object->type == OBJECT_SPRITE )
{
std::string sheet = object->sprite.substr(0, object->sprite.find_first_of(':'));
if ( !old_sheet.compare( sheet ) )
{
object->FreeData();
std::string sprite = object->sprite.substr(object->sprite.find_first_of(':'));
object->sprite = new_sheet + sprite;
object->SetData( OBJECT_SPRITE);
}
}
}
}
bool MokoiMap::RemoveObject( uint32_t ident )
{
MapObject * object = this->GetObject(ident);
if ( object )
{
lux::display->RemoveObject(object->layer, object);
this->object_cache.erase(ident);
if ( !object->layer_reference )
delete object;
return true;
}
return false;
}
/* Positions */
void MokoiMap::SetPosition( fixed position[3] )
{
this->offset_position[0] = position[0];
this->offset_position[1] = position[1];
this->offset_position[2] = position[2];
lux::core->SystemStreamMessage(SYSTEM_MESSAGE_DEBUG) << "Wrap: " << (int)this->wrap_mode << " - Centerview:" << (int)this->centered_view << std::endl;
/*
Keeps Offset for moving offscreen
*/
if ( this->centered_view )
{
fixed offset, wrap_offset = 0;
/* X Axis Wrapping handling */
if ( this->wrap_mode == MAP_WRAPXAXIS || this->wrap_mode == MAP_WRAPBOTH )
{
if ( position[0] > this->map_width )
{
wrap_offset = (position[0] / this->map_width) * this->map_width;
position[0] %= this->map_width;
}
}
/* X Axis handle*/
if ( this->dimension_width > 1 ) // Center the View
{
if ( position[0] < (screen_width / 2) )
{
this->offset_position[0] = 0;
}
else if ( position[0] > (this->map_width - (this->screen_width / 2)) )
{
this->offset_position[0] = this->map_width - this->screen_width;
}
else
{
this->offset_position[0] = position[0] - (this->screen_width/2);
}
}
else if ( this->has_width_different ) // If Screen dimension is maps, then try to account for that
{
offset = this->map_width - this->screen_height;
if ( position[0] > (this->screen_width - offset) )
{
this->offset_position[0] = this->map_width - this->screen_width;
}
else if ( position[0] > offset )
{
this->offset_position[0] -= offset;
}
else
{
this->offset_position[0] = 0;
}
}
else// No view position change needed.
{
this->offset_position[0] = 0;
}
this->offset_position[0] += wrap_offset;
wrap_offset = 0;
if ( this->wrap_mode == MAP_WRAPBOTH || this->wrap_mode == MAP_WRAPYAXIS )
{
if ( position[1] > this->map_height )
{
wrap_offset = (position[1] / this->map_height) * this->map_height;
position[1] %= this->map_height;
}
}
/* Y Axis handle*/
if ( this->dimension_height > 1 ) // Center the View
{
if ( position[1] < (screen_height / 2) )
{
this->offset_position[1] = 0;
}
else if ( position[1] > (this->map_height - (this->screen_height / 2)) )
{
this->offset_position[1] = this->map_height - this->screen_height;
}
else
{
this->offset_position[1] = position[1] - (this->screen_height / 2);
}
}
else if ( this->has_height_different ) // If Screen dimension is maps, then try to account for that
{
offset = this->map_height - this->screen_height;
if ( position[1] > (this->screen_height - offset) )
{
this->offset_position[1] = this->map_height - this->screen_height;
}
else if ( position[1] > offset )
{
this->offset_position[1] -= offset;
}
else
{
this->offset_position[1] = 0;
}
}
else // No view position change needed.
{
this->offset_position[1] = 0;
}
this->offset_position[1] += wrap_offset;
}
else
{
/* Using the top left for position */
if ( this->wrap_mode == MAP_WRAPNONE || this->wrap_mode == MAP_WRAPYAXIS )
{
this->offset_position[0] = clamp(this->offset_position[0], 0, this->map_width - this->screen_width);
}
if ( this->wrap_mode == MAP_WRAPNONE || this->wrap_mode == MAP_WRAPXAXIS )
{
this->offset_position[1] = clamp(this->offset_position[1], 0, this->map_height - this->screen_height);
}
}
}
fixed MokoiMap::GetPosition( uint8_t axis )
{
if ( axis < 3 )
{
return this->offset_position[axis];
}
return 0;
}
void MokoiMap::SetScrolling( bool scroll )
{
this->centered_view = scroll;
}
/* Entities */
EntitySection * MokoiMap::GetEntities()
{
return this->entities;
}
/* Save System */
/**
* @brief MokoiMap::Save
* @param current_save_file
* @return
*/
bool MokoiMap::Save( elix::File * current_save_file )
{
current_save_file->WriteWithLabel("Map Name", this->map_name );
current_save_file->WriteWithLabel("Map ID", this->ident.value );
current_save_file->WriteWithLabel("Map Width", (uint32_t)this->map_width);
current_save_file->WriteWithLabel("Map Height", (uint32_t)this->map_height);
current_save_file->WriteWithLabel("Map Background", this->base_background_colour.r );
current_save_file->WriteWithLabel("Map Background", this->base_background_colour.b );
current_save_file->WriteWithLabel("Map Background", this->base_background_colour.g );
current_save_file->WriteWithLabel("Map Loaded Flag", (uint8_t)this->loaded );
if ( this->entities )
{
current_save_file->WriteWithLabel("Map has Entities", (uint8_t)1 );
this->entities->Save( current_save_file );
}
else
{
current_save_file->WriteWithLabel("Map has Entities", (uint8_t)0 ); // Write 0 for empty Entity Section
}
/* Map Display Object */
uint32_t count = this->object_cache.size();
current_save_file->WriteWithLabel("Map Display Objects", count );
if ( count )
{
MapObjectList::iterator iter = this->object_cache.begin();
while( iter != this->object_cache.end() )
{
iter->second->Save( current_save_file );
iter++;
}
}
return true;
}
/**
* @brief MokoiMap::Restore
* @param current_save_file
* @return
*/
bool MokoiMap::Restore( elix::File * current_save_file )
{
uint32_t count = 0;
uint8_t map_loading_flag = 0;
uint8_t map_has_entities = 0;
current_save_file->ReadWithLabel("Map Name", &this->map_name );
this->InitialSetup(this->map_name);
this->ident.value= current_save_file->ReadUint32WithLabel("Map ID", true );
this->map_width = current_save_file->ReadUint32WithLabel("Map Width");
this->map_height = current_save_file->ReadUint32WithLabel("Map Height");
this->background_object.effects.primary_colour.r = this->base_background_colour.r = current_save_file->ReadUint8WithLabel("Map Background");
this->background_object.effects.primary_colour.g = this->base_background_colour.g = current_save_file->ReadUint8WithLabel("Map Background");
this->background_object.effects.primary_colour.b = this->base_background_colour.b = current_save_file->ReadUint8WithLabel("Map Background");
map_loading_flag = current_save_file->ReadUint8WithLabel("Map Loaded Flag");
/* Entities */
this->entities = new EntitySection( this->entity_file_name, this->ident.value );
map_has_entities = current_save_file->ReadUint8WithLabel("Map has Entities");
if ( map_has_entities )
{
this->entities->Restore( current_save_file );
}
/* Map Display Object */
this->object_cache_count = current_save_file->ReadUint32WithLabel("Map Display Objects", true );
if ( this->object_cache_count )
{
for( uint32_t i = 0; i < this->object_cache_count; i++ )
{
MapObject * existing_object = NULL;
existing_object = new MapObject( current_save_file );
this->object_cache[existing_object->GetStaticMapID()] = existing_object;
if ( existing_object->type == OBJECT_VIRTUAL_SPRITE )
{
LuxVirtualSprite * sprite = existing_object->InitialiseVirtual( );
sprite->PushObjectsToMap( existing_object, this->object_cache, ++object_cache_count, false );
}
}
}
this->loaded = true;
return true;
}
/* Screen */
/**
* @brief MokoiMap::GetScreen
* @param screen_number
* @param init_new
* @return
*/
MokoiMapScreen * MokoiMap::GetScreen(uint32_t screen_number, bool init_new)
{
if ( this->dimension_width == 1 && this->dimension_height == 1 )
screen_number = 0;
if ( screen_number > (this->dimension_width * this->dimension_height)-1 )
return NULL;
if ( !this->screens.empty() )
{
std::map<uint32_t, MokoiMapScreen *>::iterator iter = this->screens.find(screen_number);
if( iter != this->screens.end() )
return iter->second;
}
MokoiMapScreen * new_screen = new MokoiMapScreen( Screen2X(screen_number, this->dimension_width), Screen2Y(screen_number, this->dimension_width), MAKE_FIXED_INT(this->default_map_width), MAKE_FIXED_INT(this->default_map_height) );
this->screens.insert( std::make_pair( screen_number, new_screen) );
//if (init_new)
// new_screen->Init();
return new_screen;
}
/*
MokoiMapScreen * MokoiMap::UnloadScreen(uint32_t screen_number, bool init_new)
{
if ( this->width == 1 && this->height == 1 )
screen_number = 0;
if ( screen_number > (this->width * this->height)-1 )
return NULL;
std::map<uint32_t, MokoiMapScreen *>::iterator iter = this->_screen.find(screen_number);
if( iter != this->_screen.end() )
return iter->second;
MokoiMapScreen * new_screen = new MokoiMapScreen( Screen2X(screen_number, this->width), Screen2Y(screen_number, this->width), this->default_map_width, this->default_map_height );
this->_screen.insert( std::make_pair( screen_number, new_screen) );
return new_screen;
}
MokoiMapScreen * MokoiMap::LoadAllScreen(uint32_t screen_number, bool init_new)
{
if ( this->width == 1 && this->height == 1 )
screen_number = 0;
if ( screen_number > (this->width * this->height)-1 )
return NULL;
std::map<uint32_t, MokoiMapScreen *>::iterator iter = this->_screen.find(screen_number);
if( iter != this->_screen.end() )
return iter->second;
MokoiMapScreen * new_screen = new MokoiMapScreen( Screen2X(screen_number, this->width), Screen2Y(screen_number, this->width), this->default_map_width, this->default_map_height );
this->_screen.insert( std::make_pair( screen_number, new_screen) );
return new_screen;
}
*/
/**
* @brief MokoiMap::XY2Screen
* @param x
* @param y
* @param w
* @return
*/
uint32_t MokoiMap::XY2Screen(int32_t x, int32_t y, int32_t w)
{
if ( this->wrap_mode )
{
int32_t mw = MAKE_FIXED_INT(this->map_width);
int32_t mh = MAKE_FIXED_INT(this->map_height);
while ( x > mw )
{
x -= mw;
}
while ( y > mh )
{
y -= mh;
}
return (uint32_t)(((y/this->default_map_height)*w)+(x/this->default_map_height));
}
else
{
return (uint32_t)(((y/this->default_map_height)*w)+(x/this->default_map_height));
}
}
/* Data */
/**
* @brief MokoiMap::Valid
* @return
*/
bool MokoiMap::Valid()
{
return this->loaded;
}
/*
* MokoiMap::LoadDimension()
* Todo: Optimise code.
*/
bool MokoiMap::LoadDimension()
{
if ( !this->loaded )
{
tinyxml2::XMLDocument * xml_file = MokoiGame_GetXML("./maps/" + this->map_name + ".xml");
if ( xml_file->Error() )
{
//lux::core->SystemStreamMessage(__FILE__ , __LINE__, SYSTEM_MESSAGE_ERROR) << " | " << xml_file->ErrorDesc() << " Row: " << xml_file->ErrorRow() << std::endl;
delete xml_file;
return false;
}
if ( !xml_file->RootElement() || strcmp( xml_file->RootElement()->Value(), "map") )
{
lux::core->SystemStreamMessage(__FILE__ , __LINE__, SYSTEM_MESSAGE_ERROR) << " | maps/" + this->map_name + ".xml not a vamap_nameap file." << std::endl;
delete xml_file;
return false;
}
tinyxml2::XMLElement * dimensions_elem = xml_file->RootElement()->FirstChildElement("settings")->FirstChildElement("dimensions");
if ( dimensions_elem )
{
tinyxml2::QueryUnsignedAttribute( dimensions_elem, "width", this->dimension_width);
tinyxml2::QueryUnsignedAttribute( dimensions_elem, "height", this->dimension_height);
}
this->map_width = ( this->dimension_width * this->default_map_width );
this->map_height = ( this->dimension_height * this->default_map_height );
delete xml_file;
return true;
}
return false;
}
/**
* @brief MokoiMap::SaveFile
* @return
*/
bool MokoiMap::SaveFile()
{
lux::screen::display("Saving Map: " + this->map_name);
return false;
}
/**
* @brief MokoiMap::LoadFile
* @return
*/
bool MokoiMap::LoadFile()
{
if ( this->loaded )
return this->loaded;
MapXMLReader reader;
std::map<std::string, std::string> settings;
this->wrap_mode = MAP_WRAPNONE;
this->entities = new EntitySection( this->entity_file_name, this->ident.value );
if ( lux::game_data->HasFile("./maps/" + this->map_name + ".xml") )
{
if ( !reader.Load("./maps/" + this->map_name + ".xml"))
{
lux::core->SystemStreamMessage(__FILE__ , __LINE__, SYSTEM_MESSAGE_ERROR) << " | maps/" + this->map_name + ".xml not a valid file." << std::endl;
return false;
}
reader.ReadSettings( this, settings );
for ( std::map<std::string, std::string>::iterator cs = settings.begin(); cs != settings.end(); cs++ )
{
if ( !cs->first.compare("wrap") )
{
this->wrap_mode = elix::string::ToIntU8(cs->second);
}
if ( this->entities->parent )
{
this->entities->parent->AddSetting( cs->first, cs->second );
}
}
/* Read Display Object */
reader.ReadObjectsWithEntities( this->object_cache, this );
this->object_cache_count = this->object_cache.size();
/* Set up Map Screen */
for ( MapObjectListIter p = this->object_cache.begin(); p != this->object_cache.end(); p++ )
{
p->second->SetData( p->second->type );
this->AddObjectToScreens( p->second );
}
std::map<uint32_t, MokoiMapScreen *>::iterator q = this->screens.begin();
for ( ; q != this->screens.end(); q++ )
{
q->second->SortObjects();
}
}
this->loaded = true;
return true;
}
bool MokoiMap::HasSnapshot()
{
return false;
}
bool MokoiMap::SaveSnapshot()
{
return false;
}
bool MokoiMap::LoadSnapshot()
{
return false;
}
/* Mask Functions */
uint16_t MokoiMap::GetMaskValue(uint16_t x, uint16_t y)
{
MokoiMapScreen * screen = NULL;
screen = this->GetScreen( XY2Screen( x, y, this->dimension_width ) );
if ( screen )
return screen->GetMaskValue(x, y);
return 0xFFFF;
}
void MokoiMap::FillMask(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint8_t value)
{
uint32_t screen_number = 0;
MokoiMapScreen * screen = NULL;
int32_t sx = x;
int32_t sy = y;
if ( this->dimension_width > 1 || this->dimension_height > 1 )
{
while ( sx < x + width )
{
while ( sy < y + height )
{
screen_number = XY2Screen( sx, sy, this->dimension_width );
screen = this->GetScreen(screen_number);
if ( screen )
screen->FillMask(x, y, width, height, value);
sy += this->default_map_height;
}
sx += this->default_map_width;
}
}
else
{
screen = this->GetScreen(screen_number);
if ( screen )
screen->FillMask(x, y, width, height, value);
}
}
void MokoiMap::BuildMask()
{
std::map<uint32_t, MokoiMapScreen *>::iterator q = this->screens.begin();
for ( ; q != this->screens.end(); q++ )
{
q->second->BuildMask();
}
//Lux_Mask * sprite_mask = Lux_Mask_New(0, 0);
//Lux_Mask_Load("test.mask", sprite_mask);
//Lux_Mask_CopyArea(sprite_mask, map_mask, 10, 10);
//Lux_Mask_FillArea(map_mask, 5, 0, 10, 20, 69);
}
void MokoiMap::DrawMask()
{
std::map<uint32_t, MokoiMapScreen *>::iterator q = this->screens.begin();
for ( ; q != this->screens.end(); q++ )
{
q->second->DrawMask(this->offset_position);
}
}
| 26.016038 | 243 | 0.671175 | mokoi |
42cb9358ab3bbd856ec3fada1b050b6acb91d258 | 2,140 | cpp | C++ | Data Structures/Linked List/20. Bubble sort by changing pointers.cpp | Ashwanigupta9125/code-DS-ALGO | 49f6cf7d0c682da669db23619aef3f80697b352b | [
"MIT"
] | 36 | 2019-12-27T08:23:08.000Z | 2022-01-24T20:35:47.000Z | Data Structures/Linked List/20. Bubble sort by changing pointers.cpp | Ashwanigupta9125/code-DS-ALGO | 49f6cf7d0c682da669db23619aef3f80697b352b | [
"MIT"
] | 10 | 2019-11-13T02:55:18.000Z | 2021-10-13T23:28:09.000Z | Data Structures/Linked List/20. Bubble sort by changing pointers.cpp | Ashwanigupta9125/code-DS-ALGO | 49f6cf7d0c682da669db23619aef3f80697b352b | [
"MIT"
] | 53 | 2020-08-15T11:08:40.000Z | 2021-10-09T15:51:38.000Z | #include<iostream>
using namespace std;
// BUGGY CODE
//Finding it hard to implement . Will do later.
//For now data is being swapped like array.
struct node{
int data;
struct node*next;
};
struct node*newNode(int data){
struct node*temp = new struct node;
temp->data = data;
temp->next = NULL;
return temp;
}
void pushFront(struct node**head,int data){
struct node* first = newNode(data);
if(*head==NULL){
*head = first;
}
else{
first->next = (*head);
*head = first;
}
}
void print(struct node*head){
struct node*current = head;
while(current!=NULL){
cout<<current->data<<"->";
current=current->next;
}
cout<<endl;
}
int getSize(struct node*head){
if(head==NULL)
return 0;
else{
int count=0;
while(head!=NULL){
count++;
head=head->next;
}
return count;
}
}
//-----------------------------------Bubble Sort
void swap(struct node**head,struct node*a,struct node*b,struct node*c){
if(a==NULL){
struct node*cnext = c->next;
*head = c;
c->next = a;
a->next = cnext;
}
else{
struct node*cnext = c->next;
a->next = c;
c->next = b;
b->next = cnext;
}
return ;
}
void bubbleSort(struct node**head){
int i;
bool swapped = false;
struct node*current=*head;
struct node*rightEnd=NULL;
struct node*prev = NULL;
if(current==NULL)
return ;
do{
swapped = false;
current = (*head);
while(current->next!=rightEnd){
if(current->data>current->next->data){
swap(head,prev,current,current->next);
swapped = true;
}
prev = current;
current = current->next;
}
rightEnd = current;
}
while(swapped);
//When they are no swapping in the list means the list is sorted .
// It will run in O(n) if the list is already sorted
return ;
}
int main(){
struct node*head = NULL;
pushFront(&head,1);
pushFront(&head,5);
pushFront(&head,3);
pushFront(&head,2);
pushFront(&head,0);
print(head);
bubbleSort(&head);
cout<<"After Bubble sort :"<<endl;
print(head);
return 0;
}
| 17.68595 | 71 | 0.580841 | Ashwanigupta9125 |
42cc32b2f9e8f282ad0d65f4ce87d2939c5fb62c | 602 | cpp | C++ | Data Structure/Array Or Vector/Selection Sort/SolutionbyMashiyatHussain.cpp | rajethanm4/Programmers-Community | d16083eb0e84403159d999d4d1a8bbf652ca51f6 | [
"MIT"
] | 8 | 2020-11-07T10:29:21.000Z | 2020-12-26T16:54:13.000Z | Data Structure/Array Or Vector/Selection Sort/SolutionbyMashiyatHussain.cpp | rajethanm4/Programmers-Community | d16083eb0e84403159d999d4d1a8bbf652ca51f6 | [
"MIT"
] | null | null | null | Data Structure/Array Or Vector/Selection Sort/SolutionbyMashiyatHussain.cpp | rajethanm4/Programmers-Community | d16083eb0e84403159d999d4d1a8bbf652ca51f6 | [
"MIT"
] | null | null | null | #include <stdio.h>
void main()
{
int n,c,d,position,swap;
printf("Enter number of elements\n");
scanf("%d",&n);
int array[n];
printf("Enter %d integers\n",n);
for(c=0;c<n;c++)
scanf("%d",&array[c]);
for(c=0;c<(n-1);c++) {
position=c;
for(d=c+1;d<n;d++) {
if(array[position]>array[d])
position=d;
}
if(position !=c) {
swap = array[c];
array[c] = array[position];
array[position] = swap;
}
}
printf("Sorted list in ascending order:\n");
for(c = 0; c<n; c++)
printf("%d\n", array[c]);
getch();
}
| 20.066667 | 47 | 0.496678 | rajethanm4 |
42d1d227a1da8c56599d64f181074e00aefff000 | 3,489 | cpp | C++ | Source/GUI/Submenus/Miscellaneous.cpp | HatchesPls/GrandTheftAutoV-Cheat | f06011362a0a8297439b260a670f5091118ef5de | [
"curl",
"MIT"
] | 31 | 2021-07-13T21:24:58.000Z | 2022-03-31T13:04:38.000Z | Source/GUI/Submenus/Miscellaneous.cpp | HatchesPls/GrandTheftAutoV-Cheat | f06011362a0a8297439b260a670f5091118ef5de | [
"curl",
"MIT"
] | 12 | 2021-07-28T16:53:58.000Z | 2022-03-31T22:51:03.000Z | Source/GUI/Submenus/Miscellaneous.cpp | HowYouDoinMate/GrandTheftAutoV-Cheat | 1a345749fc676b7bf2c5cd4df63ed6c9b80ff377 | [
"curl",
"MIT"
] | 12 | 2020-08-16T15:57:52.000Z | 2021-06-23T13:08:53.000Z | #include "../Header/Cheat Functions/FiberMain.h"
using namespace Cheat;
int FakeWantedLevelInteger = 0;
void GUI::Submenus::Miscellaneous()
{
GUI::Title("Miscellaneous");
GUI::MenuOption("Report Statistics", Submenus::ReportStatistics);
GUI::MenuOption("Radio", Submenus::Radio);
GUI::MenuOption("Extra-sensory Perception", Submenus::ESP);
GUI::MenuOption("HUD", Submenus::HUD);
GUI::MenuOption("IPL Loader", Submenus::IPLLoader);
if (GUI::Int("Fake Wanted Level", FakeWantedLevelInteger, 0, 6, 1, "Select to change", SELECTABLE_DISABLE_SAVE | SELECTABLE_RETURN_VALUE_CHANGE))
{
GAMEPLAY::SET_FAKE_WANTED_LEVEL(FakeWantedLevelInteger);
}
GUI::Toggle("Disable Mobile Phone", CheatFeatures::DisableMobilePhoneBool, "Disable Mobile Phone");
GUI::Toggle("No-Clip", CheatFeatures::NoClipBool, "Use W and mouse to control");
GUI::Toggle("Jump Around Mode", CheatFeatures::JumpAroundModeBool, "Nearby vehicles will 'jump around'");
GUI::Toggle("Free Cam", CheatFeatures::FreeCamBool, "Use W and S to control. Shift to go faster");
GUI::Toggle("Show Joining Players Notification", CheatFeatures::ShowJoiningPlayersNotification, "");
GUI::Toggle("Rockstar Developer Mode", CheatFeatures::GTAODeveloperMode, "Toggles GTAO Spectator Options");
GUI::Toggle("Show Session Information", CheatFeatures::ShowSessionInformationBool, "Show session info (next to radar)");
GUI::Toggle("Show FPS", CheatFeatures::ShowFPSBool, "");
if (GUI::Option("Stop Cutscene", ""))
{
CUTSCENE::STOP_CUTSCENE_IMMEDIATELY();
}
if (GUI::Option("Stop spectating player", ""))
{
CheatFeatures::SpectatePlayerBool = false;
}
if (GUI::Option("Drive To Waypoint", "A NPC drives you to waypoint"))
{
int WaypointHandle = UI::GET_FIRST_BLIP_INFO_ID(SpriteWaypoint);
if (UI::DOES_BLIP_EXIST(WaypointHandle))
{
std::string VehicleName = "MARSHALL";
Vector3 WayPointVector = UI::GET_BLIP_COORDS(WaypointHandle);
STREAMING::REQUEST_MODEL(GAMEPLAY::GET_HASH_KEY(CheatFunctions::StringToChar(VehicleName)));
while (!STREAMING::HAS_MODEL_LOADED(GAMEPLAY::GET_HASH_KEY(CheatFunctions::StringToChar(VehicleName)))) { GameHooking::PauseMainFiber(0); }
Vector3 pos = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(GameFunctions::PlayerPedID, 0.0, 5.0, 0);
::Vehicle VehicleHandle = VEHICLE::CREATE_VEHICLE(GAMEPLAY::GET_HASH_KEY(CheatFunctions::StringToChar(VehicleName)), pos.x, pos.y, pos.z, ENTITY::GET_ENTITY_HEADING(GameFunctions::PlayerPedID), 1, 1);
if (VehicleHandle != 0)
{
Ped Driver = PED::CREATE_RANDOM_PED_AS_DRIVER(VehicleHandle, false);
PED::SET_PED_INTO_VEHICLE(Driver, VehicleHandle, -1);
PED::SET_PED_INTO_VEHICLE(GameFunctions::PlayerPedID, VehicleHandle, 0);
AI::TASK_VEHICLE_DRIVE_TO_COORD(Driver, VehicleHandle, WayPointVector.x, WayPointVector.y, WayPointVector.z, 40, 1, ENTITY::GET_ENTITY_MODEL(VehicleHandle), 7, 6, -1);
VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT(VehicleHandle, "CRUSADER");
GameFunctions::MinimapNotification("NPC Driver Spawned");
}
}
else { GameFunctions::MinimapNotification("Please set a waypoint first to use this feature"); }
}
if (GUI::Option("Get Empty Session", "Get Empty (Public) Session")) { Sleep(10000); }
if (GUI::Option("Exit to Single Player", "")) { GameFunctions::ChangeGTAOSessionType(SessionTypeLeaveOnline); }
if (GUI::Option("Close Game", "You must hold spacebar to prevent accidental closure")) { if (CheatFunctions::IsKeyCurrentlyPressed(VK_SPACE)) { std::exit(EXIT_SUCCESS); } }
} | 59.135593 | 203 | 0.753224 | HatchesPls |
42d280720e9c73dd149d2943ec20bca78a661570 | 3,034 | hpp | C++ | src/fenestra/Loop.hpp | cout/fenestra | b3424b427a1c8820a5586b09641e1589271fb567 | [
"BSD-3-Clause"
] | 2 | 2021-09-27T03:28:17.000Z | 2022-01-06T13:38:24.000Z | src/fenestra/Loop.hpp | cout/fenestra | b3424b427a1c8820a5586b09641e1589271fb567 | [
"BSD-3-Clause"
] | null | null | null | src/fenestra/Loop.hpp | cout/fenestra | b3424b427a1c8820a5586b09641e1589271fb567 | [
"BSD-3-Clause"
] | null | null | null | #pragma once
#include "Frontend.hpp"
#include "Clock.hpp"
#include "Context.hpp"
#include "Probe.hpp"
#include <utility>
#include <map>
namespace fenestra {
class Loop {
public:
Loop(Frontend & frontend, Context & ctx)
: frontend_(frontend)
, ctx_(ctx)
{
}
template <typename Fn>
void step(Probe & probe, std::optional<Probe::Depth> depth, Probe::Key key, Fn && fn) {
try {
auto now = Clock::gettime(CLOCK_MONOTONIC);
if (depth) probe.mark(key, *depth, now);
std::forward<Fn>(fn)();
} catch(std::exception const & ex) {
std::cout << "error during " << frontend_.probe_dict()[key] << ": " << ex.what() << std::endl;
} catch(...) {
std::cout << "error during " << frontend_.probe_dict()[key] << ": unknown error" << std::endl;
}
}
void run_core(Probe & probe) {
if (!frontend_.paused()) {
frontend_.probe().clear();
ctx_.run_core();
probe.append(frontend_.probe());
}
}
void run() {
auto final_key = frontend_.probe_dict()["---"];
auto pre_frame_delay_key = frontend_.probe_dict()["Pre frame delay"];
auto poll_window_events_key = frontend_.probe_dict()["Poll window events"];
auto frame_delay_key = frontend_.probe_dict()["Frame delay"];
auto core_run_key = frontend_.probe_dict()["Core run"];
auto video_key = frontend_.probe_dict()["Video"];
auto render_key = frontend_.probe_dict()["Render"];
auto update_delay_key = frontend_.probe_dict()["Update delay"];
auto update_key = frontend_.probe_dict()["Update"];
auto sync_key = frontend_.probe_dict()["Sync"];
Probe probe;
frontend_.start_metrics(probe);
// Make sure this is always the first probe, otherwise we will show
// the timing for the previous perf_record as if it were the one
// that happened in this loop iteration.
probe.mark(pre_frame_delay_key, 0, Clock::gettime(CLOCK_MONOTONIC));
while (!frontend_.done()) {
frontend_.pre_frame_delay();
step(probe, 0, poll_window_events_key, [&] { frontend_.poll_window_events(); });
step(probe, 0, frame_delay_key, [&] { frontend_.frame_delay(); });
step(probe, 0, core_run_key, [&] { run_core(probe); });
step(probe, 0, video_key, [&] {
step(probe, 1, render_key, [&] { frontend_.video_render(); });
step(probe, 1, update_delay_key, [&] { frontend_.window_update_delay(); });
step(probe, 1, update_key, [&] { frontend_.window_update(); });
step(probe, std::nullopt, sync_key, [&] { frontend_.window_sync(); });
});
auto pre_frame_delay_start_time = Clock::gettime(CLOCK_MONOTONIC);
probe.mark(final_key, Probe::FINAL, 0, pre_frame_delay_start_time);
frontend_.collect_metrics(probe);
frontend_.record_probe(probe);
probe.clear();
probe.mark(pre_frame_delay_key, 0, pre_frame_delay_start_time);
}
}
private:
Frontend & frontend_;
Context & ctx_;
};
}
| 33.711111 | 100 | 0.625577 | cout |
42d28464895e250b9b7be6bae0fb8ee1e48889fc | 4,897 | cpp | C++ | src/BasicParser.cpp | cyh2020/stone_compiler_cplus | 3b367628095cb3ea9d1a58ad74af87b6c853c3c0 | [
"MIT"
] | null | null | null | src/BasicParser.cpp | cyh2020/stone_compiler_cplus | 3b367628095cb3ea9d1a58ad74af87b6c853c3c0 | [
"MIT"
] | null | null | null | src/BasicParser.cpp | cyh2020/stone_compiler_cplus | 3b367628095cb3ea9d1a58ad74af87b6c853c3c0 | [
"MIT"
] | null | null | null | #include "BasicParser.h"
#include "Token.h"
#include "Parser.h"
#include "ParserDerived.h"
#include <set>
#include <string>
#include "PrimaryExpr.h"
#include "NumberLiteral.h"
#include "Name.h"
#include "StringLiteral.h"
#include "NegativeExpr.h"
#include "BinaryExpr.h"
#include "BlockStmnt.h"
#include "IfStmnt.h"
#include "WhileStmnt.h"
#include "NullStmnt.h"
#include "lexer.h"
#include "list"
using std::list;
using std::string;
//!!!!!!!!!!!!!!!!!!!!!!!Parsers must be declared in .h file !!!!!!!!!!!!!!!
BasicParser::BasicParser()
{
reserved.insert(";");
reserved.insert("}");
reserved.insert("\\n");
// trueAssoc bool LEFT = true;bool RIGHT = false;
operators.add("=", 1, false);
operators.add("==", 2, true);
operators.add(">", 2, true);
operators.add("<", 2, true);
operators.add("+", 3, true);
operators.add("-", 3, true);
operators.add("*", 4, true);
operators.add("/", 4, true);
operators.add("%", 4, true);
//--------------------expr0------------------------//
// Parser expr0;
//--------------------primary----------------------//
// ParserDerived<PrimaryExpr>primary;
// Parser primary_sep;
// Parser primary_number;
// Parser primary_identifier;
// Parser primary_str_ing;
left_bracket = "(";
right_bracket = ")";
// list<string> left_s;
left_s.push_back(left_bracket);
// list<string> right_s;
right_s.push_back(right_bracket);
primary_sep.sep(left_s);
primary_sep.ast(&expr);
primary_sep.sep(right_s);
primary_number.number<NumberLiteral>();
primary_identifier.identifier<Name>(reserved);
primary_str_ing.str_ing<StringLiteral>();
// list<Parser*>primary_va;
primary_va.push_back(&primary_sep);
primary_va.push_back(&primary_number);
primary_va.push_back(&primary_identifier);
primary_va.push_back(&primary_str_ing);
primary.or_add(primary_va);
//--------------------factor---------------------//
// Parser factor;
// ParserDerived<NegativeExpr> factor_N;
// list<string> minus_s;
minus_s.push_back(string("-"));
factor_N.sep(minus_s);
factor_N.ast(&primary);
// list<Parser*> factor_va;
factor_va.push_back(&factor_N);
factor_va.push_back(&primary);
factor.or_add(factor_va);
//---------------------expr------------------------//
// Parser expr;
expr.expression<BinaryExpr>(&factor, operators);
//-------------------statement0----------------------//
// Parser statement0;
//-------------------block----------------------//
// ParserDerived<BlockStmnt> block;
left_bracket_flower = "{";
right_bracket_flower = "}";
// list<string> left_s_flower;
left_s_flower.push_back(left_bracket_flower);
// list<string> right_s_flower;
right_s_flower.push_back(right_bracket_flower);
block.sep(left_s_flower);
// block.option(&statement);
// Parser block_repeat_va;
simi_c = ";";
// list<string> block_repeat_sep_va;
block_repeat_sep_va.push_back(simi_c);
block_repeat_sep_va.push_back(Token::EOL_S);
block_repeat_va.sep(block_repeat_sep_va);
block_repeat_va.option(&statement);
block.repeat(&block_repeat_va);
block.sep(right_s_flower);
//-------------------simple----------------------//
// ParserDerived<PrimaryExpr> simple;
simple.ast(&expr);
//-------------------statement----------------------//
// Parser statement;
// ParserDerived<IfStmnt> ifs;
ifs_if = "if";
// list<string> ifs_va_if;
ifs_va_if.push_back(ifs_if);
ifs_else = "else";
// list<string> ifs_va_else;
ifs_va_else.push_back(ifs_else);
While_while = "while";
// list<string> While_va;
While_va.push_back(While_while);
ifs.sep(ifs_va_if);
ifs.ast(&expr);
ifs.ast(&block);
// Parser ifs_opt;
ifs_opt.sep(ifs_va_else);
ifs_opt.ast(&block);
ifs.option(&ifs_opt);//ifstmnt is over
// ParserDerived<WhileStmnt> WhileS;
WhileS.sep(While_va);
WhileS.ast(&expr);
WhileS.ast(&block);
// list<Parser*> statement_or_va;
statement_or_va.push_back(&ifs);
statement_or_va.push_back(&WhileS);
statement_or_va.push_back(&simple);
statement.or_add(statement_or_va);
//-------------------program----------------------//
// Parser program;
// list<Parser*>program_or_va;
program_or_va.push_back(&statement);
// ParserDerived<NullStmnt> nulls;
program_or_va.push_back(&nulls);
program.or_add(program_or_va);
// list<string>program_sep_va;
program_sep_va.push_back(simi_c);
program_sep_va.push_back(Token::EOL_S);
program.sep(program_sep_va);
//test
// std::cout<<program.elements.size()<<std::endl;
}
BasicParser::~BasicParser()
{
//dtor
}
ASTNode* BasicParser::beginparse(Lexer* lexer_r){
ASTNode* k = program.parse(lexer_r);
return k;
}
| 24.984694 | 76 | 0.608127 | cyh2020 |
42d6c99ca88c7ff4c132ba052c98803db2c71ed7 | 2,005 | hpp | C++ | fma65816/include/binary/PluginAdapter.hpp | BenjaminSchulte/fma | df2aa5b0644c75dd34a92defeff9beaa4a32ffea | [
"MIT"
] | 14 | 2018-01-25T10:31:05.000Z | 2022-02-19T13:08:11.000Z | fma65816/include/binary/PluginAdapter.hpp | BenjaminSchulte/fma | df2aa5b0644c75dd34a92defeff9beaa4a32ffea | [
"MIT"
] | 1 | 2020-12-24T10:10:28.000Z | 2020-12-24T10:10:28.000Z | fma65816/include/binary/PluginAdapter.hpp | BenjaminSchulte/fma | df2aa5b0644c75dd34a92defeff9beaa4a32ffea | [
"MIT"
] | null | null | null | #ifndef __FMA65816_BINARY_PLUGINADAPTER_H__
#define __FMA65816_BINARY_PLUGINADAPTER_H__
#include <map>
#include <fma/plugin/Plugin.hpp>
#include <fma/plugin/BinaryGeneratorPluginAdapter.hpp>
namespace FMA65816 {
namespace binary {
struct ByteCodeGenerator;
typedef std::function<bool(const ByteCodeGenerator &generator, FMA::assem::BinaryCodeGeneratorScope *scope, FMA::assem::Instruction *instruct)> ByteCodeGeneratorFunc;
struct ByteCodeGenerator {
ByteCodeGenerator() {}
ByteCodeGenerator(uint8_t opcode, const ByteCodeGeneratorFunc &func)
: opcode(opcode), func(func) {}
inline bool execute(FMA::assem::BinaryCodeGeneratorScope *scope, FMA::assem::Instruction *instruct) {
return func(*this, scope, instruct);
}
uint8_t opcode;
ByteCodeGeneratorFunc func;
};
typedef std::map<std::string, ByteCodeGenerator> ByteCodeGeneratorMap;
class PluginAdapter : public FMA::plugin::BinaryGeneratorPluginAdapter {
public:
PluginAdapter(FMA::Project *project);
bool supports(const std::string &name) const;
bool generate(FMA::assem::BinaryCodeGeneratorScope *scope, FMA::assem::Instruction *instruct, const std::string &name);
protected:
ByteCodeGeneratorMap map;
void label(uint8_t opcode, const std::string &name);
void stzAbs(uint8_t opcode, const std::string &name);
void stzDp(uint8_t opcode, const std::string &name);
void absolute(uint8_t opcode, const std::string &name);
void absLong(uint8_t opcode, const std::string &name);
void brk(uint8_t opcode, const std::string &name);
void directPage(uint8_t opcode, const std::string &name);
void sep(uint8_t opcode, const std::string &name);
void rep(uint8_t opcode, const std::string &name);
void immediate(uint8_t opcode, const std::string &name);
void implicit(uint8_t opcode, const std::string &name);
void pcRelative(uint8_t opcode, const std::string &name);
void srRelative(uint8_t opcode, const std::string &name);
void move(uint8_t opcode, const std::string &name);
};
}
}
#endif
| 33.416667 | 166 | 0.761097 | BenjaminSchulte |
42d78a381e6c0d931325e039c92a8dfeaab012d9 | 19,007 | cpp | C++ | Classes/GameScene.cpp | 1994/AvoidTuitle | 6d9a37e2bf799efb299ae415afd2b22f6f9280be | [
"MIT"
] | null | null | null | Classes/GameScene.cpp | 1994/AvoidTuitle | 6d9a37e2bf799efb299ae415afd2b22f6f9280be | [
"MIT"
] | null | null | null | Classes/GameScene.cpp | 1994/AvoidTuitle | 6d9a37e2bf799efb299ae415afd2b22f6f9280be | [
"MIT"
] | null | null | null | //
// GameScene.cpp
// seven
//
// Created by rimi on 15/6/10.
//
//
#include "GameScene.h"
#include "Star.h"
#include "Bubble.h"
#include "Shell.hpp"
#include "iostream"
#include "WangBa.hpp"
#include "Util.h"
#include "ui/CocosGUI.h"
#include "Dici.hpp"
#include "Music.hpp"
#include "Boom.hpp"
#include "EndLayer.hpp"
#include "Fish.hpp"
#include "string"
using namespace ui;
using namespace std;
//2015-6-19 add
#include <sstream>
namespace patch
{
template < typename T > std::string to_string( const T& n )
{
std::ostringstream stm ;
stm << n ;
return stm.str() ;
}
}
#define UPTAG 100
#define LEFTANDRIGHTTAG 200
#define ACTORTAG 50
#define STARTAG 60
#define WANGBATAG 300
#define DICITAG 400
#define BOOMTAG 550
#define FISHTAG 600
Scene * GameScene::createScene()
{
auto scene = Scene::createWithPhysics();
auto layer = GameScene::create();
//scene->getPhysicsWorld()->setDebugDrawMask(PhysicsWorld::DEBUGDRAW_ALL);
//设置重力环境
scene->getPhysicsWorld()->setGravity(Vec2(0,-1500));
layer->setPhysics(scene->getPhysicsWorld());
scene->addChild(layer);
return scene;
}
bool GameScene::init()
{
if(!Layer::init())
return false;
auto _emitter=ParticleSystemQuad::create("sea-pao01.plist");
_emitter->setEndColor(Color4F(0,0,0,1));
_emitter->setPosition(Vec2(visibleSize.width/2,visibleSize.height/2));
this->addChild(_emitter,200);
// this->addLizi();
this->addEdge();
this->addUI();
this->addActor();
this->addShell();
this->addScore();
// this->addButton();
this->addDici();
Music::playBGM();
this->scheduleUpdate();
return true;
}
void GameScene::addEdge()
{
auto bodyBox = PhysicsBody::createEdgeBox(visibleSize, PHYSICSBODY_MATERIAL_DEFAULT, 3);
auto edgeBox = Node::create();
edgeBox->setPosition(Vec2(visibleSize.width/2,visibleSize.height/2));
edgeBox->setPhysicsBody(bodyBox);
this->addChild(edgeBox);
auto bodyUp = PhysicsBody::createEdgeBox(Size(visibleSize.width,2));
bodyUp->setCategoryBitmask(0xFFFFFFFF);
bodyUp->setContactTestBitmask(0xFFFFFFFF);
auto edgeUp = Node::create();
edgeUp->setTag(UPTAG);
edgeUp->setPosition(Vec2(visibleSize.width/2,visibleSize.height));
edgeUp->setPhysicsBody(bodyUp);
this->addChild(edgeUp,1);
// auto bodyDown = PhysicsBody::createEdgeBox(Size(visibleSize.width,2));
// bodyDown->setCategoryBitmask(0xFFFFFFFF);
// bodyDown->setContactTestBitmask(0xFFFFFFFF);
// auto edgeDown = Node::create();
// edgeDown->setPosition(Vec2(visibleSize.width/2,0));
// edgeDown->setPhysicsBody(bodyDown);
// edgeDown->setTag(2);
// this->addChild(edgeDown,1);
auto bodyLeft = PhysicsBody::createEdgeBox(Size(3,visibleSize.height));
bodyLeft->setCategoryBitmask(0xFFFFFFFF);
bodyLeft->setContactTestBitmask(0xFFFFFFFF);
bodyLeft->getFirstShape()->setRestitution(1);
auto edgeLeft = Node::create();
edgeLeft->setPosition(Vec2(0,visibleSize.height/2));
edgeLeft->setTag(LEFTANDRIGHTTAG);
edgeLeft->setPhysicsBody(bodyLeft);
this->addChild(edgeLeft,1);
auto bodyRight = PhysicsBody::createEdgeBox(Size(3,visibleSize.height));
bodyRight->setCategoryBitmask(0xFFFFFFFF);
bodyRight->setContactTestBitmask(0xFFFFFFFF);
bodyRight->getFirstShape()->setRestitution(1);
auto edgeRight = Node::create();
edgeRight->setPosition(Vec2(visibleSize.width,visibleSize.height/2));
edgeRight->setTag(LEFTANDRIGHTTAG);
edgeRight->setPhysicsBody(bodyRight);
this->addChild(edgeRight,1);
auto body = PhysicsBody::createBox(m_actor->getContentSize());
body->setContactTestBitmask(0xFFFFFFFF);
body->setEnable(true);
body->setGravityEnable(true);
body->setDynamic(true);
body->setRotationEnable(false);
body->setVelocity(Vec2(-800,0));
// log("mass = %f",body->getMass());
//body->setVelocityLimit(1200.0f);
body->applyForce(Vec2(-10000,0));
body->getFirstShape()->setRestitution(1);
// log("mess = %f",body->getMass());
m_actor->setPhysicsBody(body);
m_actor->getPhysicsBody()->setMass(500.0f);
auto contactListener = EventListenerPhysicsContact::create();
contactListener->onContactBegin = [this](PhysicsContact& contact)->bool
{
// log("up");
auto SpriteA = (Sprite *)contact.getShapeA()->getBody()->getNode();
auto SpriteB = (Sprite *)contact.getShapeB()->getBody()->getNode();
if(SpriteA&&SpriteB){
log("A TAG = %d",SpriteA->getTag());
log("B TAG = %d",SpriteB->getTag());
if(SpriteA&&SpriteB&&SpriteA->getTag()==UPTAG&&SpriteB->getTag()==ACTORTAG)
{
//log("actor 撞 上面");
return true;
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==STARTAG&&SpriteB->getTag()==UPTAG)
{
// log("star 撞上面");
this->removeChild(SpriteA);
return true;
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==LEFTANDRIGHTTAG&&SpriteB->getTag()==ACTORTAG)
{
Vec2 currentSpeed = SpriteB->getPhysicsBody()->getVelocity();
// log("speed.x = %f,speed.y= %f",currentSpeed.x,currentSpeed.y);
if(currentSpeed.x<0){
SpriteB->getPhysicsBody()->resetForces();
SpriteB->getPhysicsBody()->applyForce(Vec2(10000.0f,0));
SpriteB->getPhysicsBody()->setVelocity(Vec2(800,currentSpeed.y));
}else {
SpriteB->getPhysicsBody()->resetForces();
SpriteB->getPhysicsBody()->applyForce(Vec2(-10000.0f,0));
SpriteB->getPhysicsBody()->setVelocity(Vec2(-800,currentSpeed.y));
}
return true;
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==STARTAG&&SpriteB->getTag()==STARTAG)
{
// log("paopao撞到了");
return true;
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==STARTAG&&SpriteB->getTag()==ACTORTAG)
{
this->removeChild(SpriteA);
score++;
return true;
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==WANGBATAG&&SpriteB->getTag()==ACTORTAG)
{
Vec2 speed = SpriteB->getPhysicsBody()->getVelocity();
if(speed.x>0)
SpriteB->getPhysicsBody()->setVelocity(Vec2(speed.x+400,speed.y));
else
SpriteB->getPhysicsBody()->setVelocity(Vec2(speed.x-400,speed.y));
return true;
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==DICITAG&&SpriteB->getTag()==ACTORTAG)
{
auto end = EndLayer::createScene(score);
Director::getInstance()->replaceScene(end);
return true;
}
//boom
if(SpriteA&&SpriteB&&SpriteA->getTag()==BOOMTAG&&SpriteB->getTag()==ACTORTAG)
{
Music::playBoom();
auto _emitter=ParticleSystemQuad::create("baozha01.plist");
_emitter->setDuration(0.2);
_emitter->setStartSize(18.0);
_emitter->setEndSize(29.0);
// 设置例子纹理
//
auto texture=Director::getInstance()->getTextureCache()->addImage("boom-shape.png");
_emitter->setTexture(texture);
_emitter->setPosition(SpriteA->getPosition());
_emitter->setEndColor(Color4F(0,0,0,0));
this->addChild(_emitter,4);
this->removeChild(SpriteA);
_eventDispatcher->removeEventListenersForType(EventListener::Type::TOUCH_ONE_BY_ONE);
SpriteB->setColor(Color3B(0,0,0));
//失去知觉
return true;
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==BOOMTAG&&SpriteB->getTag()==DICITAG)
{
auto _emitter=ParticleSystemQuad::create("baozha01.plist");
_emitter->setDuration(0.2);
_emitter->setStartSize(18.0);
_emitter->setEndSize(29.0);
auto texture=Director::getInstance()->getTextureCache()->addImage("boom-shape.png");
_emitter->setTexture(texture);
_emitter->setPosition(SpriteA->getPosition());
_emitter->setEndColor(Color4F(0,0,0,0));
this->addChild(_emitter,4);
this->removeChild(SpriteA);
return true;
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==WANGBATAG&&SpriteB->getTag()==LEFTANDRIGHTTAG){
this->removeChild(SpriteA);
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==ACTORTAG&&SpriteB->getTag()==FISHTAG){
score++;
this->removeChild(SpriteB);
}
if(SpriteA&&SpriteB&&SpriteA->getTag()==FISHTAG&&SpriteB->getTag()==ACTORTAG){
score=score+2;
this->removeChild(SpriteA);
}
}
return true;
};
_eventDispatcher->addEventListenerWithSceneGraphPriority(contactListener, this);
}
void GameScene::addActor()
{
m_actor->setScale(0.3);
m_actor->setTag(ACTORTAG);
m_actor->setPosition(Vec2(visibleSize.width/2+origin.x,visibleSize.height/2+origin.y+400));
this->addChild(m_actor,1);
//添加事件监听
auto _ClickListener = EventListenerTouchOneByOne::create();
_ClickListener->onTouchBegan = [=](Touch *touch,Event *event)->bool{
log("Click");
Vec2 speed = m_actor->getPhysicsBody()->getVelocity();
m_actor->getPhysicsBody()->setVelocity(Vec2(speed.x,speed.y+800));
return true;
};
_eventDispatcher->addEventListenerWithSceneGraphPriority(_ClickListener, this);
}
void GameScene::addUI()
{
auto bg = Sprite::create("bg-3.png");
bg->setPosition(visibleSize.width/2,visibleSize.height/2);
this->addChild(bg);
}
void GameScene::addStar(int i)
{
int randType = Util::getRandomNumber(1, 9);
log("随机数: %d",randType);
auto star = Star::createStar(randType);
auto bodyStar = PhysicsBody::createCircle(star->getContentSize().width/2);
bodyStar->setCategoryBitmask(0xFFFFFFFF);
bodyStar->setContactTestBitmask(0xFFFFFFFF);
bodyStar->setDynamic(true);
bodyStar->setMass(0.8);
star->setPosition(Vec2(200*i,200));
star->setPhysicsBody(bodyStar);
star->setTag(STARTAG);
star->getPhysicsBody()->setGravityEnable(false);
this->addChild(star);
int control1_x = Util::getRandomNumber(0, visibleSize.width);
int control1_y = Util::getRandomNumber(0, visibleSize.height);
int control2_x = Util::getRandomNumber(0, visibleSize.width);
int control2_y = Util::getRandomNumber(0, visibleSize.height);
int destina_x = Util::getRandomNumber(0, visibleSize.width);
WangBa::getInstance()->BezierMove(star, 4, Vec2(destina_x,visibleSize.height), Vec2(control1_x,control1_y), Vec2(control2_x,control2_y));
}
void GameScene::update(float delta)
{
// srand((unsigned)time(0));
time++;
// log("time = %d",time);
temp++;
if(time>1000){
if(temp%50==0){
// srand((unsigned)time(NULL));
number++;
if(number>3){
number = 0;
}
this->addStar(number);
// this->addWangBa();
int shaizi = Util::getRandomNumber(0, 4);
if(shaizi==2){
this->addWangBa();
}
if(shaizi==0)
this->addFish();
//if(shaizi==1)
this->addBoom(Util::getRandomNumber(1, 8),time);
temp = temp%50;
}
} else {
if(temp%100==0){
// srand((unsigned)time(NULL));
number++;
if(number>3){
number = 0;
}
this->addStar(number);
// this->addWangBa();
int shaizi = Util::getRandomNumber(0, 4);
if(shaizi==2){
this->addWangBa();
}
if(shaizi==3)
this->addFish();
if(shaizi==4)
this->addBoom(Util::getRandomNumber(1, 8),time);
//this->addBoom(Util::getRandomNumber(1,8));
temp = temp%100;
}
}
//更新分数
m_score->setTextColor(Color4B(0,0,0,50));
m_score->setString(patch::to_string(score));
Vec2 currentPosition = m_actor->getPosition();
log("position.x = %f",currentPosition.x);
if(currentPosition.x>visibleSize.width||currentPosition.x<0){
auto end = EndLayer::createScene(score);
Director::getInstance()->replaceScene(end);
}
}
void GameScene::addShell(){
auto shell = Shell::createShell();
// auto bodyShell = PhysicsBody::createEdgeBox(shell->getContentSize());
shell->setPosition(Vec2(200,100));
// shell->setPhysicsBody(bodyShell);
this->addChild(shell);
}
void GameScene::addScore(){
m_score->setPosition(Vec2(visibleSize.width/2,900));
this->addChild(m_score);
}
void GameScene::addWangBa(){
auto wangba = WangBa::getInstance()->createWangBa();
auto bodyWangBa = PhysicsBody::createEdgeBox(wangba->getContentSize()*0.6);
bodyWangBa->setCategoryBitmask(0x0001);
bodyWangBa->setContactTestBitmask(0x0001);
// bodyWangBa->setCategoryBitmask(0xFFFFFFFF);
// bodyWangBa->setContactTestBitmask(0xFFFFFFFF);
//
bodyWangBa->getFirstShape()->setRestitution(1.0F);
wangba->setPosition(Vec2(0,Util::getRandomNumber(0, visibleSize.height)));
wangba->setTag(WANGBATAG);
wangba->setPhysicsBody(bodyWangBa);
this->addChild(wangba);
int control1_x = Util::getRandomNumber(0, visibleSize.width);
int control1_y = Util::getRandomNumber(0, visibleSize.height);
int control2_x = Util::getRandomNumber(0, visibleSize.width);
int control2_y = Util::getRandomNumber(0, visibleSize.height);
int destina_y = Util::getRandomNumber(0, visibleSize.height);
WangBa::getInstance()->BezierMove(wangba, 4, Vec2(visibleSize.width+100,destina_y), Vec2(control1_x,control1_y), Vec2(control2_x,control2_y));
}
void GameScene::addButton(){
auto btn = Button::create("CloseNormal.png");
btn->setPosition(Vec2(visibleSize.width/2,visibleSize.height/2));
this->addChild(btn);
//[](){}const ccWidgetClickCallback &callback
btn->addClickEventListener([&](Ref * pSender){
auto scene = GameScene::createScene();
Director::getInstance()->replaceScene(scene);
});
}
void GameScene::addDici(){
auto dici = Dici::createDici();
auto bodyDici = PhysicsBody::createEdgeBox(dici->getContentSize());
bodyDici->setCategoryBitmask(0xFFFFFFFF);
bodyDici->setContactTestBitmask(0xFFFFFFFF);
dici->setTag(DICITAG);
dici->setAnchorPoint(Vec2(0.5,0));
dici->setPosition(Vec2(visibleSize.width/2,22));
dici->setPhysicsBody(bodyDici);
this->addChild(dici);
}
void GameScene::onExit(){
Layer::onExit();
Music::end();
}
void GameScene::addLizi(){
auto _emitter=ParticleSystemQuad::create("pao-gamesence.plist");
_emitter->setStartSize(18.0);
_emitter->setEndSize(29.0);
_emitter->setEndColor(Color4F(0,0,0,1));
_emitter->setPosition(Vec2(visibleSize.width/2,visibleSize.height/2));
this->addChild(_emitter,200);
}
void GameScene::addBoom(int i,int time){
// bodyBoom->getFirstShape()->setRestitution(1);
auto boom = Boom::createBoom();
boom->setTag(BOOMTAG);
boom->setPosition(Vec2(100*i,visibleSize.height));
float scale = 0.2;
boom->setScale(scale);
auto bodyBoom = PhysicsBody::createCircle(boom->getContentSize().width/2*scale);
bodyBoom->setMass(4000.0f);
bodyBoom->setCategoryBitmask(0x0001);
bodyBoom->setContactTestBitmask(0x0001);
if(time>1000){
bodyBoom->applyForce(Vec2(0,-20000.0f));
bodyBoom->setVelocity(Vec2(0,-200));
}
else {
bodyBoom->applyForce(Vec2(0,-10000.0f));
bodyBoom->setVelocity(Vec2(0,-100));
}
boom->setPhysicsBody(bodyBoom);
this->addChild(boom,3);
}
void GameScene::addFish(){
int number = Util::getRandomNumber(1, 3);
for(int i=0;i<number;i++){
int type = Util::getRandomNumber(2, 3);
log("type = %d",type);
if(type==4)
return;
auto fish = Fish::createFish(type);
int position_y = Util::getRandomNumber(100, visibleSize.height-100);
if(type==0||type==3){
fish->setPosition(Vec2(0,position_y));
int control1_x = Util::getRandomNumber(0, visibleSize.width);
int control1_y = Util::getRandomNumber(0, visibleSize.height);
int control2_x = Util::getRandomNumber(0, visibleSize.width);
int control2_y = Util::getRandomNumber(0, visibleSize.height);
int destina_y = Util::getRandomNumber(0, visibleSize.height);
WangBa::getInstance()->BezierMove(fish, 4, Vec2(visibleSize.width+100,destina_y), Vec2(control1_x,control1_y), Vec2(control2_x,control2_y));
}
else{
fish->setPosition(Vec2(visibleSize.width,position_y));
int control1_x = Util::getRandomNumber(0, visibleSize.width);
int control1_y = Util::getRandomNumber(0, visibleSize.height);
int control2_x = Util::getRandomNumber(0, visibleSize.width);
int control2_y = Util::getRandomNumber(0, visibleSize.height);
int destina_y = Util::getRandomNumber(0, visibleSize.height);
WangBa::getInstance()->BezierMove(fish, 4, Vec2(-300,destina_y), Vec2(control1_x,control1_y), Vec2(control2_x,control2_y));
}
this->addChild(fish);
//this->addChild(fish);
}
} | 30.026856 | 152 | 0.578261 | 1994 |
42d843cca864ec3b534cc47e255e848d26f09106 | 1,917 | cpp | C++ | src/AstIOTypeAnalysis.cpp | iamsiddhant1005/souffle-new-adt | 36aae85854b60d121bb7c7cd206f9caf2889bd7f | [
"UPL-1.0"
] | null | null | null | src/AstIOTypeAnalysis.cpp | iamsiddhant1005/souffle-new-adt | 36aae85854b60d121bb7c7cd206f9caf2889bd7f | [
"UPL-1.0"
] | null | null | null | src/AstIOTypeAnalysis.cpp | iamsiddhant1005/souffle-new-adt | 36aae85854b60d121bb7c7cd206f9caf2889bd7f | [
"UPL-1.0"
] | null | null | null | /*
* Souffle - A Datalog Compiler
* Copyright (c) 2019, The Souffle Developers. All rights reserved.
* Licensed under the Universal Permissive License v 1.0 as shown at:
* - https://opensource.org/licenses/UPL
* - <souffle root>/licenses/SOUFFLE-UPL.txt
*/
/************************************************************************
*
* @file AstIOTypeAnalysis.h
*
* Implements methods to identify a relation as input, output, or printsize.
*
***********************************************************************/
#include "AstIOTypeAnalysis.h"
#include "AstIO.h"
#include "AstRelation.h"
#include "AstTranslationUnit.h"
#include "AstVisitor.h"
namespace souffle {
void IOType::run(const AstTranslationUnit& translationUnit) {
visitDepthFirst(*translationUnit.getProgram(), [&](const AstLoad& directive) {
auto* relation = translationUnit.getProgram()->getRelation(directive.getQualifiedName());
if (relation == nullptr) {
return;
}
inputRelations.insert(relation);
});
visitDepthFirst(*translationUnit.getProgram(), [&](const AstStore& directive) {
auto* relation = translationUnit.getProgram()->getRelation(directive.getQualifiedName());
if (relation == nullptr) {
return;
}
outputRelations.insert(relation);
});
visitDepthFirst(*translationUnit.getProgram(), [&](const AstPrintSize& directive) {
auto* relation = translationUnit.getProgram()->getRelation(directive.getQualifiedName());
if (relation == nullptr) {
return;
}
printSizeRelations.insert(relation);
});
}
void IOType::print(std::ostream& os) const {
os << "input relations: " << inputRelations << std::endl;
os << "output relations: " << outputRelations << std::endl;
os << "printSize relations: " << printSizeRelations << std::endl;
}
} // end of namespace souffle
| 34.232143 | 97 | 0.615023 | iamsiddhant1005 |
42d9c61c0c74cfd48d8438b418e621773e36d366 | 4,532 | cpp | C++ | applications/physbam/physbam-lib/Public_Library/PhysBAM_Rendering/PhysBAM_OpenGL/OpenGL_Components/OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD.cpp | schinmayee/nimbus | 170cd15e24a7a88243a6ea80aabadc0fc0e6e177 | [
"BSD-3-Clause"
] | 20 | 2017-07-03T19:09:09.000Z | 2021-09-10T02:53:56.000Z | applications/physbam/physbam-lib/Public_Library/PhysBAM_Rendering/PhysBAM_OpenGL/OpenGL_Components/OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD.cpp | schinmayee/nimbus | 170cd15e24a7a88243a6ea80aabadc0fc0e6e177 | [
"BSD-3-Clause"
] | null | null | null | applications/physbam/physbam-lib/Public_Library/PhysBAM_Rendering/PhysBAM_OpenGL/OpenGL_Components/OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD.cpp | schinmayee/nimbus | 170cd15e24a7a88243a6ea80aabadc0fc0e6e177 | [
"BSD-3-Clause"
] | 9 | 2017-09-17T02:05:06.000Z | 2020-01-31T00:12:01.000Z | //#####################################################################
// Copyright 2010, Jon Gretarsson.
// This file is part of PhysBAM whose distribution is governed by the license contained in the accompanying file PHYSBAM_COPYRIGHT.txt.
//#####################################################################
#if !COMPILE_WITHOUT_DYADIC_SUPPORT || COMPILE_WITH_BINTREE_SUPPORT
#include <PhysBAM_Tools/Read_Write/Arrays/READ_WRITE_ARRAY.h>
#include <PhysBAM_Tools/Read_Write/Utilities/FILE_UTILITIES.h>
#include <PhysBAM_Rendering/PhysBAM_OpenGL/OpenGL/OPENGL_COLOR_MAP.h>
#include <PhysBAM_Rendering/PhysBAM_OpenGL/OpenGL_Components/OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD.h>
using namespace PhysBAM;
template<class T,class T2,class RW> OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD(BINTREE_GRID<T> &grid,const std::string &scalar_field_filename_input,OPENGL_COLOR_MAP<T2>* color_map_input,bool draw_points_input)
: OPENGL_COMPONENT("Bintree Based Scalar Field"), opengl_bintree_face_scalar_field(grid,*(new ARRAY<T2>),color_map_input,draw_points_input),
scalar_field_filename(scalar_field_filename_input), valid(false)
{
is_animation = FILE_UTILITIES::Is_Animated(scalar_field_filename);
frame_loaded = -1;
Reinitialize();
}
template<class T,class T2,class RW> OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
~OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD()
{
}
template<class T,class T2,class RW> bool OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
Valid_Frame(int frame_input) const
{
return FILE_UTILITIES::Frame_File_Exists(scalar_field_filename, frame_input);
}
template<class T,class T2,class RW> void OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
Set_Frame(int frame_input)
{
OPENGL_COMPONENT::Set_Frame(frame_input);
Reinitialize();
}
template<class T,class T2,class RW> void OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
Set_Draw(bool draw_input)
{
OPENGL_COMPONENT::Set_Draw(draw_input);
Reinitialize();
}
template<class T,class T2,class RW> void OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
Display(const int in_color) const
{
if (valid && draw) opengl_bintree_face_scalar_field.Display(in_color);
}
template<class T,class T2,class RW> RANGE<VECTOR<float,3> > OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
Bounding_Box() const
{
if (valid && draw) return opengl_bintree_face_scalar_field.Bounding_Box();
else return RANGE<VECTOR<float,3> >::Centered_Box();
}
template<class T,class T2,class RW> void OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
Reinitialize()
{
if (draw)
{
if (!valid ||
(is_animation && frame_loaded != frame) ||
(!is_animation && frame_loaded < 0))
{
valid = false;
std::string tmp_filename = FILE_UTILITIES::Get_Frame_Filename(scalar_field_filename, frame);
if (FILE_UTILITIES::File_Exists(tmp_filename))
FILE_UTILITIES::Read_From_File<RW>(tmp_filename,opengl_bintree_face_scalar_field.value);
else
return;
opengl_bintree_face_scalar_field.Update();
frame_loaded = frame;
valid = true;
}
}
}
template<class T,class T2,class RW> void OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
Print_Selection_Info(std::ostream& output_stream,OPENGL_SELECTION* current_selection) const
{
if(Is_Up_To_Date(frame)){
output_stream<<component_name<<": "<<std::endl;
opengl_bintree_face_scalar_field.Print_Selection_Info(output_stream,current_selection);}
}
template<class T,class T2,class RW> void OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
Increase_Point_Size()
{
opengl_bintree_face_scalar_field.point_size++;
}
template<class T,class T2,class RW> void OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<T,T2,RW>::
Decrease_Point_Size()
{
opengl_bintree_face_scalar_field.point_size--;
}
template class OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<float,int,float>;
template class OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<float,bool,float>;
template class OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<float,float,float>;
#ifndef COMPILE_WITHOUT_DOUBLE_SUPPORT
template class OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<double,int,double>;
template class OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<double,bool,double>;
template class OPENGL_COMPONENT_BINTREE_FACE_SCALAR_FIELD<double,double,double>;
#endif
#endif
| 39.754386 | 173 | 0.754634 | schinmayee |
42df4dffc224f67c79a6465148f1fa16d71eeba0 | 569 | hpp | C++ | src/parser_nodes/poetic_decimal_digits_parser_node_pre.hpp | lowlander/nederrock | aa23f79de3adf0510419208938bf4dcdbe786c9f | [
"MIT"
] | null | null | null | src/parser_nodes/poetic_decimal_digits_parser_node_pre.hpp | lowlander/nederrock | aa23f79de3adf0510419208938bf4dcdbe786c9f | [
"MIT"
] | null | null | null | src/parser_nodes/poetic_decimal_digits_parser_node_pre.hpp | lowlander/nederrock | aa23f79de3adf0510419208938bf4dcdbe786c9f | [
"MIT"
] | null | null | null | //
// Copyright (c) 2020 Erwin Rol <erwin@erwinrol.com>
//
// SPDX-License-Identifier: MIT
//
#ifndef NEDERROCK_SRC_POETIC_DECIMAL_DIGITS_PARSER_NODE_PRE_HPP
#define NEDERROCK_SRC_POETIC_DECIMAL_DIGITS_PARSER_NODE_PRE_HPP
#include <memory>
#include <vector>
class Poetic_Decimal_Digits_Parser_Node;
using Poetic_Decimal_Digits_Parser_Node_Ptr = std::shared_ptr<Poetic_Decimal_Digits_Parser_Node>;
using Poetic_Decimal_Digits_Parser_Node_Vector = std::vector<Poetic_Decimal_Digits_Parser_Node_Ptr>;
#endif // NEDERROCK_SRC_POETIC_DECIMAL_DIGITS_PARSER_NODE_PRE_HPP
| 29.947368 | 100 | 0.855888 | lowlander |
42e181aaa93c132286fbe57d22e471672e0ddea2 | 1,196 | cc | C++ | tests/test_1.cc | z8432k/feodorov-oop-lw-3 | 8ec4c2ae2439aa86f3562cd52117189ac2b29dc5 | [
"MIT"
] | null | null | null | tests/test_1.cc | z8432k/feodorov-oop-lw-3 | 8ec4c2ae2439aa86f3562cd52117189ac2b29dc5 | [
"MIT"
] | null | null | null | tests/test_1.cc | z8432k/feodorov-oop-lw-3 | 8ec4c2ae2439aa86f3562cd52117189ac2b29dc5 | [
"MIT"
] | 1 | 2021-01-23T14:16:23.000Z | 2021-01-23T14:16:23.000Z | #include <iostream>
#include <string>
#include <ComplexNum.h>
#include <complex>
#include <cassert>
using namespace std;
int main(int argc, char** argv) {
ComplexNum cn(3, 7);
complex<double> cn_t {3., 7.};
ComplexNum cn2(10, 2);
complex<double> cn2_t {10., 2.};
cout << endl;
cout << "First num:" << static_cast<string>(cn) << endl;
cout << "Second num:" << static_cast<string>(cn2) << endl;
cout << endl;
cout << "Check class operators:" << endl << endl;
auto result = cn + cn2;
assert(result == cn_t + cn2_t);
cout << "+ OK: " << static_cast<string>(result) << endl;
result = cn - cn2;
assert(result == cn_t - cn2_t);
cout << "- OK: " << static_cast<string>(result) << endl;
result = cn / cn2;
assert(result == cn_t / cn2_t);
cout << "/ OK: " << static_cast<string>(result) << endl;
result = cn * cn2;
assert(result == cn_t * cn2_t);
cout << "* OK: " << static_cast<string>(result) << endl;
assert((cn != cn2) == true);
cout << "!= OK: " << endl;
string num = "3+7i";
ComplexNum eq(num);
assert((cn == eq) == true);
cout << "== OK: " << endl;
exit(EXIT_SUCCESS);
}
| 22.566038 | 62 | 0.550167 | z8432k |
42e2bd604d2d4f5d551dc55fdd83b6b2fb7faad6 | 927 | cpp | C++ | tests/android/app/src/main/cpp/log_buffer.cpp | ondesly/audio_engine | 37e68f9e5be3f36b77aac6574e90d2150aef0f6d | [
"BSD-2-Clause"
] | null | null | null | tests/android/app/src/main/cpp/log_buffer.cpp | ondesly/audio_engine | 37e68f9e5be3f36b77aac6574e90d2150aef0f6d | [
"BSD-2-Clause"
] | null | null | null | tests/android/app/src/main/cpp/log_buffer.cpp | ondesly/audio_engine | 37e68f9e5be3f36b77aac6574e90d2150aef0f6d | [
"BSD-2-Clause"
] | null | null | null | //
// log_buffer.cpp
// audio_engine
//
// Created by Dmitrii Torkhov <dmitriitorkhov@gmail.com> on 19.03.2021.
// Copyright © 2021 Dmitrii Torkhov. All rights reserved.
//
#include <streambuf>
#include <android/log.h>
#include "log_buffer.h"
namespace {
const char *c_tag = "maw";
}
oo::log_buffer::log_buffer() {
setp(m_buffer, m_buffer + c_buffer_size - 1);
}
int oo::log_buffer::overflow(int c) {
if (c == traits_type::eof()) {
*pptr() = traits_type::to_char_type(c);
sbumpc();
}
return this->sync() ? traits_type::eof() : traits_type::not_eof(c);
}
int oo::log_buffer::sync() {
__android_log_print(ANDROID_LOG_INFO, c_tag, "");
if (pbase() != pptr()) {
__android_log_print(ANDROID_LOG_INFO, c_tag, "%s",
std::string(pbase(), pptr() - pbase()).c_str());
setp(m_buffer, m_buffer + c_buffer_size - 1);
}
return 0;
} | 22.071429 | 76 | 0.607335 | ondesly |
42e41a173064c32d50d70ac89c00328515cb6331 | 4,692 | hxx | C++ | main/toolkit/inc/toolkit/awt/vclxspinbutton.hxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 679 | 2015-01-06T06:34:58.000Z | 2022-03-30T01:06:03.000Z | main/toolkit/inc/toolkit/awt/vclxspinbutton.hxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 102 | 2017-11-07T08:51:31.000Z | 2022-03-17T12:13:49.000Z | main/toolkit/inc/toolkit/awt/vclxspinbutton.hxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 331 | 2015-01-06T11:40:55.000Z | 2022-03-14T04:07:51.000Z | /**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
#ifndef TOOLKIT_AWT_VCLXSPINBUTTON_HXX
#define TOOLKIT_AWT_VCLXSPINBUTTON_HXX
#include <toolkit/awt/vclxwindow.hxx>
#include <toolkit/helper/listenermultiplexer.hxx>
#include <cppuhelper/implbase1.hxx>
#include <comphelper/uno3.hxx>
#include <com/sun/star/awt/XSpinValue.hpp>
//........................................................................
namespace toolkit
{
//........................................................................
//====================================================================
//= VCLXSpinButton
//====================================================================
typedef ::cppu::ImplHelper1 < ::com::sun::star::awt::XSpinValue
> VCLXSpinButton_Base;
class VCLXSpinButton :public VCLXWindow
,public VCLXSpinButton_Base
{
private:
AdjustmentListenerMultiplexer maAdjustmentListeners;
public:
VCLXSpinButton();
protected:
~VCLXSpinButton( );
// XInterface
DECLARE_XINTERFACE()
// XTypeProvider
DECLARE_XTYPEPROVIDER()
// XComponent
void SAL_CALL dispose( ) throw(::com::sun::star::uno::RuntimeException);
// XSpinValue
virtual void SAL_CALL addAdjustmentListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XAdjustmentListener >& listener ) throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeAdjustmentListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XAdjustmentListener >& listener ) throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setValue( sal_Int32 n ) throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setValues( sal_Int32 minValue, sal_Int32 maxValue, sal_Int32 currentValue ) throw (::com::sun::star::uno::RuntimeException);
virtual sal_Int32 SAL_CALL getValue( ) throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setMinimum( sal_Int32 minValue ) throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setMaximum( sal_Int32 maxValue ) throw (::com::sun::star::uno::RuntimeException);
virtual sal_Int32 SAL_CALL getMinimum( ) throw (::com::sun::star::uno::RuntimeException);
virtual sal_Int32 SAL_CALL getMaximum( ) throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setSpinIncrement( sal_Int32 spinIncrement ) throw (::com::sun::star::uno::RuntimeException);
virtual sal_Int32 SAL_CALL getSpinIncrement( ) throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setOrientation( sal_Int32 orientation ) throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual sal_Int32 SAL_CALL getOrientation( ) throw (::com::sun::star::uno::RuntimeException);
// VclWindowPeer
virtual void SAL_CALL setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value ) throw(::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Any SAL_CALL getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException);
// VCLXWindow
void ProcessWindowEvent( const VclWindowEvent& _rVclWindowEvent );
private:
VCLXSpinButton( const VCLXSpinButton& ); // never implemented
VCLXSpinButton& operator=( const VCLXSpinButton& ); // never implemented
};
//........................................................................
} // namespacetoolkit
//........................................................................
#endif // TOOLKIT_INC_TOOLKIT_AWT_VCLXSPINBUTTON_HXX
| 48.371134 | 201 | 0.617008 | Grosskopf |
42e51682acd0fe34cb169b0ff1e2885529fce2ed | 4,877 | cpp | C++ | WorldEditor/WorldView.cpp | madeso/infection-survivors | 654fc5405dcecccaa7e54f1fdbfec379e0c185da | [
"Zlib"
] | null | null | null | WorldEditor/WorldView.cpp | madeso/infection-survivors | 654fc5405dcecccaa7e54f1fdbfec379e0c185da | [
"Zlib"
] | null | null | null | WorldEditor/WorldView.cpp | madeso/infection-survivors | 654fc5405dcecccaa7e54f1fdbfec379e0c185da | [
"Zlib"
] | null | null | null | #include "WorldView.hpp"
#include "World.hpp"
#include "Tool.hpp"
#include "MainFrame.hpp"
#include <sstream>
WorldView::WorldView(wxPanel* parent, MainFrame *iMainFrame, int *gl_attrib) :
wxGLCanvas(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize,
wxFULL_REPAINT_ON_RESIZE, _T("WorldView"), gl_attrib), mMain(iMainFrame), mWorld(new World()), mRenderMode(RM_HALOED_LINE) {
}
void WorldView::newWorld() {
mWorld.reset( new World() );
mTool.reset();
Refresh(false);
}
void WorldView::selectRenderMode(RenderMode iRenderMode) {
mRenderMode = iRenderMode;
Refresh(false);
}
void WorldView::OnPaint(wxPaintEvent& event) {
// This is a dummy, to avoid an endless succession of paint messages
// OnPaint handlers must always create a wxPaintDC.
wxPaintDC dc(this);
#ifndef __WXMOTIF__
if (!GetContext()) return;
#endif
SetCurrent(); // make opengl calls happen on this canvas
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glLoadIdentity();
setupOpenGl();
doPaint();
glFlush();
SwapBuffers();
}
void WorldView::setupOpenGl() {
glEnable(GL_DEPTH_TEST);
glClearColor(1, 1, 1, 0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
void WorldView::OnSize(wxSizeEvent& event) {
// this is also necessary to update the context on some platforms
wxGLCanvas::OnSize(event);
int w, h;
GetClientSize(&w, &h);
if( h==0 ) {
h=1;
}
#ifndef __WXMOTIF__
if (GetContext())
#endif
{
SetCurrent();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glViewport(0, 0, (GLint) w, (GLint) h);
const GLfloat aspect = (GLfloat)w/(GLfloat)h;
gluPerspective(45.0f,aspect,0.1f,100.0f);
glMatrixMode(GL_MODELVIEW);
setupOpenGl();
}
}
void WorldView::OnEraseBackground(wxEraseEvent& event) {
// Do nothing, to avoid flashing.
}
WorldView* WorldView::build(wxPanel* parent, MainFrame *iMainFrame) {
#ifdef __WXMSW__
//int *gl_attrib = NULL;
int gl_attrib[] = { WX_GL_RGBA, WX_GL_MIN_RED, 1, WX_GL_MIN_GREEN, 1,
WX_GL_MIN_BLUE, 1, WX_GL_DEPTH_SIZE, 32,
WX_GL_DOUBLEBUFFER, NULL};
#else
int gl_attrib[20] = { WX_GL_RGBA, WX_GL_MIN_RED, 1, WX_GL_MIN_GREEN, 1,
WX_GL_MIN_BLUE, 1, WX_GL_DEPTH_SIZE, 1,
WX_GL_DOUBLEBUFFER,
# ifdef __WXMAC__
GL_NONE };
# else
None };
# endif
#endif
return new WorldView(parent, iMainFrame, gl_attrib);
}
BEGIN_EVENT_TABLE(WorldView, wxGLCanvas)
EVT_SIZE(WorldView::OnSize)
EVT_PAINT(WorldView::OnPaint)
EVT_ERASE_BACKGROUND(WorldView::OnEraseBackground)
EVT_MOUSE_EVENTS(WorldView::OnMouseEvent)
END_EVENT_TABLE()
void WorldView::OnMouseEvent(wxMouseEvent& event) {
int w, h;
GetClientSize(&w, &h);
const ::lunarlady::real x = 2.0f*(::lunarlady::math::limitRange(0.0f, (::lunarlady::real)event.GetX() / (::lunarlady::real)w, 1.0f)-0.5f);
const ::lunarlady::real y = 2.0f*(::lunarlady::math::limitRange(0.0f, (::lunarlady::real)event.GetY() / (::lunarlady::real)h, 1.0f)-0.5f);
const ::lunarlady::math::vec2 movement(x, y);
SetCurrent();
/*std::stringstream str;
str << "location: " << event.GetX() << "/" << w << ", " << event.GetY() << "/" << h;
mMain->setInfoText( str.str() );*/
mWorld->setMousePosition(::lunarlady::math::vec2(event.GetX(),h-event.GetY()));
if( updateCurrentTool(movement, event) ) {
Refresh(false);
}
mWorld->setMousePosition(::lunarlady::math::vec2(event.GetX(),h-event.GetY()));
}
void WorldView::selectTool(Tool* iTool) {
mTool.reset( iTool );
mWorld->selectToolAction( iTool->getToolAction() );
Refresh(false);
}
World& WorldView::getWorld() {
assert( mWorld.get() );
return *(mWorld.get());
}
bool WorldView::updateCurrentTool(const ::lunarlady::math::vec2& movement, wxMouseEvent& event) {
static bool mDragging = false;
static ::lunarlady::math::vec2 last(0,0);
bool refresh = getWorld().defaultRefreshValue();
{
int rotation = event.GetWheelRotation();
const int delta = event.GetWheelDelta();
const ::lunarlady::real power = event.ShiftDown()? 1.0f : 0.5f;
if( rotation > 0 ) {
for(; rotation >= delta; rotation -= delta) {
mWorld->increaseZoom( power );
refresh = true;
}
}
else if( rotation < 0 ) {
for(; rotation <= -delta; rotation += delta) {
mWorld->increaseZoom( -power );
refresh = true;
}
}
}
if( event.MiddleIsDown() ) {
if(!mDragging ) {
mDragging = true;
}
else {
::lunarlady::math::vec2 move = movement - last;
if( event.ShiftDown() ) {
mWorld->changePosition(move * 6);
}
else {
mWorld->changeRotation(-move * 2);
}
refresh = true;
}
last = movement;;
}
else {
mDragging = false;
}
mWorld->mRotating = mDragging;
if( mTool.get() ) {
if( mTool->onInput(movement, event) ) {
refresh = true;
}
}
return refresh;
}
void WorldView::doPaint() {
mWorld->render(mRenderMode);
} | 25.401042 | 139 | 0.671519 | madeso |
42e6389a685752527efdbed31f762e7f4631e386 | 1,839 | cpp | C++ | src/http/HttpClient.cpp | SHIINASAMA/MyEngine | be71642d4b23877d156505369312fcb3629d1924 | [
"MIT"
] | null | null | null | src/http/HttpClient.cpp | SHIINASAMA/MyEngine | be71642d4b23877d156505369312fcb3629d1924 | [
"MIT"
] | null | null | null | src/http/HttpClient.cpp | SHIINASAMA/MyEngine | be71642d4b23877d156505369312fcb3629d1924 | [
"MIT"
] | null | null | null | /**
* @file HttpClient.cpp
* @author kaoru
* @date 2021.8.9
* @brief Http 客户端实现
* @version 0.1
*/
#include <http/HttpClient.h>
#include <http/HttpParser.h>
#include <sstream>
#include <utility>
using namespace MyEngine;
bool MyEngine::HttpClient::Get(const string &ipaddress, unsigned short port, const HttpRequest::Ptr& request, HttpResponse::Ptr response) noexcept {
request->setMethod(HttpMethod::GET);
request->setHttpVersion(11);
auto baseString = request->dump();
auto client = make_shared<TcpClient>(ipaddress.c_str(), port);
client->createTcpSocket();
if (client->connect()) {
auto send_len = client->send(baseString.c_str(), baseString.length(), 0);
if (send_len != baseString.length()) {
client->close();
return false;
}
if (!HttpParser::ResponseParser(client, std::move(response))) {
client->close();
return false;
}
client->close();
return true;
} else {
return false;
}
}
bool HttpClient::Post(const string &ipaddress, unsigned short port, const HttpRequest::Ptr& request, HttpResponse::Ptr response) noexcept {
request->setMethod(HttpMethod::POST);
request->setHttpVersion(11);
auto baseString = request->dump();
auto client = make_shared<TcpClient>(ipaddress.c_str(), port);
client->createTcpSocket();
if (client->connect()) {
auto send_len = client->send(baseString.c_str(), baseString.length(), 0);
if (send_len != baseString.length()) {
client->close();
return false;
}
if (!HttpParser::ResponseParser(client, std::move(response))) {
client->close();
return false;
}
client->close();
return true;
} else {
return false;
}
}
| 30.65 | 148 | 0.610658 | SHIINASAMA |
42e8144748b95314e8f21246c6b5acdafa9900a2 | 4,126 | cpp | C++ | src/Engine/BoxCollider.cpp | kevinmkchin/ADK | 46e0e18e359ebcd4a0ccef36dc9f5d5280858a0f | [
"MIT"
] | 15 | 2021-01-24T23:04:33.000Z | 2022-01-12T02:04:50.000Z | src/Engine/BoxCollider.cpp | kevinmkchin/ADK | 46e0e18e359ebcd4a0ccef36dc9f5d5280858a0f | [
"MIT"
] | 9 | 2021-02-03T09:08:47.000Z | 2021-05-16T20:06:17.000Z | src/Engine/BoxCollider.cpp | kevinmkchin/ADK | 46e0e18e359ebcd4a0ccef36dc9f5d5280858a0f | [
"MIT"
] | 2 | 2021-02-26T19:07:39.000Z | 2021-08-22T05:15:46.000Z | #include "BoxCollider.h"
#include <cassert>
#include <cstdlib>
BoxCollider::BoxCollider()
{
offset_x = 0;
offset_y = 0;
left = 0;
top = 0;
width = 0;
height = 0;
}
BoxCollider::BoxCollider(float InLeft, float InTop, float InWidth, float InHeight)
{
offset_x = 0;
offset_y = 0;
left = InLeft;
top = InTop;
width = InWidth;
height = InHeight;
}
BoxCollider::BoxCollider(float InLeft, float InTop, float InOffsetX, float InOffsetY, float InWidth, float InHeight)
{
offset_x = InOffsetX;
offset_y = InOffsetY;
left = offset_x + InLeft;
top = offset_y + InTop;
width = InWidth;
height = InHeight;
}
void BoxCollider::set_pos(float x, float y)
{
left = offset_x + x;
top = offset_y + y;
}
void BoxCollider::set_pos(sf::Vector2f pos)
{
left = offset_x + pos.x;
top = offset_y + pos.y;
}
void BoxCollider::rotate(float by, sf::Vector2f origin)
{
// TODO
}
void BoxCollider::set_offsets(float x_offset, float y_offset)
{
offset_x = x_offset - offset_x;
offset_y = y_offset - offset_y;
left += offset_x;
top += offset_y;
offset_x = x_offset;
offset_y = y_offset;
}
void BoxCollider::move(float x, float y)
{
left += x;
top += y;
}
void BoxCollider::move(sf::Vector2f delta)
{
left += delta.x;
top += delta.y;
}
bool BoxCollider::intersects(BoxCollider& other)
{
float bot = top + height;
float right = left + width;
float otherbot = other.top + other.height;
float otherright = other.left + other.width;
bool notColliding = bot < other.top || top > otherbot || left > otherright || right < other.left;
if (notColliding == false)
{
return true;
}
else
{
return false;
}
return notColliding == false;
}
bool BoxCollider::contains(sf::Vector2f other)
{
float bot = top + height - 1;
float right = left + width - 1;
return (left <= other.x && other.x <= right) && (top <= other.y && other.y <= bot);
}
bool BoxCollider::will_touch_top(BoxCollider& other, float vel)
{
float bot = top + height;
float right = left + width;
float otherbot = other.top + other.height;
float otherright = other.left + other.width;
vel = abs(vel);
return
top - vel < otherbot &&
bot > otherbot &&
right > other.left &&
left < otherright;
}
bool BoxCollider::will_touch_bottom(BoxCollider& other, float vel)
{
float bot = top + height;
float right = left + width;
float otherright = other.left + other.width;
vel = abs(vel);
return
bot + vel > other.top &&
top < other.top &&
right > other.left &&
left < otherright;
}
bool BoxCollider::will_touch_left(BoxCollider& other, float vel)
{
float bot = top + height;
float right = left + width;
float otherbot = other.top + other.height;
float otherright = other.left + other.width;
vel = abs(vel);
return
left - vel < otherright &&
right > otherright &&
bot > other.top &&
top < otherbot;
}
bool BoxCollider::will_touch_right(BoxCollider& other, float vel)
{
float bot = top + height;
float right = left + width;
float otherbot = other.top + other.height;
float otherright = other.left + other.width;
if (top > otherbot)
{
printf("");
}
vel = abs(vel);
return
right + vel > other.left &&
left < other.left &&
bot > other.top &&
top < otherbot;
}
sf::Vector2f BoxCollider::resolve_collision_rect(BoxCollider& other)
{
// Check we are colliding with it
if (!intersects(other))
{
return sf::Vector2f(0, 0);
}
float bot = top + height;
float right = left + width;
float otherbot = other.top + other.height;
float otherright = other.left + other.width;
// Find distance to move to each side
float toTop = other.top - bot;
float toBot = otherbot - top;
float toLeft = other.left - right;
float toRight = otherright - left;
// Get minimum distance to a side
float min = std::min({ std::abs(toTop), std::abs(toBot), std::abs(toLeft), std::abs(toRight) });
if (std::abs(toTop) == min)
{
return sf::Vector2f(0.f, toTop);
}
else if (std::abs(toBot) == min)
{
return sf::Vector2f(0.f, toBot);
}
else if (std::abs(toLeft) == min)
{
return sf::Vector2f(toLeft, 0.f);
}
else
{
assert(std::abs(toRight) == min);
return sf::Vector2f(toRight, 0.f);
}
} | 19.741627 | 116 | 0.663597 | kevinmkchin |
42eb87bc8f1cfecc71113ef2f638a0a9187acfeb | 16,331 | cpp | C++ | src/databases/Dyna3D/MaterialProperties.cpp | visit-dav/vis | c08bc6e538ecd7d30ddc6399ec3022b9e062127e | [
"BSD-3-Clause"
] | 226 | 2018-12-29T01:13:49.000Z | 2022-03-30T19:16:31.000Z | src/databases/Dyna3D/MaterialProperties.cpp | visit-dav/vis | c08bc6e538ecd7d30ddc6399ec3022b9e062127e | [
"BSD-3-Clause"
] | 5,100 | 2019-01-14T18:19:25.000Z | 2022-03-31T23:08:36.000Z | src/databases/Dyna3D/MaterialProperties.cpp | visit-dav/vis | c08bc6e538ecd7d30ddc6399ec3022b9e062127e | [
"BSD-3-Clause"
] | 84 | 2019-01-24T17:41:50.000Z | 2022-03-10T10:01:46.000Z | #include <MaterialProperties.h>
#include <cstring>
#include <cstdio>
// ****************************************************************************
// Method: MaterialProperties::MaterialProperties
//
// Purpose:
// Constructor
//
// Programmer: Brad Whitlock
// Creation: Mon Mar 9 16:04:53 PDT 2009
//
// Modifications:
//
// ****************************************************************************
MaterialProperties::MaterialProperties() :
enabled(true),
materialNumber(0),
materialName(), eosName(),
density(0.), strength(0.), equivalentPlasticStrain(0.), materialLines()
{
memset(materialInformation, 0, sizeof(double) * MATERIALPROPERTIES_NUM_ITEMS);
}
// ****************************************************************************
// Method: MaterialProperties::RequiresEOS
//
// Purpose:
// Returns whether this material properties object requires EOS. Taken from
// pp.165-166 of Dyna3D.pdf.
//
// Arguments:
//
// Returns:
//
// Note:
//
// Programmer: Brad Whitlock
// Creation: Thu Jan 26 15:28:10 PST 2012
//
// Modifications:
//
// ****************************************************************************
bool
MaterialProperties::RequiresEOS() const
{
const int modelsWithEOS[] = {10,11,15,16,17,45,64,65};
int materialType = int(this->materialInformation[0]);
for(int i = 0; i < 8; ++i)
if(modelsWithEOS[i] == materialType)
return true;
return false;
}
static int GetI(char *line, int c0, int c1)
{
int value = 0;
char tmp;
tmp = line[c1];
line[c1] = '\0';
sscanf(line + c0 - 1, "%d", &value);
line[c1] = tmp;
return value;
}
static double GetD(char *line, int c0, int c1)
{
double value = 0;
char tmp;
tmp = line[c1];
line[c1] = '\0';
sscanf(line + c0 - 1, "%lg", &value);
line[c1] = tmp;
return value;
}
static void GetD10(char *line, double *v, int n)
{
for(int i = 0; i < n; ++i)
v[i] = GetD(line, i*10+1, (i+1)*10);
}
static void GetD16(char *line, double *v, int n)
{
for(int i = 0; i < n; ++i)
v[i] = GetD(line, i*16+1, (i+1)*16);
}
// ****************************************************************************
// Method: MaterialProperties::ReadCard
//
// Purpose:
// Read the material information from a Dyna3D format material card.
//
// Arguments:
// readline : A callback function that can get a line of text.
// cbdata : Data for the callback function.
//
// Returns:
//
// Note:
//
// Programmer: Brad Whitlock
// Creation: Thu Jan 26 12:21:38 PST 2012
//
// Modifications:
// Brad Whitlock, Fri Mar 9 10:24:04 PST 2012
// I added material models 10, 15.
//
// ****************************************************************************
static void
fillspaces(char *buf, int buflen)
{
for(int i = 0; i < buflen; ++i)
buf[i] = ' ';
buf[buflen-1] = '\0';
}
void
MaterialProperties::ReadCard(void (*readline_cb)(char *, int, void *), void *cbdata)
{
if(readline_cb == NULL)
return;
char line[1024];
memset(line, 0, 1024 * sizeof(char));
#define readline fillspaces(line, 1024);readline_cb
//
// The structure of the material card is taken from DYNA3D.pdf section 4.4.
// I found that file in /usr/gapps/mdg/doc. We're just reading a small
// subset of material types presently.
//
readline(line, 1024, cbdata);
this->materialNumber = GetI(line, 1, 5);
this->materialInformation[0] = GetI(line, 6, 10); // Material type
this->materialInformation[1] = GetD(line, 11,20); // Density
this->density = materialInformation[1];
this->materialInformation[2] = GetI(line, 21,25); // EOS type
this->materialInformation[3] = GetI(line, 26,30); // Hourglass stabilization method
this->materialInformation[4] = GetD(line, 31,40); // Hourglass stabilization coefficient
this->materialInformation[5] = GetI(line, 41,45); // Bulk viscosity type for shock capture
this->materialInformation[6] = GetD(line, 46,55); // Quadratic bulk viscosity coefficient
this->materialInformation[7] = GetD(line, 56,65); // Linear bulk viscosity coefficient
this->materialInformation[8] = GetI(line, 66,70); // Element type for which this material model is valid
this->materialInformation[9] = GetI(line, 71,75); // unused
this->materialInformation[10]= GetI(line, 76,80); // Element formulation.
// Read the name line of the material card and strip out
// extra spaces from the name.
readline(line, 1024, cbdata);
char matNameBuf[1024];
memset(matNameBuf, 0, 1024);
char *s = matNameBuf, *ptr = line;
while(*ptr != '\0' && ((s - matNameBuf) < 1024))
{
if(*ptr == ' ')
{
*s++ = *ptr;
while(*ptr == ' ')
ptr++;
}
else if(*ptr != '\n')
{
*s++ = *ptr++;
}
}
this->materialName = matNameBuf;
if(this->materialName == " ")
this->materialName = std::string();
int materialType = int(this->materialInformation[0]);
double *v = this->materialInformation + 11;
if(materialType <= 1)
{
// Material type 1 has the following format:
for(int i = 0; i < 6; ++i)
{
readline(line, 1024, cbdata);
GetD10(line, v, 8);
v += 8;
}
}
else if(materialType == 10)
{
// DYNA3D.pdf page 205
readline(line, 1024, cbdata);
GetD10(line, v, 8);
this->strength = v[1];
bool needCard9 = v[7] > 0.;
v += 8;
readline(line, 1024, cbdata);
GetD10(line, v, 8);
this->equivalentPlasticStrain = v[0];
v += 8;
readline(line, 1024, cbdata);
GetD10(line, v, 8);
v += 8;
readline(line, 1024, cbdata);
GetD10(line, v, 8);
v += 8;
readline(line, 1024, cbdata);
GetD10(line, v, 8);
v += 8;
readline(line, 1024, cbdata);
GetD10(line, v, 8);
v += 8;
if(needCard9)
{
readline(line, 1024, cbdata);
GetD10(line, v, 4);
v += 4;
}
}
else if(materialType == 11)
{
readline(line, 1024, cbdata);
this->strength = v[1]; // card3, value 2
GetD10(line, v, 8);
v += 8;
readline(line, 1024, cbdata);
GetD10(line, v, 5);
v += 5;
readline(line, 1024, cbdata);
GetD10(line, v, 8);
v += 8;
readline(line, 1024, cbdata);
this->equivalentPlasticStrain = v[2]; // card6, value 3
GetD10(line, v, 7);
v += 7;
#if 1
// This is how it is described in the book.
for(int i = 0; i < 2; ++i)
{
readline(line, 1024, cbdata);
GetD16(line, v, 5);
v += 5;
}
#else
// This is how I've seen it in a file.
readline(line, 1024, cbdata);
GetD16(line, v, 1);
v ++;
readline(line, 1024, cbdata);
GetD16(line, v, 1);
v ++;
#endif
}
else if(materialType == 15)
{
// DYNA3D.pdf page 225
readline(line, 1024, cbdata);
GetD10(line, v, 8);
this->strength = v[1];
v += 8;
readline(line, 1024, cbdata);
GetD10(line, v, 6);
this->equivalentPlasticStrain = v[0];
v += 6;
readline(line, 1024, cbdata);
GetD10(line, v, 7);
v += 7;
readline(line, 1024, cbdata);
GetD10(line, v, 6);
v += 6;
readline(line, 1024, cbdata);
GetD10(line, v, 4);
v += 4;
// Read as - - val - val
// The dash represents a value we read from spaces but store anyway.
// We don't write it back out that way.
readline(line, 1024, cbdata);
GetD10(line, v, 5);
v += 5;
}
else if(materialType == 64)
{
// Material type 64 has the following format:
for(int i = 0; i < 5; ++i)
{
readline(line, 1024, cbdata);
GetD10(line, v, 8);
v += 8;
}
for(int i = 0; i < 2; ++i)
{
readline(line, 1024, cbdata);
GetD16(line, v, 5);
v += 5;
}
this->strength = materialInformation[12];
this->equivalentPlasticStrain = materialInformation[19];
}
else
{
// Assume that the material has 8 cards. We've read 2.
for(int i = 0; i < 6; ++i)
{
readline(line, 1024, cbdata);
this->materialLines.push_back(std::string(line));
}
}
int eosType = int(this->materialInformation[2]);
if(eosType > 0)
{
// DYNA3D.pdf page 445
readline(line, 1024, cbdata);
this->eosName = std::string(line);
readline(line, 1024, cbdata);
GetD10(line, v, 8);
v += 8;
if(eosType == 4)
{
}
else // most forms are like form 1, which has 1 more number.
{
readline(line, 1024, cbdata);
v[0] = GetD(line, 1,10);
}
}
}
// ****************************************************************************
// Method: MaterialProperties::WriteCard
//
// Purpose:
// Write the material information as a Dyna3D format material card.
//
// Arguments:
// writeline : A callback function that can write a line of text.
// cbdata : Data for the callback function.
//
// Returns:
//
// Note:
//
// Programmer: Brad Whitlock
// Creation: Thu Jan 26 12:21:38 PST 2012
//
// Modifications:
// Brad Whitlock, Fri Mar 9 10:26:04 PST 2012
// I added material models 10, 15.
//
// ****************************************************************************
void
MaterialProperties::WriteCard(void (*writeline)(const char *, void *), void *cbdata) const
{
// Make a mutable copy of the materialInformation so we can override some values.
double mvalues[MATERIALPROPERTIES_NUM_ITEMS];
memcpy(mvalues, this->materialInformation, sizeof(double) * MATERIALPROPERTIES_NUM_ITEMS);
mvalues[1] = this->density;
char line[200];
sprintf(line,
"%5d" "%5d" "%1.4lE" "%5d" "%5d" "%1.4lE" "%5d" "%1.4lE" "%1.4lE" "%5d" "%5d" "%5d",
this->materialNumber,
int(mvalues[0]), //I
mvalues[1], //D
int(mvalues[2]), //I
int(mvalues[3]), //I
mvalues[4], //D
int(mvalues[5]), //I
mvalues[6], //D
mvalues[7], //D
int(mvalues[8]), //I
int(mvalues[9]), //I
int(mvalues[10]) //I
);
writeline(line, cbdata);
writeline(this->materialName.c_str(), cbdata);
int materialType = int(mvalues[0]);
const double *v = mvalues + 11;
if(materialType <= 1)
{
for(int i = 0; i < 6; ++i)
{
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
writeline(line, cbdata);
v += 8;
}
}
else if(materialType == 10)
{
bool needCard9 = mvalues[18] > 0.;
// Poke potentially modified values back into mvalues before we write out.
mvalues[12] = this->strength;
mvalues[19] = this->equivalentPlasticStrain;
for(int i = 0; i < 6; ++i)
{
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
writeline(line, cbdata);
v += 8;
}
if(needCard9)
{
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3]);
writeline(line, cbdata);
v += 4;
}
}
else if(materialType == 11)
{
// Poke potentially modified values back into mvalues before we write out.
mvalues[12] = this->strength;
mvalues[34] = this->equivalentPlasticStrain;
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
writeline(line, cbdata);
v += 8;
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4]);
writeline(line, cbdata);
v += 5;
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
writeline(line, cbdata);
v += 8;
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5], v[6]);
writeline(line, cbdata);
v += 7;
#if 1
// This is how it is described in the book
for(int i = 0; i < 2; ++i)
{
sprintf(line,
"% 1.9lE"
"% 1.9lE"
"% 1.9lE"
"% 1.9lE"
"% 1.9lE",
v[0], v[1], v[2], v[3], v[4]);
writeline(line, cbdata);
v += 5;
}
#else
// This is what I've seen in practice.
sprintf(line, "% 1.9lE", v[0]);
writeline(line, cbdata);
v ++;
sprintf(line, "% 1.9lE", v[0]);
writeline(line, cbdata);
v ++;
#endif
}
else if(materialType == 15)
{
// Poke potentially modified values back into mvalues before we write out.
mvalues[12] = this->strength;
mvalues[19] = this->equivalentPlasticStrain;
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
writeline(line, cbdata);
v += 8;
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5]);
writeline(line, cbdata);
v += 6;
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5], v[6]);
writeline(line, cbdata);
v += 7;
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5]);
writeline(line, cbdata);
v += 6;
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3]);
writeline(line, cbdata);
v += 4;
sprintf(line, " % 1.3lE % 1.3lE",
v[2], v[4]);
writeline(line, cbdata);
v += 5;
}
else if(materialType == 64)
{
// Poke potentially modified values back into mvalues before we write out.
mvalues[12] = this->strength;
mvalues[19] = this->equivalentPlasticStrain;
for(int i = 0; i < 5; ++i)
{
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
writeline(line, cbdata);
v += 8;
}
for(int i = 0; i < 2; ++i)
{
sprintf(line,
" % 1.3lE"
" % 1.3lE"
" % 1.3lE"
" % 1.3lE"
" % 1.3lE",
v[0], v[1], v[2], v[3], v[4]);
writeline(line, cbdata);
v += 5;
}
}
else
{
// We don't understand the material type so print out text that we
// stashed from the file.
for(size_t i = 0; i < this->materialLines.size(); ++i)
writeline(this->materialLines[i].c_str(), cbdata);
}
if(RequiresEOS())
{
// DYNA3D.pdf page 445
writeline(this->eosName.c_str(), cbdata);
sprintf(line, "% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE% 1.3lE",
v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
writeline(line, cbdata);
v += 8;
int eosType = int(this->materialInformation[2]);
if(eosType == 4)
{
}
else // Form 1 and those derived from it.
{
sprintf(line, "% 1.3lE", v[0]);
writeline(line, cbdata);
}
}
}
| 28.550699 | 108 | 0.482457 | visit-dav |
42ebbf10bf88d3102bf9258a91c1492eec12df0a | 746 | cpp | C++ | src/problems/101-150/145/problem145.cpp | abeccaro/project-euler | c3b124bb973dc3a1cf29e8c96c3e70c8816d5fa3 | [
"MIT"
] | 1 | 2019-12-25T10:17:15.000Z | 2019-12-25T10:17:15.000Z | src/problems/101-150/145/problem145.cpp | abeccaro/project-euler | c3b124bb973dc3a1cf29e8c96c3e70c8816d5fa3 | [
"MIT"
] | null | null | null | src/problems/101-150/145/problem145.cpp | abeccaro/project-euler | c3b124bb973dc3a1cf29e8c96c3e70c8816d5fa3 | [
"MIT"
] | null | null | null | //
// Created by Alex Beccaro on 16/01/2020.
//
#include "problem145.hpp"
#include <generics.hpp>
using generics::int_pow;
namespace problems {
uint32_t problem145::solve(uint32_t ub_exp) {
uint32_t res = 0;
for (uint32_t e = 2; e <= ub_exp; e++) {
uint32_t mod = e % 4;
switch(mod) {
case 0:
case 2: {
res += 20 * int_pow(30u, e / 2 - 1);
break;
}
case 3: {
res += int_pow(25u, e / 4) * int_pow(20u, e / 4 + 1) * 5;
break;
}
case 1:
default: break;
}
}
return res;
}
} | 20.162162 | 77 | 0.395442 | abeccaro |
42ecaf0e56bd5b02ae8771a1b000bff0ff932233 | 1,067 | hpp | C++ | Tut11/Pickable.hpp | vrum/rlTut | 0907b357c51a0b983ff8812f5c4887ecb185c9fa | [
"MIT"
] | null | null | null | Tut11/Pickable.hpp | vrum/rlTut | 0907b357c51a0b983ff8812f5c4887ecb185c9fa | [
"MIT"
] | null | null | null | Tut11/Pickable.hpp | vrum/rlTut | 0907b357c51a0b983ff8812f5c4887ecb185c9fa | [
"MIT"
] | null | null | null | class Pickable : public Persistent {
public :
bool pick(Actor *owner, Actor *wearer);
void drop(Actor *owner, Actor *wearer);
virtual bool use(Actor *owner, Actor *wearer);
static Pickable *create (TCODZip &zip);
protected :
enum PickableType {
HEALER,LIGHTNING_BOLT,CONFUSER,FIREBALL
};
};
class Healer : public Pickable {
public :
float amount; // how many hp
Healer(float amount);
bool use(Actor *owner, Actor *wearer);
void load(TCODZip &zip);
void save(TCODZip &zip);
};
class LightningBolt : public Pickable {
public :
float range,damage;
LightningBolt(float range, float damage);
bool use(Actor *owner, Actor *wearer);
void load(TCODZip &zip);
void save(TCODZip &zip);
};
class Confuser : public Pickable {
public :
int nbTurns;
float range;
Confuser(int nbTurns, float range);
bool use(Actor *owner, Actor *wearer);
void load(TCODZip &zip);
void save(TCODZip &zip);
};
class Fireball : public LightningBolt {
public :
Fireball(float range, float damage);
bool use(Actor *owner, Actor *wearer);
void save(TCODZip &zip);
};
| 21.77551 | 47 | 0.713215 | vrum |
42edb46d60dbb5d26f9f9236512ea5f7bea6385c | 21 | cpp | C++ | Solve/Tree/AvlTree.cpp | nolmegamelab/Learn | 29146fc1ba2b3fddb8c85e256362e112b43173fe | [
"MIT"
] | null | null | null | Solve/Tree/AvlTree.cpp | nolmegamelab/Learn | 29146fc1ba2b3fddb8c85e256362e112b43173fe | [
"MIT"
] | null | null | null | Solve/Tree/AvlTree.cpp | nolmegamelab/Learn | 29146fc1ba2b3fddb8c85e256362e112b43173fe | [
"MIT"
] | null | null | null | #include <functional> | 21 | 21 | 0.809524 | nolmegamelab |
42eddc555fa9a5d221c47d3cc203c23b41bad4c7 | 10,000 | cpp | C++ | main/jim-and-his-lan-party/jim-and-his-lan-party.cpp | EliahKagan/old-practice-snapshot | 1b53897eac6902f8d867c8f154ce2a489abb8133 | [
"0BSD"
] | null | null | null | main/jim-and-his-lan-party/jim-and-his-lan-party.cpp | EliahKagan/old-practice-snapshot | 1b53897eac6902f8d867c8f154ce2a489abb8133 | [
"0BSD"
] | null | null | null | main/jim-and-his-lan-party/jim-and-his-lan-party.cpp | EliahKagan/old-practice-snapshot | 1b53897eac6902f8d867c8f154ce2a489abb8133 | [
"0BSD"
] | null | null | null | #ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
#ifdef __MINGW32__
#define __USE_MINGW_ANSI_STDIO 1
#endif
#include <algorithm>
#include <cstdio>
#include <iterator>
#include <memory>
#include <unordered_map>
#include <utility>
#include <vector>
namespace {
using std::size_t;
class DisjointPlayerSets {
public:
class iterator {
friend class DisjointPlayerSets;
friend bool operator==(const iterator& lhs,
const iterator& rhs) noexcept;
public:
using difference_type = void;
using value_type = int;
using pointer = void;
using reference = value_type; // OK, we are not a ForwardIterator
using iterator_category = std::input_iterator_tag;
int operator*() const noexcept;
iterator& operator++() noexcept;
iterator operator++(int) noexcept;
private:
static constexpr auto game_not_started = -1;
explicit iterator(std::vector<int>::const_iterator pos) noexcept;
std::vector<int>::const_iterator pos_;
};
using const_iterator = iterator;
// @param player_games player -> game
explicit DisjointPlayerSets(const std::vector<unsigned>& player_games,
size_t game_count);
// advances the clock, joining and merging contributions from player1's
// and player2's sublans if they were not already joined
void connect(size_t player1, size_t player2);
// begin/cbegin and end/cend iterate through game start times
iterator begin() const noexcept;
iterator cbegin() const noexcept { return begin(); }
iterator end() const noexcept;
iterator cend() const noexcept { return end(); }
private:
// (game -> negative population) map type
using Contributions = std::unordered_map<unsigned, int>;
// finds the leader of the player's connected sublan
size_t find_set(size_t player) noexcept;
// perform a union of the sublans by rank if they were separate
// @return the old leaders, with the new leader first
std::pair<size_t, size_t> unite(size_t player1,
size_t player2) noexcept;
// merges the population contributions of what had been two sublans
void merge_contribs(size_t dest_player, size_t src_player);
// merges two (game, population) hash tables, removing and recording
// start times for games that have reached their starting populations
void merge_nontrivial_contribs(Contributions& dest,
const Contributions& src);
// set leader -> (game -> negative population)
std::vector<std::unique_ptr<Contributions>> contribs_;
// player -> nonnegatve DSU parent, or negative DSU rank if set leader
std::vector<int> parents_or_ranks_;
// game -> negative population target, or nonneg start time if started
std::vector<int> pop_targets_or_start_times_;
// current time
int time_ {0};
};
inline bool operator==(const DisjointPlayerSets::iterator& lhs,
const DisjointPlayerSets::iterator& rhs) noexcept
{
return lhs.pos_ == rhs.pos_;
}
inline bool operator!=(const DisjointPlayerSets::iterator& lhs,
const DisjointPlayerSets::iterator& rhs) noexcept
{
return !(lhs == rhs);
}
inline int DisjointPlayerSets::iterator::operator*() const noexcept
{
const auto start_time = *pos_;
return start_time < 0 ? game_not_started : start_time;
}
inline auto DisjointPlayerSets::iterator::operator++() noexcept
-> iterator&
{
++pos_;
return *this;
}
inline auto DisjointPlayerSets::iterator::operator++(int) noexcept
-> iterator
{
auto ret = *this;
++pos_;
return ret;
}
inline DisjointPlayerSets::iterator::iterator(
const std::vector<int>::const_iterator pos) noexcept
: pos_{pos}
{
}
DisjointPlayerSets::DisjointPlayerSets(
const std::vector<unsigned>& player_games, const size_t game_count)
: contribs_(player_games.size()),
parents_or_ranks_(player_games.size(), -1),
pop_targets_or_start_times_(game_count)
{
const auto player_count = player_games.size();
// determine how many players are needed for each game
for (size_t player {0u}; player != player_count; ++player) {
const auto game = player_games[player];
--pop_targets_or_start_times_[static_cast<size_t>(game)];
}
// start single-player games immediately
for (auto& elem : pop_targets_or_start_times_)
if (elem == -1) elem = 0;
// record players' population contributions toward multiplayer games
for (size_t player {0u}; player != player_count; ++player) {
const auto game = player_games[player];
if (pop_targets_or_start_times_[static_cast<size_t>(game)] != 0) {
auto& p = contribs_[player];
p = std::make_unique<Contributions>();
p->emplace(game, -1);
}
}
}
void DisjointPlayerSets::connect(size_t player1, size_t player2)
{
// one connection per tick of the clock
++time_;
// actually connect the sublans (if they are separate)
const auto endpoints = unite(player1, player2);
// unless the sublans were already joined, merge their contributions
if (endpoints.first != endpoints.second)
merge_contribs(endpoints.first, endpoints.second);
}
size_t DisjointPlayerSets::find_set(size_t player) noexcept
{
// find the leader
auto leader = player;
while (parents_or_ranks_[leader] >= 0)
leader = static_cast<size_t>(parents_or_ranks_[leader]);
// compress the path
for (const auto lead = static_cast<int>(leader); player != leader; ) {
const auto parent = static_cast<size_t>(parents_or_ranks_[player]);
parents_or_ranks_[player] = lead;
player = parent;
}
return leader;
}
std::pair<size_t, size_t> DisjointPlayerSets::unite(size_t player1,
size_t player2) noexcept
{
// find the leaders
player1 = find_set(player1);
player2 = find_set(player2);
// if the leaders are not already the same, then perform union by rank
if (player1 != player2) {
if (parents_or_ranks_[player1] > parents_or_ranks_[player2]) {
// player 2 has superior (more negative) rank; it stays leader
std::swap(player1, player2);
}
else if (parents_or_ranks_[player1] == parents_or_ranks_[player2]) {
// players have equal rank, so promote player1
--parents_or_ranks_[player1];
}
// whichever player is currently player1 remains the leader
parents_or_ranks_[player2] = static_cast<int>(player1);
}
return {player1, player2};
}
void DisjointPlayerSets::merge_contribs(const size_t dest_player,
const size_t src_player)
{
auto& srcp = contribs_[src_player];
if (!srcp) return;
auto& destp = contribs_[dest_player];
if (!destp) {
destp = std::move(srcp);
return;
}
if (destp->size() < srcp->size()) std::swap(destp, srcp);
merge_nontrivial_contribs(*destp, *srcp);
srcp = nullptr;
if (destp->empty()) destp = nullptr;
}
void DisjointPlayerSets::merge_nontrivial_contribs(Contributions& dest,
const Contributions& src)
{
const auto qq = std::cend(src);
for (auto q = std::cbegin(src); q != qq; ++q) {
const auto game = q->first;
const auto p = dest.find(game);
if (p == std::end(dest)) {
dest.insert(*q);
continue;
}
auto& elem = pop_targets_or_start_times_[static_cast<size_t>(game)];
if ((p->second += q->second) == elem) {
elem = time_;
dest.erase(p);
}
}
}
inline auto DisjointPlayerSets::begin() const noexcept -> iterator
{
return iterator{std::cbegin(pop_targets_or_start_times_)};
}
inline auto DisjointPlayerSets::end() const noexcept -> iterator
{
return iterator{std::cend(pop_targets_or_start_times_)};
}
std::vector<unsigned> read_player_games(const size_t n)
{
std::vector<unsigned> player_games (n + 1u); // +1 for 1-based indexing
const auto pp = std::end(player_games);
for (auto p = std::next(std::begin(player_games)); p != pp; ++p)
(void)std::scanf("%u", &*p);
return player_games;
}
}
int main()
{
// read initial parameters
size_t n, m {};
unsigned q {};
(void)std::scanf("%zu%zu%u", &n, &m, &q);
// read everyone's game and initialize the model (+1 for 1-based indexing)
DisjointPlayerSets network {read_player_games(n), m + 1u};
// read connection information and apply all the connections in order
for (size_t u {}, v {}; q != 0u; --q) {
(void)std::scanf("%zu%zu", &u, &v);
network.connect(u, v);
}
// output each game's start time
auto first = std::cbegin(network); // pre-C++17 std::next needs ForwardIt
std::for_each(++first, std::cend(network), [](const int start_time) {
std::printf("%d\n", start_time);
});
}
| 33.0033 | 80 | 0.5881 | EliahKagan |
0cd493232f23e85f201b21cd253bbad0beaa80e9 | 1,107 | cpp | C++ | go_fish.cpp | bolym/C-GoFish | 88bc0301d7915c039757528a288f33e4c4d1bb97 | [
"MIT"
] | 1 | 2021-03-10T01:10:01.000Z | 2021-03-10T01:10:01.000Z | go_fish.cpp | bolym/C-GoFish | 88bc0301d7915c039757528a288f33e4c4d1bb97 | [
"MIT"
] | null | null | null | go_fish.cpp | bolym/C-GoFish | 88bc0301d7915c039757528a288f33e4c4d1bb97 | [
"MIT"
] | null | null | null | /******************************************************************
* Program: go_fish.cpp
* Author: Michael Boly
* Date: 1/30/2019
* Description: Plays Go Fish by the rules
* Input: The user chooses an index of the cards in their hand to
request from the computer
* Output: A wholesome game of Go Fish guarenteed to satisfy your
gaming desires for hours on end.
*****************************************************************/
#include "game.hpp"
/******************************************************************
* Function: main()
* Description: Creates a game of Go Fish (user vs. computer) that
repeats until the user is as sick of playing Go Fish
as I am.
* Parameters: None
* Pre-Conditions: None
* Post-Conditions: The user will be appreciating your hard work.
******************************************************************/
int main(){
int again = 1;
while(again == 1){
Game game;
game.beginTurns();
again = game.checkInput("Enter 1 to play again or 2 to exit: ", "12");
}
}
| 35.709677 | 75 | 0.474255 | bolym |
0cd904b424d3abd62eb663746fbcd2abdbf9d888 | 6,237 | cpp | C++ | src/D3D9EXWrapper/ID3D9EXWrapper.cpp | GrimFlash/BBCF-Improvement-Mod-GGPO | 9482ead2edd70714f427d3a5683d17b19ab8ac2e | [
"MIT"
] | 48 | 2020-06-09T22:53:52.000Z | 2022-01-02T12:44:33.000Z | src/D3D9EXWrapper/ID3D9EXWrapper.cpp | GrimFlash/BBCF-Improvement-Mod-GGPO | 9482ead2edd70714f427d3a5683d17b19ab8ac2e | [
"MIT"
] | 2 | 2020-05-27T21:25:49.000Z | 2020-05-27T23:56:56.000Z | src/D3D9EXWrapper/ID3D9EXWrapper.cpp | GrimFlash/BBCF-Improvement-Mod-GGPO | 9482ead2edd70714f427d3a5683d17b19ab8ac2e | [
"MIT"
] | 12 | 2020-06-17T20:44:17.000Z | 2022-01-04T18:15:27.000Z | #include "ID3D9EXWrapper.h"
#include "ID3D9EXWrapper_Device.h"
#include "Core/logger.h"
Direct3D9ExWrapper::Direct3D9ExWrapper(IDirect3D9Ex **ppIDirect3D9Ex)
{
LOG(1, "cDirect3D9ExWrapper\n");
Direct3D9Ex = *ppIDirect3D9Ex;
*ppIDirect3D9Ex = this;
}
Direct3D9ExWrapper::~Direct3D9ExWrapper() {}
HRESULT APIENTRY Direct3D9ExWrapper::RegisterSoftwareDevice(void* pInitializeFunction)
{
return Direct3D9Ex->RegisterSoftwareDevice(pInitializeFunction);
}
HRESULT APIENTRY Direct3D9ExWrapper::QueryInterface(const IID &riid, void **ppvObj)
{
HRESULT hRes = Direct3D9Ex->QueryInterface(riid, ppvObj);
if (hRes == S_OK)
*ppvObj = this;
else
*ppvObj = NULL;
return hRes;
}
ULONG APIENTRY Direct3D9ExWrapper::AddRef()
{
return Direct3D9Ex->AddRef();
}
ULONG APIENTRY Direct3D9ExWrapper::Release()
{
ULONG res = Direct3D9Ex->Release();
if (res == 0)
delete this;
return res;
}
UINT APIENTRY Direct3D9ExWrapper::GetAdapterCount()
{
return Direct3D9Ex->GetAdapterCount();
}
HRESULT APIENTRY Direct3D9ExWrapper::GetAdapterIdentifier(UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER9* pIdentifier)
{
return Direct3D9Ex->GetAdapterIdentifier(Adapter, Flags, pIdentifier);
}
UINT APIENTRY Direct3D9ExWrapper::GetAdapterModeCount(UINT Adapter, D3DFORMAT Format)
{
return Direct3D9Ex->GetAdapterModeCount(Adapter, Format);
}
HRESULT APIENTRY Direct3D9ExWrapper::EnumAdapterModes(UINT Adapter, D3DFORMAT Format, UINT Mode, D3DDISPLAYMODE* pMode)
{
//LOG(1, "EnumAdapterModes\n");
HRESULT ret = Direct3D9Ex->EnumAdapterModes(Adapter, Format, Mode, pMode);
//LOG(1, "\t- Adapter: %u\n", Adapter);
//LOG(1, "\t- Format: %d\n", Format);
//LOG(1, "\t- Mode: %u\n", Mode);
//LOG(1, "\t- ReturnFormat: %d\n", pMode->Format);
//LOG(1, "\t- ReturnWidth: %u\n", pMode->Width);
//LOG(1, "\t- ReturnHeight: %d\n", pMode->Height);
//LOG(1, "\t- ReturnRefreshRate: %u\n", pMode->RefreshRate);
//Settings::savedSettings.adapterRefreshRate = pMode->RefreshRate;
return ret;
}
HRESULT APIENTRY Direct3D9ExWrapper::GetAdapterDisplayMode(UINT Adapter, D3DDISPLAYMODE* pMode)
{
return Direct3D9Ex->GetAdapterDisplayMode(Adapter, pMode);
}
HRESULT APIENTRY Direct3D9ExWrapper::CheckDeviceType(UINT Adapter, D3DDEVTYPE DevType, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat, BOOL bWindowed)
{
return Direct3D9Ex->CheckDeviceType(Adapter, DevType, AdapterFormat, BackBufferFormat, bWindowed);
}
HRESULT APIENTRY Direct3D9ExWrapper::CheckDeviceFormat(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, DWORD Usage, D3DRESOURCETYPE RType, D3DFORMAT CheckFormat)
{
return Direct3D9Ex->CheckDeviceFormat(Adapter, DeviceType, AdapterFormat, Usage, RType, CheckFormat);
}
HRESULT APIENTRY Direct3D9ExWrapper::CheckDeviceMultiSampleType(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SurfaceFormat, BOOL Windowed, D3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels)
{
return Direct3D9Ex->CheckDeviceMultiSampleType(Adapter, DeviceType, SurfaceFormat, Windowed, MultiSampleType, pQualityLevels);
}
HRESULT APIENTRY Direct3D9ExWrapper::CheckDepthStencilMatch(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT AdapterFormat, D3DFORMAT RenderTargetFormat, D3DFORMAT DepthStencilFormat)
{
return Direct3D9Ex->CheckDepthStencilMatch(Adapter, DeviceType, AdapterFormat, RenderTargetFormat, DepthStencilFormat);
}
HRESULT APIENTRY Direct3D9ExWrapper::CheckDeviceFormatConversion(UINT Adapter, D3DDEVTYPE DeviceType, D3DFORMAT SourceFormat, D3DFORMAT TargetFormat)
{
return Direct3D9Ex->CheckDeviceFormatConversion(Adapter, DeviceType, SourceFormat, TargetFormat);
}
HRESULT APIENTRY Direct3D9ExWrapper::GetDeviceCaps(UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS9* pCaps)
{
return Direct3D9Ex->GetDeviceCaps(Adapter, DeviceType, pCaps);
}
HMONITOR APIENTRY Direct3D9ExWrapper::GetAdapterMonitor(UINT Adapter)
{
return Direct3D9Ex->GetAdapterMonitor(Adapter);
}
HRESULT APIENTRY Direct3D9ExWrapper::CreateDevice(UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS *pPresentationParameters, IDirect3DDevice9 **ppReturnedDeviceInterface)
{
LOG(1, "CreateDevice\n")
HRESULT hRet = Direct3D9Ex->CreateDevice(Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, ppReturnedDeviceInterface);
if (SUCCEEDED(hRet))
{
Settings::applySettingsIni(pPresentationParameters);
}
return hRet;
}
UINT APIENTRY Direct3D9ExWrapper::GetAdapterModeCountEx(UINT Adapter, CONST D3DDISPLAYMODEFILTER* pFilter)
{
return Direct3D9Ex->GetAdapterModeCountEx(Adapter, pFilter);
}
HRESULT APIENTRY Direct3D9ExWrapper::EnumAdapterModesEx(UINT Adapter, CONST D3DDISPLAYMODEFILTER* pFilter, UINT Mode, D3DDISPLAYMODEEX* pMode)
{
return Direct3D9Ex->EnumAdapterModesEx(Adapter, pFilter, Mode, pMode);
}
HRESULT APIENTRY Direct3D9ExWrapper::GetAdapterDisplayModeEx(UINT Adapter, D3DDISPLAYMODEEX* pMode, D3DDISPLAYROTATION* pRotation)
{
return Direct3D9Ex->GetAdapterDisplayModeEx(Adapter, pMode, pRotation);
}
HRESULT APIENTRY Direct3D9ExWrapper::CreateDeviceEx(UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode, IDirect3DDevice9Ex** ppReturnedDeviceInterface)
{
LOG(1, "CreateDeviceEx:\n");
LOG(1, "\tAdapter: %d\n\tDeviceType: %d\n\thFocusWindow: 0x%p\n\tBehaviorFlags: 0x%p\n",
Adapter, DeviceType, hFocusWindow, BehaviorFlags);
logD3DPParams(pPresentationParameters, true);
HRESULT hRet = Direct3D9Ex->CreateDeviceEx(Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters, pFullscreenDisplayMode, ppReturnedDeviceInterface);
if (SUCCEEDED(hRet))
{
LOG(1, "CreateDeviceEx created with original PresentationParameters\n");
Settings::applySettingsIni(pPresentationParameters);
logD3DPParams(pPresentationParameters, false);
Direct3DDevice9ExWrapper *ret = new Direct3DDevice9ExWrapper(ppReturnedDeviceInterface, pPresentationParameters, this);
}
else
{
LOG(1, "CreateDeviceEx failed to be created with original PresentationParameters\n");
}
return hRet;
}
HRESULT APIENTRY Direct3D9ExWrapper::GetAdapterLUID(UINT Adapter, LUID * pLUID)
{
return Direct3D9Ex->GetAdapterLUID(Adapter, pLUID);
} | 35.4375 | 266 | 0.802629 | GrimFlash |
0cd9398fde86456988c5a8c14b855202799d773d | 974 | cpp | C++ | LeetCode/0416. Partition Equal Subset Sum/solution.cpp | InnoFang/oh-my-algorithms | f559dba371ce725a926725ad28d5e1c2facd0ab2 | [
"Apache-2.0"
] | 1 | 2017-03-31T15:24:01.000Z | 2017-03-31T15:24:01.000Z | LeetCode/0416. Partition Equal Subset Sum/solution.cpp | InnoFang/Algorithm-Library | 1896b9d8b1fa4cd73879aaecf97bc32d13ae0169 | [
"Apache-2.0"
] | null | null | null | LeetCode/0416. Partition Equal Subset Sum/solution.cpp | InnoFang/Algorithm-Library | 1896b9d8b1fa4cd73879aaecf97bc32d13ae0169 | [
"Apache-2.0"
] | null | null | null | /**
* 117 / 117 test cases passed.
* Runtime: 168 ms
* Memory Usage: 11.7 MB
*/
class Solution {
public:
bool canPartition(vector<int>& nums) {
int n = nums.size();
if (n < 2) return false;
int sum = 0, maxn = 0;
for (int i = 0; i < n; ++ i) {
sum += nums[i];
maxn = max(maxn, nums[i]);
}
int target = sum >> 1;
if (sum & 1 || maxn > target) return false;
vector<vector<bool>> dp(n, vector<bool>(target + 1));
for (int i = 0; i < n; ++ i) dp[i][0] = true;
dp[0][nums[0]] = true;
for (int i = 1; i < n; ++ i) {
int num = nums[i];
for (int j = 0; j <= target; ++ j) {
if (j >= num) {
dp[i][j] = dp[i - 1][j] || dp[i - 1][j - num];
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[n - 1][target];
}
};
| 27.828571 | 66 | 0.377823 | InnoFang |
0cda6397186e9a29a43c80c5790be10a0d1d03aa | 3,480 | cpp | C++ | Practice/2018/2018.4.4/BZOJ1558.cpp | SYCstudio/OI | 6e9bfc17dbd4b43467af9b19aa2aed41e28972fa | [
"MIT"
] | 4 | 2017-10-31T14:25:18.000Z | 2018-06-10T16:10:17.000Z | Practice/2018/2018.4.4/BZOJ1558.cpp | SYCstudio/OI | 6e9bfc17dbd4b43467af9b19aa2aed41e28972fa | [
"MIT"
] | null | null | null | Practice/2018/2018.4.4/BZOJ1558.cpp | SYCstudio/OI | 6e9bfc17dbd4b43467af9b19aa2aed41e28972fa | [
"MIT"
] | null | null | null | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
#define ll long long
#define mem(Arr,x) memset(Arr,x,sizeof(Arr))
#define lson (now<<1)
#define rson (lson|1)
#define MIN(a,b,c) min(a,min(b,c))
const int maxN=101000;
const int inf=2147483647;
class Data
{
public:
int f00,f01,f10,f11;
int left,right;
int lazy;
Data(){
lazy=0;
}
};
int n,m;
int Arr[maxN];
Data S[maxN<<2];
Data operator + (Data A,Data B);
void PushDown(int now);
void Build(int now,int l,int r);
void Modify(int now,int l,int r,int ql,int qr,int key);
Data Query(int now,int l,int r,int ql,int qr);
void OutpNum(int now,int l,int r);
int main()
{
//ios::sync_with_stdio(false);
scanf("%d",&n);
for (int i=1;i<=n;i++) scanf("%d",&Arr[i]);//cin>>Arr[i];
for (int i=n;i>=1;i--) Arr[i]=Arr[i]-Arr[i-1];
//for (int i=1;i<=n;i++) cout<<Arr[i]<<" ";cout<<endl;
Build(1,1,n);
//OutpNum(1,1,n);
cin>>m;
while (m--)
{
char opt;//cin>>opt;
opt=getchar();
while ((opt!='A')&&(opt!='B')) opt=getchar();
if (opt=='A')
{
int s,t,a,b;scanf("%d%d%d%d",&s,&t,&a,&b);//cin>>s>>t>>a>>b;
Modify(1,1,n,s,s,a);
if (s<t) Modify(1,1,n,s+1,t,b);
if (t<n) Modify(1,1,n,t+1,t+1,-(t-s)*b-a);
}
if (opt=='B')
{
int s,t;scanf("%d%d",&s,&t);//cin>>s>>t;
Data G=Query(1,1,n,s,t);
//cout<<G.f00<<" "<<G.f10<<" "<<G.f01<<" "<<G.f11<<endl;
//cout<<min(G.f11,G.f01)<<endl;
printf("%d\n",min(G.f11,G.f01));
}
//OutpNum(1,1,n);cout<<endl;
}
return 0;
}
Data operator + (Data A,Data B)
{
Data Ret;
Ret.left=A.left;Ret.right=B.right;
Ret.f00=MIN(A.f01+B.f10-(A.right==B.left),A.f00+B.f10,A.f01+B.f00);
Ret.f01=MIN(A.f01+B.f11-(A.right==B.left),A.f00+B.f11,A.f01+B.f01);
Ret.f10=MIN(A.f11+B.f10-(A.right==B.left),A.f10+B.f10,A.f11+B.f00);
Ret.f11=MIN(A.f11+B.f11-(A.right==B.left),A.f10+B.f11,A.f11+B.f01);
return Ret;
}
void PushDown(int now)
{
if (S[now].lazy)
{
int lz=S[now].lazy;
S[lson].left+=lz;S[lson].right+=lz;S[lson].lazy+=lz;
S[rson].left+=lz;S[rson].right+=lz;S[rson].lazy+=lz;
S[now].lazy=0;
}
return;
}
void Build(int now,int l,int r)
{
if (l==r)
{
S[now].f00=0;S[now].f10=S[now].f01=1;S[now].f11=1;
S[now].left=S[now].right=Arr[l];//cout<<now<<":"<<Arr[l]<<endl;
//cout<<l<<" "<<r<<" "<<S[now].left<<" "<<S[now].right<<endl;
return;
}
int mid=(l+r)>>1;
Build(lson,l,mid);Build(rson,mid+1,r);
S[now]=S[lson]+S[rson];
//cout<<l<<" "<<r<<" "<<S[now].left<<" "<<S[now].right<<endl;
return;
}
void Modify(int now,int l,int r,int ql,int qr,int key)
{
if ((l==ql)&&(r==qr))
{
S[now].left+=key;S[now].right+=key;S[now].lazy+=key;
return;
}
PushDown(now);
int mid=(l+r)>>1;
if (qr<=mid) Modify(lson,l,mid,ql,qr,key);
else if (ql>=mid+1) Modify(rson,mid+1,r,ql,qr,key);
else
{
Modify(lson,l,mid,ql,mid,key);
Modify(rson,mid+1,r,mid+1,qr,key);
}
S[now]=S[lson]+S[rson];
return;
}
Data Query(int now,int l,int r,int ql,int qr)
{
if ((l==ql)&&(r==qr)) return S[now];
PushDown(now);
int mid=(l+r)>>1;
if (qr<=mid) return Query(lson,l,mid,ql,qr);
else if (ql>=mid+1) return Query(rson,mid+1,r,ql,qr);
else return Query(lson,l,mid,ql,mid)+Query(rson,mid+1,r,mid+1,qr);
}
void OutpNum(int now,int l,int r)
{
cout<<"["<<l<<","<<r<<"]"<<S[now].f00<<" "<<S[now].f10<<" "<<S[now].f01<<" "<<S[now].f11<<" "<<S[now].left<<" "<<S[now].right<<endl;
if (l==r) return;
PushDown(now);
int mid=(l+r)>>1;
OutpNum(lson,l,mid);OutpNum(rson,mid+1,r);
return;
}
| 22.597403 | 133 | 0.57931 | SYCstudio |
0cdaad5be54819fa61817b5a794187c35d790328 | 2,910 | hpp | C++ | tests/unit/coherence/util/filter/LikeFilterTest.hpp | chpatel3/coherence-cpp-extend-client | 4ea5267eae32064dff1e73339aa3fbc9347ef0f6 | [
"UPL-1.0",
"Apache-2.0"
] | 6 | 2020-07-01T21:38:30.000Z | 2021-11-03T01:35:11.000Z | tests/unit/coherence/util/filter/LikeFilterTest.hpp | chpatel3/coherence-cpp-extend-client | 4ea5267eae32064dff1e73339aa3fbc9347ef0f6 | [
"UPL-1.0",
"Apache-2.0"
] | 1 | 2020-07-24T17:29:22.000Z | 2020-07-24T18:29:04.000Z | tests/unit/coherence/util/filter/LikeFilterTest.hpp | chpatel3/coherence-cpp-extend-client | 4ea5267eae32064dff1e73339aa3fbc9347ef0f6 | [
"UPL-1.0",
"Apache-2.0"
] | 6 | 2020-07-10T18:40:58.000Z | 2022-02-18T01:23:40.000Z | /*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
#include "cxxtest/TestSuite.h"
#include "coherence/lang.ns"
#include "coherence/util/extractor/IdentityExtractor.hpp"
#include "coherence/util/filter/LikeFilter.hpp"
using namespace coherence::lang;
using coherence::util::extractor::IdentityExtractor;
using coherence::util::filter::LikeFilter;
/**
* Test Suite for the LikeFilter.
*/
class LikeFilterSuite : public CxxTest::TestSuite
{
public:
/**
* Test LikeFilter
*/
void testLikeFilter()
{
LikeFilter::Handle hFilter;
hFilter = LikeFilter::create(
IdentityExtractor::getInstance(),
String::create("David"));
TS_ASSERT(hFilter->evaluate(String::create("David")));
hFilter = LikeFilter::create(
IdentityExtractor::getInstance(),
String::create("David"));
TS_ASSERT(!hFilter->evaluate(String::create("DaviD")));
hFilter = LikeFilter::create(
IdentityExtractor::getInstance(),
String::create("_avid"));
TS_ASSERT(hFilter->evaluate(String::create("David")));
hFilter = LikeFilter::create(
IdentityExtractor::getInstance(),
String::create("Davi_"));
TS_ASSERT(hFilter->evaluate(String::create("David")));
hFilter = LikeFilter::create(
IdentityExtractor::getInstance(),
String::create("Da_iD"));
TS_ASSERT(!hFilter->evaluate(String::create("David")));
hFilter = LikeFilter::create(
IdentityExtractor::getInstance(),
String::create("%vid"));
TS_ASSERT(hFilter->evaluate(String::create("David")));
hFilter = LikeFilter::create(
IdentityExtractor::getInstance(),
String::create("D%d"));
TS_ASSERT(hFilter->evaluate(String::create("David")));
hFilter = LikeFilter::create(
IdentityExtractor::getInstance(),
String::create("%v%"));
TS_ASSERT(hFilter->evaluate(String::create("David")));
//test case for COH-4020
hFilter = LikeFilter::create(
IdentityExtractor::getInstance(),
String::create("%GetLogonData_getAccountIndicativeInfoInput_7137B2C9070C4951AE00EE5C4F01435A%"));
TS_ASSERT(hFilter->evaluate(String::create("xGetLogonDataxgetAccountIndicativeInfoInputx7137B2C9070C4951AE00EE5C4F01435Axxx")));
}
};
| 37.307692 | 140 | 0.558076 | chpatel3 |
0cdc26208bc53b78b98ca4d69d5bd75dfab87216 | 424 | hpp | C++ | src/net.hpp | harry830622/fiduccia-mattheyses-partitioning | 0d4960f95f10cd83bd36504fd57ceeab43b0eed0 | [
"MIT"
] | null | null | null | src/net.hpp | harry830622/fiduccia-mattheyses-partitioning | 0d4960f95f10cd83bd36504fd57ceeab43b0eed0 | [
"MIT"
] | null | null | null | src/net.hpp | harry830622/fiduccia-mattheyses-partitioning | 0d4960f95f10cd83bd36504fd57ceeab43b0eed0 | [
"MIT"
] | null | null | null | #ifndef NET_HPP
#define NET_HPP
#include <iostream>
#include <string>
#include <vector>
class Net {
public:
Net(const std::string& name);
void Print(std::ostream& os = std::cout, int num_spaces = 0) const;
const std::string& Name() const;
int NumCells() const;
const std::vector<int>& CellIds() const;
void ConnectCell(int cell_id);
private:
std::string name_;
std::vector<int> cell_ids_;
};
#endif
| 16.307692 | 69 | 0.681604 | harry830622 |
0cdc682910ad6c68c751223b1cfae141a6d31cfa | 2,998 | cpp | C++ | mp/src/game/server/Mod/SF194_Disposer.cpp | hekar/luminousforts-2013 | 09f07df4def93fa0d774721375a6c7c9da26d71f | [
"Unlicense"
] | 7 | 2019-02-04T01:17:26.000Z | 2022-02-26T21:36:34.000Z | mp/src/game/server/Mod/SF194_Disposer.cpp | hekar/luminousforts-2013 | 09f07df4def93fa0d774721375a6c7c9da26d71f | [
"Unlicense"
] | 11 | 2016-05-06T22:44:46.000Z | 2016-05-06T22:45:03.000Z | mp/src/game/server/Mod/SF194_Disposer.cpp | hekar/luminousforts-2013 | 09f07df4def93fa0d774721375a6c7c9da26d71f | [
"Unlicense"
] | 2 | 2016-06-28T11:34:53.000Z | 2017-04-01T18:08:46.000Z | /* ***** BEGIN LICENSE BLOCK *****
Version: MPL 1.1/LGPL 2.1/GPL 2.0
The contents of this file are subject to the Mozilla Public License Version
1.1 (the "License"); you may not use this file except in compliance with
...
for the specific language governing rights and limitations under the
License.
The Original Code is for LuminousForts.
The Initial Developer of the Original Code is Hekar Khani.
Portions created by the Hekar Khani are Copyright (C) 2010
Hekar Khani. All Rights Reserved.
Contributor(s):
Hekar Khani <hekark@gmail.com>
Alternatively, the contents of this file may be used under the terms of
either of the GNU General Public License Version 2 or later (the "GPL"),
...
the terms of any one of the MPL, the GPL or the LGPL.
***** END LICENSE BLOCK ***** */
/*===============================================================
Server
SF Disposer Brush Entity
For backwards compatibility with SF 194.
Everything in the classic Flag applies to this flag, there's
just a layer for compatibility.
Last Updated Dec 08, 2009
===============================================================*/
#include "cbase.h"
#ifdef MOD_SF194
#include "CDisposerBase.h"
#include "CDisposerClassic.h"
// Original disposer is the same as SF 195's
LINK_ENTITY_TO_CLASS( func_disposer, CBlockDisposerClassic );
class CDisposerSF194 : public CBlockDisposerClassic
{
DECLARE_CLASS( CDisposerSF194, CBlockDisposerClassic )
DECLARE_DATADESC()
public:
CDisposerSF194();
~CDisposerSF194();
bool OnFlagTouch( CBaseEntity *pOther );
bool OnBlockTouch( CBaseEntity *pOther );
bool OnPlayerTouch( CBaseEntity *pOther );
private:
int m_bKillBlock;
int m_bKillFlag;
int m_bKillRed;
int m_bKillBlue;
};
LINK_ENTITY_TO_CLASS( func_disposer_selective, CDisposerSF194 );
BEGIN_DATADESC( CDisposerSF194 )
DEFINE_KEYFIELD( m_bKillBlock, FIELD_INTEGER, "KillBlocks" ),
DEFINE_KEYFIELD( m_bKillFlag, FIELD_INTEGER, "KillFlag" ),
DEFINE_KEYFIELD( m_bKillRed, FIELD_INTEGER, "KillRed" ),
DEFINE_KEYFIELD( m_bKillBlue, FIELD_INTEGER, "KillBlue" ),
END_DATADESC()
//
// Name: CDisposerSF194
// Author: Hekar Khani
// Description: Backward compatible disposer for Sourceforts 194 maps
// Notes:
//
CDisposerSF194::CDisposerSF194()
{
m_bKillBlock = FALSE;
m_bKillFlag = FALSE;
m_bKillRed = FALSE;
m_bKillBlue = FALSE;
}
CDisposerSF194::~CDisposerSF194()
{
}
bool CDisposerSF194::OnFlagTouch( CBaseEntity *pOther )
{
if ( m_bKillFlag )
{
return BaseClass::OnFlagTouch( pOther );
}
return false;
}
bool CDisposerSF194::OnBlockTouch( CBaseEntity *pOther )
{
if ( m_bKillBlock )
{
return BaseClass::OnBlockTouch( pOther );
}
return false;
}
bool CDisposerSF194::OnPlayerTouch( CBaseEntity *pOther )
{
if ( m_bKillRed && pOther->GetTeamNumber() == SDK_TEAM_RED )
{
return BaseClass::OnPlayerTouch( pOther );
}
else if ( m_bKillBlue && pOther->GetTeamNumber() == SDK_TEAM_BLUE )
{
return BaseClass::OnPlayerTouch( pOther );
}
return false;
}
#endif // MOD_SF194 | 23.061538 | 76 | 0.715477 | hekar |
0ce4328248d36a2d78fba3618cc5940317da0c10 | 16,729 | cpp | C++ | handlers/videohandler.cpp | Feqzz/qZoom-Client | ac68be4a10a1db66dcf276ee881d5fa093e5f718 | [
"MIT"
] | 3 | 2020-08-24T09:03:35.000Z | 2020-11-18T17:28:24.000Z | handlers/videohandler.cpp | Stykk-Gruppen/qZoom-Client | ac68be4a10a1db66dcf276ee881d5fa093e5f718 | [
"MIT"
] | 1 | 2020-08-24T13:59:24.000Z | 2020-08-24T13:59:24.000Z | handlers/videohandler.cpp | Feqzz/qZoom-Client | ac68be4a10a1db66dcf276ee881d5fa093e5f718 | [
"MIT"
] | 1 | 2021-09-27T15:33:25.000Z | 2021-09-27T15:33:25.000Z | #include "videohandler.h"
#define STREAM_PIX_FMT AV_PIX_FMT_YUV420P /* default pix_fmt */
/**
* @brief VideoHandler::VideoHandler
* @param cDeviceName
* @param _writeLock
* @param _time
* @param imageHandler
* @param _socketHandler
* @param bufferSize
* @param tcpSocketHandler
* @param screenShare
* @param parent
*/
VideoHandler::VideoHandler(QString cDeviceName, std::mutex* _writeLock,int64_t _time,
ImageHandler* imageHandler, UdpSocketHandler* _socketHandler,
int bufferSize, TcpSocketHandler* tcpSocketHandler, bool screenShare, QObject* parent): QObject(parent)
{
mScreenCapture = screenShare;
mTcpSocketHandler = tcpSocketHandler;
connect(this, &VideoHandler::callWriteHeader, mTcpSocketHandler, &TcpSocketHandler::sendVideoHeader);
mBufferSize = bufferSize;
mWriteToFile = false;
mSocketHandler = _socketHandler;
mTime = _time;
/*ScreenSharing stuff*/
if(mScreenCapture)
{
mSource = "x11grab";
this->mCameraDeviceName = buildScreenDeviceName();
}
else
{
this->mCameraDeviceName = cDeviceName;
mSource = "v4l2";
}
mImageHandler = imageHandler;
mWriteLock = _writeLock;
mStruct = new mSocketStruct;
mStruct->udpSocket = mSocketHandler;
mStruct->tcpSocket = tcpSocketHandler;
mStruct->headerSent = false;
}
/**
* @brief VideoHandler::buildScreenDeviceName
* @return
*/
QString VideoHandler::buildScreenDeviceName()
{
//Use system calls to find displayName and number for X11grab
QString displayName = SystemCall::exec("xdpyinfo | grep 'name of display:'");
QString displayNumber = SystemCall::exec("xdpyinfo | grep 'default screen number:'");
qDebug() << "ScreenInfo system call: " << displayName;
qDebug() << "ScreenInfo system call: " << displayNumber;
for(int i = 0; i < displayName.length(); i++)
{
if(displayName.at(i).isDigit())
{
displayName = displayName.at(i);
break;
}
}
for(int i = 0; i < displayNumber.length(); i++)
{
if(displayNumber.at(i).isDigit())
{
displayNumber = displayNumber.at(i);
break;
}
}
QScreen* screen = QGuiApplication::primaryScreen();
int a, b, c, d;
screen->geometry().getCoords(&a, &b, &c, &d);
QRect screenGeometry = screen->geometry();
mScreenHeight = screenGeometry.height();
mScreenWidth = screenGeometry.width();
QString screenDeviceName = ":" + displayName + "." + displayNumber + "+" + QString::number(a) + ", " + QString::number(b) + "," + QString::number(mScreenWidth) + "," + QString::number(mScreenHeight);
qDebug() << "ScreenDeviceName: " << screenDeviceName;
return screenDeviceName;
}
/**
* @brief VideoHandler::~VideoHandler
*/
VideoHandler::~VideoHandler()
{
delete mStruct;
}
/**
* @brief VideoHandler::init
* @return
*/
int VideoHandler::init()
{
mActive = false;
ifmt_ctx = NULL;
int ret;
//Find input video formats
AVInputFormat* videoInputFormat = av_find_input_format(mSource);
if(videoInputFormat == NULL)
{
qDebug() << "Not found videoFormat\n";
return -1;
}
AVDictionary* screenOpt = NULL;
if(mScreenCapture)
{
QString videoSize = QString::number(mScreenWidth) + "x" + QString::number(mScreenHeight);
std::string framerate = QString{}.setNum(30).toStdString();
av_dict_set(&screenOpt, "framerate", framerate.c_str(), 0);
av_dict_set(&screenOpt, "video_size", videoSize.toUtf8().data(), 0);
av_dict_set(&screenOpt, "probesize", "800000000", 0);
}
//Open VideoInput
if (avformat_open_input(&ifmt_ctx, mCameraDeviceName.toUtf8().data(), videoInputFormat, &screenOpt) < 0)
{
fprintf(stderr, "Could not open input file '%s'", mCameraDeviceName.toUtf8().data());
return -1;
}
av_dict_free(&screenOpt);
//Get stream information
if ((ret = avformat_find_stream_info(ifmt_ctx, 0)) < 0)
{
fprintf(stderr, "Failed to retrieve input stream information");
return -1;
}
//Print stream information
qDebug() << "Dumping video input";
av_dump_format(ifmt_ctx, 0, NULL, 0);
ret = avformat_alloc_output_context2(&ofmt_ctx, NULL, "ismv", NULL);
if (ret < 0)
{
fprintf(stderr, "Could not alloc output context with file '%s'", mFileName);
exit(1);
}
//Set Output codecs from guess
outputVideoCodec = avcodec_find_encoder(ofmt_ctx->oformat->video_codec);
//Allocate CodecContext for outputstreams
mOutputVideoCodecContext = avcodec_alloc_context3(outputVideoCodec);
//Loop gjennom inputstreams
for (int i = 0; (unsigned int)i < ifmt_ctx->nb_streams; i++)
{
AVStream *in_stream = ifmt_ctx->streams[i];
AVStream *out_stream;
qDebug() << "Input stream framerate: " << in_stream->r_frame_rate.num;
qDebug() << "Input stream timebase: " << in_stream->time_base.num << "/" << in_stream->time_base.den;
//Setter av inputcodec og codeccontext, så vi slipper bruke deprecated codec
inputVideoCodec = avcodec_find_decoder((ifmt_ctx)->streams[i]->codecpar->codec_id);
mInputVideoCodecContext = avcodec_alloc_context3(inputVideoCodec);
avcodec_parameters_to_context(mInputVideoCodecContext, in_stream->codecpar);
ret = avcodec_open2(mInputVideoCodecContext, inputVideoCodec, NULL);
mInputVideoCodecContext->framerate = in_stream->r_frame_rate;
mInputVideoCodecContext->time_base = in_stream->time_base;
//Lager ny outputStream
out_stream = avformat_new_stream(ofmt_ctx, outputVideoCodec);
//Denne trenger vi egentlig ikke lenger
mVideoStream = i;
//Setter div parametere.
//Denne krasher vanlig video også
mOutputVideoCodecContext->width = in_stream->codecpar->width;
mOutputVideoCodecContext->height = in_stream->codecpar->height;
if(mScreenCapture)
{
mOutputVideoCodecContext->width = 1920;
mOutputVideoCodecContext->height = 1080;
}
mOutputVideoCodecContext->pix_fmt = STREAM_PIX_FMT;
mOutputVideoCodecContext->time_base = mInputVideoCodecContext->time_base;
mOutputVideoCodecContext->max_b_frames = 0;
mOutputVideoCodecContext->gop_size = 1;
av_opt_set(mOutputVideoCodecContext->priv_data, "preset", "veryslow", 0);
//av_opt_set(mOutputVideoCodecContext->priv_data, "crf", "36", 0);//0 is lossless, 53 is worst possible quality
av_opt_set(mOutputVideoCodecContext->priv_data, "tune", "zerolatency", 0);
//Kopierer parametere inn i out_stream
avcodec_parameters_from_context(out_stream->codecpar, mOutputVideoCodecContext);
ret = avcodec_open2(mOutputVideoCodecContext, outputVideoCodec, NULL);
out_stream->time_base = in_stream->time_base;
//Sett convert context som brukes ved frame conversion senere.
img_convert_ctx = sws_getContext(
in_stream->codecpar->width,
in_stream->codecpar->height,
//in_stream->codec->pix_fmt,
(AVPixelFormat)in_stream->codecpar->format,
mOutputVideoCodecContext->width,
mOutputVideoCodecContext->height,
mOutputVideoCodecContext->pix_fmt,
SWS_BICUBIC,
NULL, NULL, NULL);
if (!out_stream)
{
fprintf(stderr, "Failed allocating output stream\n");
ret = AVERROR_UNKNOWN;
return -1;
}
out_stream->codecpar->codec_tag = 0;
if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
{
mOutputVideoCodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
}
//usikker på om denne må være før eller etter.
ret = avcodec_parameters_to_context(mOutputVideoCodecContext, out_stream->codecpar);
if (ret < 0)
{
qDebug() << "avcodec_parameters_to_context failed" << Q_FUNC_INFO;
exit(-1);
}
}
AVDictionary *options = NULL;
int avio_buffer_size = mBufferSize;
void *avio_buffer = av_malloc(avio_buffer_size);
AVIOContext* custom_io = avio_alloc_context (
(unsigned char*)avio_buffer, avio_buffer_size,
1, (void*) mStruct,
NULL, &custom_io_write, NULL);
ofmt_ctx->pb = custom_io;
av_dict_set(&options, "live", "1", 0);
qDebug() << "Dumping video output";
av_dump_format(ofmt_ctx, 0, NULL, 1);
ret = avformat_write_header(ofmt_ctx, &options);
if(ret < 0)
{
fprintf(stderr, "Could not open write header");
exit(1);
}
mStruct->headerSent = true;
return ret;
}
/**
* @brief VideoHandler::grabFrames
*/
void VideoHandler::grabFrames()
{
emit callWriteHeader();
mActive = true;
AVPacket* pkt = av_packet_alloc();
AVStream* out_stream;
AVPacket* outPacket = av_packet_alloc();
pkt->size = 0;
pkt->data = NULL;
if(pkt == NULL)
{
qDebug() << "pkt = null\n";
exit(1);
}
mVideoFrame = av_frame_alloc();
mVideoFrame->data[0] = NULL;
mVideoFrame->width = mInputVideoCodecContext->width;
mVideoFrame->height = mInputVideoCodecContext->height;
mVideoFrame->format = mInputVideoCodecContext->pix_fmt;
mScaledFrame = av_frame_alloc();
mScaledFrame->data[0] = NULL;
mScaledFrame->width = mOutputVideoCodecContext->width;
mScaledFrame->height = mOutputVideoCodecContext->height;
mScaledFrame->format = mOutputVideoCodecContext->pix_fmt;
int ret;
while ((ret = av_read_frame(ifmt_ctx, pkt)) >= 0 && !mAbortGrabFrames)
{
if(ret < 0)
{
qDebug() << "Input Avcodec open failed: " << ret << "\n";
exit(1);
}
ret = avcodec_send_packet(mInputVideoCodecContext, pkt);
if(ret < 0)
{
qDebug() << "Send packet error";
exit(1);
}
ret = avcodec_receive_frame(mInputVideoCodecContext, mVideoFrame);
if(ret < 0)
{
qDebug() << "Recieve frame error";
exit(1);
}
//If the input video format is not STREAM_PIX_FMT or if the input w/h does not match output w/h, do rescaling++
if (mInputVideoCodecContext->pix_fmt != STREAM_PIX_FMT ||
mOutputVideoCodecContext->width != mInputVideoCodecContext->width ||
mOutputVideoCodecContext->height != mInputVideoCodecContext->height)
{
int num_bytes = av_image_get_buffer_size(mOutputVideoCodecContext->pix_fmt, mOutputVideoCodecContext->width,
mOutputVideoCodecContext->height, 1);
uint8_t* frame2_buffer = (uint8_t *)av_malloc(num_bytes*sizeof(uint8_t));
av_image_fill_arrays(mScaledFrame->data, mScaledFrame->linesize,
frame2_buffer, mOutputVideoCodecContext->pix_fmt,
mOutputVideoCodecContext->width, mOutputVideoCodecContext->height, 1);
ret = sws_scale(img_convert_ctx, mVideoFrame->data,
mVideoFrame->linesize, 0,
mInputVideoCodecContext->height,
mScaledFrame->data, mScaledFrame->linesize);
if(ret < 0)
{
qDebug() << "Error with scale " << ret <<"\n";
exit(1);
}
if(mIsFirstPacket)
{
mPts = mTime;
mIsFirstPacket = false;
}
if (mScaledFrame)
{
mScaledFrame->pts = mPts;
mPts += ifmt_ctx->streams[0]->time_base.den/ifmt_ctx->streams[0]->r_frame_rate.num;
}
mImageHandler->readImage(mOutputVideoCodecContext, mScaledFrame, std::numeric_limits<uint8_t>::max());
ret = avcodec_send_frame(mOutputVideoCodecContext, mScaledFrame);
if(ret < 0)
{
qDebug() << "Error with send frame " << ret <<"\n";
exit(1);
}
av_free(frame2_buffer); //Viktig! Ellers skjer det memory leaks.
}
else
{
if(mIsFirstPacket)
{
mPts = mTime;
mIsFirstPacket = false;
}
if (mVideoFrame)
{
mVideoFrame->pts = mPts;
mPts += ifmt_ctx->streams[0]->time_base.den/ifmt_ctx->streams[0]->r_frame_rate.num;
}
mImageHandler->readImage(mOutputVideoCodecContext, mVideoFrame, std::numeric_limits<uint8_t>::max());
ret = avcodec_send_frame(mOutputVideoCodecContext, mVideoFrame);
if(ret < 0)
{
qDebug() << "Error with send frame " << ret <<"\n";
exit(1);
}
}
outPacket->data = NULL;
outPacket->size = 0;
if(ret < 0)
{
qDebug() << "Output Avcodec open failed: " << ret << "\n";
}
ret = avcodec_receive_packet(mOutputVideoCodecContext, outPacket);
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
{
mNumberOfSkippedFrames++;
continue;
}
else if (ret < 0)
{
fprintf(stderr, "Error with receive packet\n");
exit(1);
}
else
{
mNumberOfSkippedFrames = 0;
out_stream = ofmt_ctx->streams[pkt->stream_index];
AVRational encoderTimebase = mOutputVideoCodecContext->time_base;
AVRational muxerTimebase = out_stream->time_base;
outPacket->pts = av_rescale_q_rnd(outPacket->pts, encoderTimebase, muxerTimebase, (AVRounding) (AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
outPacket->dts = av_rescale_q_rnd(outPacket->dts, encoderTimebase, muxerTimebase, (AVRounding) (AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
outPacket->duration = av_rescale_q(outPacket->duration, encoderTimebase, muxerTimebase);
outPacket->pos = -1;
mWriteLock->lock();
int ret = av_interleaved_write_frame(ofmt_ctx, outPacket);
mWriteLock->unlock();
if (ret < 0)
{
qDebug() << "Error muxing packet" << Q_FUNC_INFO;
}
av_packet_unref(pkt);
av_packet_unref(outPacket);
}
av_packet_unref(pkt);
av_packet_unref(outPacket);
}
av_packet_free(&pkt);
av_packet_free(&outPacket);
av_frame_free(&mScaledFrame);
av_frame_free(&mVideoFrame);
close();
mImageHandler->setPeerVideoAsDisabled(std::numeric_limits<uint8_t>::max());
}
/**
* @brief VideoHandler::close
*/
void VideoHandler::close()
{
avcodec_free_context(&mOutputVideoCodecContext);
avcodec_free_context(&mInputVideoCodecContext);
avformat_close_input(&ifmt_ctx);
if (ofmt_ctx->pb)
{
av_freep(&ofmt_ctx->pb->buffer);
}
avio_context_free(&ofmt_ctx->pb);
avformat_free_context(ofmt_ctx);
sws_freeContext(img_convert_ctx);
mActive = false;
}
/**
* @brief VideoHandler::isActive
* @return
*/
bool VideoHandler::isActive() const
{
return mActive;
}
/**
* @brief VideoHandler::custom_io_write
* @param opaque
* @param buffer
* @param buffer_size
* @return
*/
int VideoHandler::custom_io_write(void* opaque, uint8_t *buffer, int buffer_size)
{
mSocketStruct *s = reinterpret_cast<mSocketStruct*>(opaque);
char *cptr = reinterpret_cast<char*>(const_cast<uint8_t*>(buffer));
QByteArray send;
send = QByteArray(reinterpret_cast<char*>(cptr), buffer_size);
if(!s->headerSent)
{
qDebug() << "INNE I HEADERSEND";
const QString stringLength = QString::number(send.size());
send.prepend(stringLength.toUtf8().data());
send.prepend(stringLength.size());
s->tcpSocket->appendToHeader(send);
return 0;
}
else
{
//Prepends the video header byte needed by socketHandler
const QString stringLength = QString::number(send.size());
send.prepend(stringLength.toUtf8().data());
send.prepend(stringLength.size());
send.prepend(int(1));
return s->udpSocket->sendDatagram(send);
}
}
/**
* @brief VideoHandler::toggleGrabFrames
* @param a
*/
void VideoHandler::toggleGrabFrames(bool a)
{
mAbortGrabFrames = !a;
}
| 32.295367 | 204 | 0.612768 | Feqzz |
0ce54717bb74591c682d27c6cb4398cac241e933 | 5,748 | cpp | C++ | src/c1001.cpp | lua511/hello-acm | a337d7c8c3c8384745ec8e2cf41e5cecb268c7be | [
"MIT"
] | null | null | null | src/c1001.cpp | lua511/hello-acm | a337d7c8c3c8384745ec8e2cf41e5cecb268c7be | [
"MIT"
] | null | null | null | src/c1001.cpp | lua511/hello-acm | a337d7c8c3c8384745ec8e2cf41e5cecb268c7be | [
"MIT"
] | null | null | null | #include <string>
#include <iostream>
#include <vector>
using namespace std;
typedef vector<int> int_vector;
string tostring(int_vector iv)
{
string val;
for(int_vector::const_iterator iter = iv.begin();
iter != iv.end(); ++iter)
{
val.push_back((char)(*iter + '0'));
}
return val;
}
int_vector tovector(const string& vv)
{
string v = vv;
int_vector iv;
for(string::const_iterator iter = v.begin();
iter != v.end(); ++iter)
{
iv.push_back(*iter - '0');
}
return iv;
}
string trimstr_left(string s)
{
string::iterator iter = s.begin();
while(iter != s.end())
{
if(*iter == '0')
{
s.erase(iter);
iter = s.begin();
}
else
{
break;
}
}
return s;
}
string trimstr_right(string ss)
{
string s = ss;
do
{
int idx = s.size() - 1;
if(idx < 0)
{
break;
}
char v = s[idx];
if(v != '0')
{
break;
}
string::iterator iter = s.begin() + idx;
s.erase(iter);
}
while(true);
return s;
}
class Number
{
public:
int_vector data;
int count;
void eval(const string& ss)
{
string s = trimstr_left(ss);
string left;
string right;
bool find_dot = false;
for(string::const_iterator iter = s.begin(); iter != s.end(); ++iter)
{
if(*iter == '.')
{
find_dot = true;
continue;
}
if(find_dot)
{
right.push_back(*iter);
}
else
{
left.push_back(*iter);
}
}
if(!find_dot)
{
int_vector iv = tovector(left);
data.swap(iv);
return;
}
// has dot, trim left & trim right
left = trimstr_left(left);
right = trimstr_right(right);
count = right.size();
data = tovector(left + right);
}
};
class StringNumber
{
public:
string data;
void eval(int_vector iv,int c)
{
if(c == 0)
{
bool bZero = true;
for(int_vector::iterator i = iv.begin(); i != iv.end(); ++i)
{
if(*i != 0)
{
bZero = false;
}
else
{
if(bZero)
{
continue;
}
}
data.insert(data.begin(),1,char(*i) + '0');
}
}
else
{
data.clear();
int cursor = 0;
for(int i = iv.size() - 1; i >= 0; --i)
{
data.push_back((char)(iv[i] + '0'));
++cursor;
if(cursor == c)
{
data.push_back('.');
}
}
if(cursor < c)
{
while(cursor < c)
{
data.push_back('0');
++cursor;
}
data.push_back('.');
}
}
}
};
int_vector mul(int_vector aa,int bb,int zcount)
{
int diff = 0;
int b = bb;
int_vector a(aa);
for(int i = a.size() - 1; i >= 0; --i)
{
int v = a[i];
v *= b;
v += diff;
diff = 0;
if( v > 9)
{
diff = v / 10;
v = v % 10;
}
a[i] = v;
}
if(diff > 0)
{
a.insert(a.begin(),diff);
}
for(int i = 0;i < zcount; ++i)
{
a.push_back(0);
}
return a;
}
// a is hight vector
int_vector add(int_vector aa,int_vector bb)
{
int_vector a(aa);
int_vector b(bb);
while(b.size() < a.size())
{
b.insert(b.begin(),0);
}
if(a.size() < b.size())
{
a.push_back(0);
}
int diff = 0;
int_vector c;
for(int i = 0;i < a.size(); ++i)
{
int idx = a.size() - i - 1;
int v = a[idx] + b[idx] + diff;
diff = 0;
if(v > 9)
{
diff = v / 10;
v = v % 10;
}
c.insert(c.begin(),v);
}
if(diff > 0)
{
c.insert(c.begin(),diff);
}
return c;
}
int_vector mul(int_vector aa,int_vector bb)
{
int_vector a(aa);
int_vector c;
int bb_len = bb.size();
for(int i = bb_len - 1;i >= 0; --i)
{
int v = bb[i];
int z = bb_len - i - 1;
int_vector d = mul(a,v,z);
c = add(d,c);
}
return c;
}
int_vector power(int_vector iv,int n)
{
if(n == 0)
{
int_vector iv;
iv.push_back(1);
return iv;
}
int_vector c(iv);
for(int i = 0;i < n - 1; ++i)
{
c = mul(c,iv);
}
return c;
}
int main(int argc,char* argv[])
{
string str;
string s;
int np;
while(cin >> s >> np)
{
if(np == 0)
{
cout << 1 << endl;
continue;
}
Number num;
num.eval(s);
if(num.data.size() == 0)
{
cout << 0 << endl;
continue;
}
int n = num.count;
int_vector dst = power(num.data,np);
int pos = 0;
for(int i = 0;i < np; ++i)
{
pos += n;
}
StringNumber snum;
snum.eval(dst,pos);
for(string::reverse_iterator i = snum.data.rbegin(); i != snum.data.rend(); ++i)
{
cout << *i;
}
cout << endl;
}
return 0;
} | 19.096346 | 88 | 0.388135 | lua511 |
0ce580f0e46cdc3c762600f0c34a3e98c63b9817 | 6,350 | cc | C++ | Facebook Hackercup/2021/Round1/C.cc | mjenrungrot/algorithm | e0e8174eb133ba20931c2c7f5c67732e4cb2b703 | [
"MIT"
] | 1 | 2021-12-08T08:58:43.000Z | 2021-12-08T08:58:43.000Z | Facebook Hackercup/2021/Round1/C.cc | mjenrungrot/algorithm | e0e8174eb133ba20931c2c7f5c67732e4cb2b703 | [
"MIT"
] | null | null | null | Facebook Hackercup/2021/Round1/C.cc | mjenrungrot/algorithm | e0e8174eb133ba20931c2c7f5c67732e4cb2b703 | [
"MIT"
] | null | null | null | /*=============================================================================
# Author: Teerapat Jenrungrot - https://github.com/mjenrungrot/
# FileName: C.cc
# Description: Facebook Hacker Cup 2021 - Round1 - C
=============================================================================*/
#include <bits/stdc++.h>
#pragma GCC optimizer("Ofast")
#pragma GCC target("avx2")
using namespace std;
typedef pair<int, int> ii;
typedef pair<long long, long long> ll;
typedef pair<double, double> dd;
typedef tuple<int, int, int> iii;
typedef tuple<long long, long long, long long> lll;
typedef tuple<double, double, double> ddd;
typedef vector<string> vs;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vl;
typedef vector<vector<long long>> vvl;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<ii> vii;
typedef vector<ll> vll;
typedef vector<dd> vdd;
// Debug Snippets
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T& x) {
int f = 0;
cerr << '{';
for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
template <class Ch, class Tr, class Container>
basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& os,
Container const& x) {
os << "{ ";
for (auto& y : x) os << y << " ";
return os << "}";
}
template <class X, class Y>
ostream& operator<<(ostream& os, pair<X, Y> const& p) {
return os << "[ " << p.first << ", " << p.second << "]";
}
// End Debug Snippets
class union_find {
public:
vi parent, sizes;
union_find(int n) {
parent.resize(n);
sizes.resize(n);
for (int i = 0; i < n; i++) {
parent[i] = i;
sizes[i] = 1;
}
}
int find_set(int a) {
if (a == parent[a]) return a;
return parent[a] = find_set(parent[a]);
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (sizes[a] < sizes[b]) swap(a, b);
parent[b] = a;
sizes[a] += sizes[b];
}
}
};
vs split(string line, regex re) {
vs output;
sregex_token_iterator it(line.begin(), line.end(), re, -1), it_end;
while (it != it_end) {
output.push_back(it->str());
it++;
}
return output;
}
const int INF_INT = 1e9 + 7;
const long long INF_LL = 1e18;
const long long MOD = 1e9 + 7;
const int MAXN = 800005;
const int MAXK = 22;
long long ans, base;
int N;
vii V[MAXN];
int reachable1[MAXN][MAXK]; // reachable(i,j): nodes within subtree reachable
// from i-th node using weight >= j
int reachable2[MAXN][MAXK]; // reachable(i,j): nodes outside subtree reachable
// from i-th node using weight >= j
void f1(int u, int p) {
for (int j = 0; j < MAXK; j++) reachable1[u][j] = 1;
for (auto x : V[u]) {
if (x.first == p) continue;
f1(x.first, u);
for (int j = 1; j <= x.second; j++)
reachable1[u][j] += reachable1[x.first][j];
}
}
void f2(int u, int p) {
for (auto x : V[u]) {
if (x.first == p) continue;
for (int j = 1; j <= x.second; j++)
reachable2[x.first][j] +=
reachable2[u][j] + reachable1[u][j] - reachable1[x.first][j];
f2(x.first, u);
}
}
void f3(int u, int p) {
for (auto x : V[u]) {
if (x.first == p) continue;
long long tmp = 0LL;
for (int j = 1; j < MAXK - 1; j++) {
long long P1 =
(long long)reachable1[x.first][j] * reachable2[x.first][j];
long long P2 = (long long)reachable1[x.first][j + 1] *
reachable2[x.first][j + 1];
tmp += (long long)j * (P1 - P2);
}
ans = (ans * ((base - tmp) % MOD)) % MOD;
f3(x.first, u);
}
}
void run() {
memset(reachable1, 0, sizeof(reachable1));
memset(reachable2, 0, sizeof(reachable2));
for (int i = 0; i < MAXN; i++) V[i].clear();
cin >> N;
vector<iii> edges;
for (int i = 0; i < N - 1; i++) {
int u, v, c;
cin >> u >> v >> c;
V[u].emplace_back(v, c);
V[v].emplace_back(u, c);
edges.push_back({u, v, c});
}
auto cmp = [](iii& x, iii& y) { return get<2>(x) > get<2>(y); };
sort(edges.begin(), edges.end(), cmp);
union_find S(N + 1);
base = 0;
for (int i = 0; i < edges.size(); i++) {
int u = get<0>(edges[i]);
int v = get<1>(edges[i]);
int c = get<2>(edges[i]);
if (S.find_set(u) == S.find_set(v)) {
continue;
} else {
base += (long long)c * ((long long)S.sizes[S.find_set(u)] *
S.sizes[S.find_set(v)]);
assert((long long)c * ((long long)S.sizes[S.find_set(u)] *
S.sizes[S.find_set(v)]) >=
0);
assert(base >= 0);
S.union_set(u, v);
}
}
f1(1, -1);
f2(1, -1);
ans = 1LL;
f3(1, -1);
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
for (int i = 1; i <= T; i++) {
cout << "Case #" << i << ": ";
run();
}
return 0;
} | 27.136752 | 79 | 0.487559 | mjenrungrot |
0ce8c6d7568e29ca4f9fbd1d974f0cf8a272d951 | 13,975 | cpp | C++ | source/gui/daquiri.cpp | ess-dmsc/daquiri | f218d9a62cdf568b4a52454f1e35d87ec262391c | [
"BSD-2-Clause"
] | 2 | 2018-03-25T05:31:44.000Z | 2019-07-25T05:17:51.000Z | source/gui/daquiri.cpp | ess-dmsc/daquiri | f218d9a62cdf568b4a52454f1e35d87ec262391c | [
"BSD-2-Clause"
] | 158 | 2017-11-16T09:20:24.000Z | 2022-03-28T11:39:43.000Z | source/gui/daquiri.cpp | ess-dmsc/daquiri | f218d9a62cdf568b4a52454f1e35d87ec262391c | [
"BSD-2-Clause"
] | 2 | 2018-09-20T08:29:21.000Z | 2020-08-04T18:34:50.000Z | #include <gui/daquiri.h>
#include <daquiri_autogen/include/ui_daquiri.h>
#include <gui/Profiles.h>
#include <gui/daq/ListModeForm.h>
#include <gui/daq/ProjectForm.h>
#include <gui/widgets/TabCloseButton.h>
#include <gui/widgets/QFileExtensions.h>
#include <gui/widgets/qt_util.h>
#include <QSettings>
#include <QScrollBar>
#include <QMessageBox>
#include <QInputDialog>
#include <QLabel>
#include <QTimer>
#include <QDir>
#include <QApplication>
#include <date/date.h>
using namespace DAQuiri;
daquiri::daquiri(QWidget *parent,
bool open_new_project,
bool start_daq)
: QMainWindow(parent)
, ui(new Ui::daquiri)
, log_stream_()
, my_emitter_()
, text_buffer_(log_stream_, my_emitter_)
, open_new_project_(open_new_project)
, start_daq_(start_daq)
, server(this)
{
// detectors_.add(Detector("a"));
// detectors_.add(Detector("b"));
// detectors_.add(Detector("c"));
qRegisterMetaType<DAQuiri::OscilData>("DAQuiri::OscilData");
qRegisterMetaType<std::vector<Detector>>("std::vector<Detector>");
qRegisterMetaType<DAQuiri::ListData>("DAQuiri::ListData");
qRegisterMetaType<DAQuiri::Setting>("DAQuiri::Setting");
qRegisterMetaType<DAQuiri::ProducerStatus>("DAQuiri::ProducerStatus");
qRegisterMetaType<DAQuiri::StreamManifest>("DAQuiri::StreamManifest");
qRegisterMetaType<DAQuiri::ProjectPtr>("DAQuiri::ProjectPtr");
qRegisterMetaType<hr_duration_t>("hr_duration_t");
qRegisterMetaType<hr_time_t >("hr_time_t");
CustomLogger::initLogger(spdlog::level::info, "daquiri.log", &log_stream_);
ui->setupUi(this);
connect(&my_emitter_, SIGNAL(writeLine(QString)), this, SLOT(add_log_text(QString)));
server.start_listen(12345);
connect(&server, SIGNAL(stopDAQ()), this, SLOT(stop_daq()));
connect(&server, SIGNAL(startNewDAQ(QString)), this, SLOT(start_new_daq(QString)));
connect(&server, SIGNAL(close_older(uint32_t)), this, SLOT(close_older(uint32_t)));
connect(&server, SIGNAL(save()), this, SLOT(save()));
connect(&server, SIGNAL(die()), this, SLOT(die()));
connect(&runner_thread_,
SIGNAL(settingsUpdated(DAQuiri::Setting, DAQuiri::ProducerStatus, DAQuiri::StreamManifest)),
this, SLOT(update_settings(DAQuiri::Setting, DAQuiri::ProducerStatus, DAQuiri::StreamManifest)));
loadSettings();
connect(ui->tabs, SIGNAL(tabCloseRequested(int)), this, SLOT(close_tab_at(int)));
QPushButton *tb = new QPushButton();
tb->setIcon(QIcon(":/icons/oxy/16/filenew.png"));
tb->setMinimumWidth(35);
tb->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Ignored);
tb->setToolTip("New project");
tb->setFlat(true);
connect(tb, SIGNAL(clicked(bool)), this, SLOT(open_project()));
// Add empty, not enabled tab to tabWidget
ui->tabs->addTab(new QLabel("<center>Open new project by clicking \"+\"</center>"), QString());
ui->tabs->setTabEnabled(0, false);
// Add tab button to current tab. Button will be enabled, but tab -- not
ui->tabs->tabBar()->setTabButton(0, QTabBar::RightSide, tb);
connect(ui->tabs->tabBar(), SIGNAL(tabMoved(int,int)), this, SLOT(tabs_moved(int,int)));
connect(ui->tabs, SIGNAL(currentChanged(int)), this, SLOT(tab_changed(int)));
main_tab_ = new SettingsForm(runner_thread_, this);
ui->tabs->addTab(main_tab_, "DAQ");
// ui->tabs->addTab(main_tab_, main_tab_->windowTitle());
ui->tabs->setTabIcon(ui->tabs->count() - 1, QIcon(":/icons/oxy/16/applications_systemg.png"));
connect(main_tab_, SIGNAL(toggleIO(bool)), this, SLOT(toggleIO(bool)));
connect(this, SIGNAL(toggle_push(bool, DAQuiri::ProducerStatus, DAQuiri::StreamManifest)),
main_tab_, SLOT(toggle_push(bool, DAQuiri::ProducerStatus, DAQuiri::StreamManifest)));
connect(main_tab_, SIGNAL(requestList()), this, SLOT(open_list()));
// connect(this, SIGNAL(settings_changed()), main_tab_, SLOT(refresh()));
// connect(this, SIGNAL(update_dets()), main_tab_, SLOT(updateDetDB()));
QTimer::singleShot(10, this, SLOT(initialize_settings_dir()));
if (open_new_project && !start_daq)
open_project(nullptr, false);
else
{
ui->tabs->setCurrentWidget(main_tab_);
reorder_tabs();
}
}
daquiri::~daquiri()
{
CustomLogger::closeLogger();
delete ui;
}
void daquiri::closeEvent(QCloseEvent *event)
{
if (runner_thread_.running())
{
int reply = QMessageBox::warning(this, "Ongoing data acquisition operations",
"Terminate?",
QMessageBox::Yes|QMessageBox::Cancel);
if (reply == QMessageBox::Yes)
{
runner_thread_.terminate();
runner_thread_.wait();
}
else
{
event->ignore();
return;
}
}
else
{
runner_thread_.terminate();
runner_thread_.wait();
}
for (int i = ui->tabs->count() - 2; i >= 0; --i)
{
if (ui->tabs->widget(i) != main_tab_)
{
ui->tabs->setCurrentIndex(i);
if (!ui->tabs->widget(i)->close())
{
event->ignore();
return;
}
else
{
ui->tabs->removeTab(i);
}
}
}
if (main_tab_ != nullptr)
{
main_tab_->exit();
main_tab_->close();
}
saveSettings();
event->accept();
}
void daquiri::close_tab_at(int index)
{
if ((index < 0) || (index >= ui->tabs->count()))
return;
ui->tabs->setCurrentIndex(index);
if (ui->tabs->widget(index)->close())
ui->tabs->removeTab(index);
}
void daquiri::tab_changed(int index)
{
if ((index < 0) || (index >= ui->tabs->count()))
return;
if (main_tab_ == nullptr)
return;
runner_thread_.set_idle_refresh(ui->tabs->widget(index) == main_tab_);
}
void daquiri::add_log_text(QString line)
{
ui->logBox->append(line);
}
void daquiri::update_settings(Setting sets,
ProducerStatus status,
StreamManifest manifest)
{
engine_status_ = status;
stream_manifest_ = manifest;
auto description = sets.find({"ProfileDescr"}, Match::id);
profile_description_ = QS(description.get_text());
if (profile_description_.isEmpty())
profile_description_ = Profiles::singleton().current_profile_name();
toggleIO(true);
if ((status & ProducerStatus::can_run) &&
open_new_project_ && start_daq_)
{
open_new_project_ = false;
QTimer::singleShot(100, this, SLOT(open_new_proj()));
}
}
void daquiri::toggleIO(bool enable)
{
gui_enabled_ = enable;
QString name = "daquiri";
if (!profile_description_.isEmpty())
name = profile_description_;
if (enable && (engine_status_ & ProducerStatus::running))
name += " (Running)";
else if (enable && (engine_status_ & ProducerStatus::booted))
name += " (Online)";
else if (enable)
name += " (Offline)";
else
name += " (Busy)";
setWindowTitle(name);
for (int i = 0; i < ui->tabs->count(); ++i)
if (ui->tabs->widget(i) != main_tab_)
ui->tabs->setTabText(i, ui->tabs->widget(i)->windowTitle());
emit toggle_push(enable, engine_status_, stream_manifest_);
}
void daquiri::loadSettings()
{
QSettings settings;
settings.beginGroup("Program");
Profiles::singleton().select_profile(
settings.value("current_profile","").toString(),
settings.value("auto_boot","").toBool());
QRect myrect = settings.value("position",QRect(20,20,1234,650)).toRect();
setGeometry(myrect);
ui->splitter->restoreState(settings.value("splitter").toByteArray());
}
void daquiri::saveSettings()
{
QSettings settings;
settings.beginGroup("Program");
settings.setValue("position", this->geometry());
settings.setValue("splitter", ui->splitter->saveState());
settings.setValue("current_profile", Profiles::singleton().current_profile_name());
settings.setValue("auto_boot", Profiles::singleton().auto_boot());
}
void daquiri::on_splitter_splitterMoved(int /*pos*/, int /*index*/)
{
ui->logBox->verticalScrollBar()->setValue(ui->logBox->verticalScrollBar()->maximum());
}
void daquiri::add_closable_tab(QWidget* widget)
{
close_tab_widgetButton *cb = new close_tab_widgetButton(widget);
cb->setIcon( QIcon(":/icons/oxy/16/application_exit.png"));
// tb->setIconSize(QSize(16, 16));
cb->setToolTip("Close");
cb->setFlat(true);
connect(cb, SIGNAL(close_tab_widget(QWidget*)), this, SLOT(close_tab_widget(QWidget*)));
ui->tabs->addTab(widget, widget->windowTitle());
ui->tabs->tabBar()->setTabButton(ui->tabs->count()-1, QTabBar::RightSide, cb);
}
void daquiri::close_tab_widget(QWidget* w)
{
int idx = ui->tabs->indexOf(w);
close_tab_at(idx);
}
void daquiri::reorder_tabs()
{
for (int i = 0; i < ui->tabs->count(); ++i)
if (ui->tabs->tabText(i).isEmpty() && (i != (ui->tabs->count() - 1)))
ui->tabs->tabBar()->moveTab(i, ui->tabs->count() - 1);
}
void daquiri::tabs_moved(int, int)
{
reorder_tabs();
}
void daquiri::open_list()
{
ListModeForm *newListForm = new ListModeForm(runner_thread_, this);
add_closable_tab(newListForm);
connect(newListForm, SIGNAL(toggleIO(bool)), this, SLOT(toggleIO(bool)));
connect(this, SIGNAL(toggle_push(bool, DAQuiri::ProducerStatus, DAQuiri::StreamManifest)),
newListForm, SLOT(toggle_push(bool, DAQuiri::ProducerStatus, DAQuiri::StreamManifest)));
ui->tabs->setCurrentWidget(newListForm);
reorder_tabs();
emit toggle_push(gui_enabled_, engine_status_, stream_manifest_);
}
void daquiri::open_new_proj()
{
open_project(nullptr, start_daq_);
start_daq_ = false;
}
void daquiri::open_project(ProjectPtr proj, bool start, QString name)
{
auto newSpectraForm = new ProjectForm(runner_thread_, proj, name, this);
connect(newSpectraForm, SIGNAL(requestClose(QWidget*)),
this, SLOT(close_tab_widget(QWidget*)));
connect(newSpectraForm, SIGNAL(toggleIO(bool)), this, SLOT(toggleIO(bool)));
connect(this, SIGNAL(toggle_push(bool, DAQuiri::ProducerStatus, DAQuiri::StreamManifest)),
newSpectraForm, SLOT(toggle_push(bool, DAQuiri::ProducerStatus, DAQuiri::StreamManifest)));
add_closable_tab(newSpectraForm);
ui->tabs->setCurrentWidget(newSpectraForm);
reorder_tabs();
newSpectraForm->toggle_push(true, engine_status_, stream_manifest_);
if (start && (engine_status_ & ProducerStatus::can_run))
QTimer::singleShot(500, newSpectraForm, SLOT(start_DAQ()));
}
void daquiri::initialize_settings_dir()
{
if (Profiles::has_settings_dir())
return;
if (Profiles::is_valid_settings_dir(Profiles::default_settings_dir()))
{
INFO("Found profiles in default settings dir ({}).",
Profiles::default_settings_dir().toStdString());
Profiles::select_settings_dir(Profiles::default_settings_dir());
main_tab_->on_pushChangeProfile_clicked();
return;
}
bool ok {false};
QString text = QInputDialog::getText(this, tr("First run?"),
tr("Is this your first run of Daquiri?\n"
"Let's create a settings directory.\n"
"How about this?"),
QLineEdit::Normal,
Profiles::default_settings_dir(), &ok);
if (!ok || text.isEmpty())
return;
QDir dir(text);
bool exists = dir.exists();
if (!exists)
exists = dir.mkpath(".");
if (exists)
{
Profiles::select_settings_dir(text);
int reply = QMessageBox::warning(this, tr("Install defaults?"),
tr("Shall we also copy default configuration profiles\n"
"to your specified directory?"),
QMessageBox::Yes|QMessageBox::Cancel);
if (reply == QMessageBox::Yes)
{
QFileInfo fi(QCoreApplication::applicationFilePath());
QDir from_path = fi.absoluteDir();
from_path.cd("../../data");
copy_dir_recursive(from_path.path(), Profiles::settings_dir(), true);
}
}
}
void daquiri::stop_daq()
{
for (int i = ui->tabs->count() - 1; i >= 0; --i)
{
if (ui->tabs->widget(i) == main_tab_)
continue;
if (ProjectForm* of = qobject_cast<ProjectForm*>(ui->tabs->widget(i)))
{
if (of->running()) {
INFO("<daquiri> remote command stopping project at i={}", i);
of->on_pushStop_clicked();
}
}
}
}
void daquiri::save()
{
for (int i = ui->tabs->count() - 1; i >= 0; --i)
{
if (ui->tabs->widget(i) == main_tab_)
continue;
if (ProjectForm* of = qobject_cast<ProjectForm*>(ui->tabs->widget(i)))
{
INFO("<daquiri> remote command saving project at i={}", i);
of->save();
}
}
}
void daquiri::start_new_daq(QString name)
{
INFO("<daquiri> remote command starting new project '{}'", name.toStdString());
if (engine_status_ & ProducerStatus::can_run)
open_project(nullptr, true, name);
}
void daquiri::close_older(uint32_t mins)
{
auto now = std::chrono::system_clock::now();
for (int i = ui->tabs->count() - 1; i >= 0; --i)
{
if (ui->tabs->widget(i) == main_tab_)
continue;
if (ProjectForm* of = qobject_cast<ProjectForm*>(ui->tabs->widget(i)))
{
auto dif = now - of->opened();
bool eval = ((date::floor<std::chrono::seconds>(dif).count() / 60) >= mins);
if (eval) {
INFO("<daquiri> closing older project at i={}", i);
ui->tabs->setCurrentIndex(i);
if (ui->tabs->widget(i)->close())
ui->tabs->removeTab(i);
}
}
}
}
void daquiri::die()
{
INFO("<daquiri> remote command shutting down");
closeEvent(new QCloseEvent());
QApplication::quit();
}
| 31.263982 | 108 | 0.631914 | ess-dmsc |
0ceb21ac1adc5fe533e60dca8836e5c5e7d08a4b | 9,580 | cpp | C++ | src/prod/src/Reliability/Failover/fm/ServiceFactory.cpp | AnthonyM/service-fabric | c396ea918714ea52eab9c94fd62e018cc2e09a68 | [
"MIT"
] | 1 | 2018-03-15T02:09:21.000Z | 2018-03-15T02:09:21.000Z | src/prod/src/Reliability/Failover/fm/ServiceFactory.cpp | AnthonyM/service-fabric | c396ea918714ea52eab9c94fd62e018cc2e09a68 | [
"MIT"
] | null | null | null | src/prod/src/Reliability/Failover/fm/ServiceFactory.cpp | AnthonyM/service-fabric | c396ea918714ea52eab9c94fd62e018cc2e09a68 | [
"MIT"
] | null | null | null | // ------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// ------------------------------------------------------------
#include "stdafx.h"
using namespace std;
using namespace Api;
using namespace Common;
using namespace Reliability;
using namespace Reliability::FailoverManagerComponent;
using namespace Store;
using namespace Transport;
StringLiteral const TraceFactory("Factory");
GlobalWString FailoverManagerServiceFactory::FMStoreDirectory = make_global<wstring>(L"FM");
GlobalWString FailoverManagerServiceFactory::FMStoreFilename = make_global<wstring>(L"FM.edb");
GlobalWString FailoverManagerServiceFactory::FMSharedLogFilename = make_global<wstring>(L"fmshared.log");
FailoverManagerServiceFactory::FailoverManagerServiceFactory(
__in Reliability::IReliabilitySubsystem & reliabilitySubsystem,
EventHandler const & readyEvent,
EventHandler const & failureEvent,
ComponentRoot const & root)
: ComponentRoot()
, federationSPtr_(reliabilitySubsystem.Federation.shared_from_this())
, instance_(reliabilitySubsystem.FederationWrapperBase.Instance)
, fmServiceLock_()
, fmServiceWPtr_()
, fm_()
, fmReadyEvent_()
, fmFailedEvent_()
, fabricRoot_(root.CreateComponentRoot())
, reliabilitySubsystem_(reliabilitySubsystem)
{
fmReadyEvent_.Add(readyEvent);
fmFailedEvent_.Add(failureEvent);
WriteInfo(
TraceFactory,
"FailoverManagerServiceFactory::ctor: node instance = {0}",
instance_);
}
FailoverManagerServiceFactory::~FailoverManagerServiceFactory()
{
WriteInfo(
TraceFactory,
"FailoverManagerServiceFactory::~dtor: node instance = {0}",
instance_);
}
ErrorCode FailoverManagerServiceFactory::CreateReplica(
wstring const & serviceType,
NamingUri const & serviceName,
vector<byte> const & initializationData,
Guid const & partitionId,
FABRIC_REPLICA_ID replicaId,
__out IStatefulServiceReplicaPtr & replicaResult)
{
UNREFERENCED_PARAMETER(initializationData);
WriteInfo(
TraceFactory,
"CreateReplica called at node instance = {0}",
instance_);
ASSERT_IF(
serviceType != ServiceModel::ServiceTypeIdentifier::FailoverManagerServiceTypeId->ServiceTypeName,
"StoreServiceFactory cannot create service of type '{0}'", serviceType);
ASSERT_IF(serviceName.ToString() != ServiceModel::SystemServiceApplicationNameHelper::PublicFMServiceName, "StoreServiceFactory cannot create service '{0}'", serviceName);
FailoverConfig & config = FailoverConfig::GetConfig();
ReplicationComponent::ReplicatorSettingsUPtr replicatorSettings;
auto error = ReplicationComponent::ReplicatorSettings::FromConfig(
config,
reliabilitySubsystem_.NodeConfig->FailoverManagerReplicatorAddress,
reliabilitySubsystem_.NodeConfig->FailoverManagerReplicatorAddress,
reliabilitySubsystem_.NodeConfig->FailoverManagerReplicatorAddress,
reliabilitySubsystem_.SecuritySettings,
replicatorSettings);
if (!error.IsSuccess()) { return error; }
shared_ptr<FailoverManagerService> fmServiceSPtr;
{
AcquireWriteLock lock(fmServiceLock_);
fmServiceSPtr = make_shared<FailoverManagerService>(
partitionId,
replicaId,
instance_,
*fabricRoot_);
error = fmServiceSPtr->InitializeForSystemServices(
config.EnableTStore,
reliabilitySubsystem_.WorkingDirectory,
FMStoreDirectory,
FMSharedLogFilename,
config,
partitionId,
move(replicatorSettings),
Store::ReplicatedStoreSettings(
FailoverConfig::GetConfig().CommitBatchingPeriod,
FailoverConfig::GetConfig().CommitBatchingSizeLimitInKB << 10,
FailoverConfig::GetConfig().TransactionLowWatermark,
FailoverConfig::GetConfig().TransactionHighWatermark,
FailoverConfig::GetConfig().CommitBatchingPeriodExtension,
FailoverConfig::GetConfig().ThrottleOperationCount,
FailoverConfig::GetConfig().ThrottleQueueSizeBytes,
Store::StoreConfig::GetConfig().EnableSystemServiceFlushOnDrain),
Store::EseLocalStoreSettings(
FMStoreFilename,
Path::Combine(reliabilitySubsystem_.WorkingDirectory, FMStoreDirectory),
FailoverConfig::GetConfig().CompactionThresholdInMB),
reliabilitySubsystem_.ClientFactory,
serviceName);
if (!error.IsSuccess()) { return error; }
fmServiceWPtr_ = fmServiceSPtr;
}
auto selfRoot = this->CreateComponentRoot();
fmServiceSPtr->OnChangeRoleCallback =
[this, selfRoot] (::FABRIC_REPLICA_ROLE newRole, Common::ComPointer<IFabricStatefulServicePartition> const & servicePartition)
{
this->OnServiceChangeRole(newRole, servicePartition);
};
fmServiceSPtr->OnCloseReplicaCallback =
[this, selfRoot]()
{
this->OnServiceCloseReplica();
};
replicaResult = IStatefulServiceReplicaPtr(fmServiceSPtr.get(), fmServiceSPtr->CreateComponentRoot());
return ErrorCode();
}
Common::ErrorCode FailoverManagerServiceFactory::UpdateReplicatorSecuritySettings(
Transport::SecuritySettings const & securitySettings)
{
ErrorCode error;
ReplicationComponent::ReplicatorSettingsUPtr replicatorSettings;
error = ReplicationComponent::ReplicatorSettings::FromSecuritySettings(
securitySettings,
replicatorSettings);
if (!error.IsSuccess())
{
return error;
}
{
AcquireExclusiveLock lock(fmServiceLock_);
auto replica = fmServiceWPtr_.lock();
if (replica)
{
error = replica->UpdateReplicatorSettings(move(replicatorSettings));
}
}
if (error.IsSuccess())
{
WriteInfo(
TraceFactory,
"{0}: UpdateReplicatorSettings succeeded, new value = {1}",
instance_,
securitySettings);
}
else
{
WriteError(
TraceFactory,
"{0}: UpdateReplicatorSettings failed, error = {1}, new value = {2}",
instance_,
error,
securitySettings);
}
return error;
}
void FailoverManagerServiceFactory::OnServiceChangeRole(FABRIC_REPLICA_ROLE newRole, ComPointer<IFabricStatefulServicePartition> const & servicePartition)
{
AcquireExclusiveLock lock(fmServiceLock_);
auto replica = fmServiceWPtr_.lock();
ASSERT_IF(!replica, "OnServiceChangeRole called even though FMService is null");
if(newRole == ::FABRIC_REPLICA_ROLE_PRIMARY)
{
ASSERT_IF(fm_ != nullptr, "Replica role changed to Primary although FM already exists");
auto fmStore = make_unique<FailoverManagerStore>(RootedObjectPointer<Store::IReplicatedStore>(
replica->ReplicatedStore,
replica->CreateComponentRoot()));
auto localFederationSPtr = federationSPtr_;
fm_ = FailoverManager::CreateFM(
move(localFederationSPtr),
reliabilitySubsystem_.HealthClient,
reliabilitySubsystem_.NodeConfig,
move(fmStore),
servicePartition,
replica->PartitionId,
replica->ReplicaId);
FABRIC_EPOCH epoch;
ASSERT_IF(!replica->ReplicatedStore->GetCurrentEpoch(epoch).IsSuccess(), "GetCurrentEpoch not successful.");
fm_->PreOpenFMServiceEpoch = epoch;
WriteInfo(
TraceFactory,
"FM {0} changed to primary with epoch: {1}",
fm_->Id,
fm_->PreOpenFMServiceEpoch);
auto selfRoot = this->CreateComponentRoot();
fm_->Open(
[this, selfRoot] (EventArgs const &) { OnFailoverManagerReady(); },
[this, selfRoot] (EventArgs const &) { OnFailoverManagerFailed(); });
}
else
{
if (fm_)
{
fm_->Close(newRole != FABRIC_REPLICA_ROLE::FABRIC_REPLICA_ROLE_ACTIVE_SECONDARY);
fm_ = nullptr;
}
}
}
void FailoverManagerServiceFactory::OnServiceCloseReplica()
{
AcquireExclusiveLock lock(fmServiceLock_);
auto replica = fmServiceWPtr_.lock();
ASSERT_IF(!replica, "OnServiceCloseReplica called even though FMService is null");
if (fm_)
{
fm_->Close(true /* isStoreCloseNeeded */);
fm_ = nullptr;
}
fmServiceWPtr_.reset();
}
void FailoverManagerServiceFactory::OnFailoverManagerReady()
{
fmReadyEvent_.Fire(EventArgs(), true);
}
void FailoverManagerServiceFactory::OnFailoverManagerFailed()
{
fmFailedEvent_.Fire(EventArgs());
}
void FailoverManagerServiceFactory::Cleanup()
{
fmFailedEvent_.Close();
fmReadyEvent_.Close();
fabricRoot_.reset();
}
IFailoverManagerSPtr FailoverManagerServiceFactory::Test_GetFailoverManager() const
{
AcquireExclusiveLock lock(fmServiceLock_);
return fm_;
}
ComponentRootWPtr FailoverManagerServiceFactory::Test_GetFailoverManagerService() const
{
AcquireExclusiveLock lock(fmServiceLock_);
return fmServiceWPtr_;
}
bool FailoverManagerServiceFactory::Test_IsFailoverManagerReady() const
{
AcquireExclusiveLock lock(fmServiceLock_);
return (fm_ != nullptr && fm_->IsReady);
}
| 33.034483 | 175 | 0.679645 | AnthonyM |
0cec009777f38e317ba1a41db7983cd1ed8f8ed3 | 6,418 | cxx | C++ | lassy++/src/LaShellShellCombine.cxx | alonsoJASL/lassy | 10aefa4d6b3b9d859e9fc1cd1302b06163cc24d1 | [
"Apache-2.0"
] | null | null | null | lassy++/src/LaShellShellCombine.cxx | alonsoJASL/lassy | 10aefa4d6b3b9d859e9fc1cd1302b06163cc24d1 | [
"Apache-2.0"
] | null | null | null | lassy++/src/LaShellShellCombine.cxx | alonsoJASL/lassy | 10aefa4d6b3b9d859e9fc1cd1302b06163cc24d1 | [
"Apache-2.0"
] | null | null | null | #define HAS_VTK 1
/* The Circle class (All source codes in one file) (CircleAIO.cpp) */
#include <iostream> // using IO functions
#include <string> // using string
#include "../include/LaShellShellCombine.h"
using namespace std;
LaShellShellCombine::LaShellShellCombine()
{
_output_la = new LaShell();
_overlap_preference = WHEN_OVERLAP_USE_SOURCE1;
_scalar_array_location_in_source1 = -1;
_scalar_array_location_in_source2 = -1;
_write_to_field_data = false;
_output_scalar_name = "comb_scalar";
}
LaShellShellCombine::~LaShellShellCombine() {
delete _output_la;
}
void LaShellShellCombine::SetOverlapToSource1() {
_overlap_preference = WHEN_OVERLAP_USE_SOURCE1;
}
void LaShellShellCombine::SetOverlapToSource2() {
_overlap_preference = WHEN_OVERLAP_USE_SOURCE2;
}
void LaShellShellCombine::SetInputData(LaShell* shell)
{
_source_la_1 = shell;
}
void LaShellShellCombine::SetInputData2(LaShell* shell)
{
_source_la_2 = shell;
}
void LaShellShellCombine::SetWriteDataToField()
{
_write_to_field_data= true;
}
int LaShellShellCombine::FindScalarArray(LaShell* shell, const char* array_name)
{
int location = -1;
vtkIdType numberOfPointArrays;
vtkSmartPointer<vtkPolyData> Source_Poly1 = vtkSmartPointer<vtkPolyData>::New();
shell->GetMesh3D(Source_Poly1);
if (!_write_to_field_data)
numberOfPointArrays = Source_Poly1->GetPointData()->GetNumberOfArrays();
else
numberOfPointArrays = Source_Poly1->GetFieldData()->GetNumberOfArrays();
for(vtkIdType i = 0; i < numberOfPointArrays; i++)
{
//cout << "Array " << i << ", name = " << Source_Poly1->GetPointData()->GetArray(i)->GetName() << endl;
if (!_write_to_field_data) {
if (strcmp(Source_Poly1->GetPointData()->GetArray(i)->GetName(), array_name) == 0) {
//cout << "Found array at location " << i << endl;
location = i;
}
}
else {
if (strcmp(Source_Poly1->GetFieldData()->GetArray(i)->GetName(), array_name) == 0) {
//cout << "Found array at location " << i << endl;
location = i;
}
}
}
return location;
}
bool LaShellShellCombine::SetScalarArrayNames(const char* array_name1, const char* array_name2)
{
int location1 = FindScalarArray(_source_la_1, array_name1);
int location2 = FindScalarArray(_source_la_2, array_name2);
if (location1 < 0 || location2 < 0)
{
if (location1 < 0)
cerr << "The array with name: " << array_name1 << " does not exist" << endl;
else
cerr << "The array with name: " << array_name2 << " does not exist" << endl;
return false;
}
else {
_scalar_array_location_in_source1 = location1;
_scalar_array_location_in_source2 = location2;
cout << "Array with this name exists at location w/index " << location1 << ", and in second mesh at location w/index "<< location2 << endl;
return true;
}
}
void LaShellShellCombine::SetOutputScalarName(string array_name)
{
_output_scalar_name = array_name;
}
LaShell* LaShellShellCombine::GetOutput() {
return _output_la;
}
void LaShellShellCombine::Update()
{
// VTK error logging
vtkSmartPointer<vtkFileOutputWindow> fileOutputWindow = vtkSmartPointer<vtkFileOutputWindow>::New();
fileOutputWindow->SetFileName("vtkLog.txt");
vtkOutputWindow* outputWindow = vtkOutputWindow::GetInstance();
if (outputWindow)
{
outputWindow->SetInstance(fileOutputWindow);
}
vtkSmartPointer<vtkPolyData> Output_Poly = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPolyData> Source_Poly1 = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPolyData> Source_Poly2 = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkDoubleArray> Scalars_Poly1 = vtkSmartPointer<vtkDoubleArray>::New();
vtkSmartPointer<vtkDoubleArray> Scalars_Poly2 = vtkSmartPointer<vtkDoubleArray>::New();
_source_la_1->GetMesh3D(Source_Poly1);
_source_la_2->GetMesh3D(Source_Poly2);
if (!_write_to_field_data) {
Scalars_Poly1 = vtkDoubleArray::SafeDownCast(Source_Poly1->GetPointData()->GetArray(_scalar_array_location_in_source1));
Scalars_Poly2 = vtkDoubleArray::SafeDownCast(Source_Poly2->GetPointData()->GetArray(_scalar_array_location_in_source2));
}
else {
Scalars_Poly1 = vtkDoubleArray::SafeDownCast(Source_Poly1->GetFieldData()->GetArray(_scalar_array_location_in_source1));
Scalars_Poly2 = vtkDoubleArray::SafeDownCast(Source_Poly2->GetFieldData()->GetArray(_scalar_array_location_in_source2));
}
vtkSmartPointer<vtkDoubleArray> Output_Poly_Scalar = vtkSmartPointer<vtkDoubleArray>::New();
//Output_Poly_Scalar->SetNumberOfComponents(1);
Output_Poly_Scalar->SetName(_output_scalar_name.c_str());
cout << "New array name = " << _output_scalar_name << endl;
cout << "Array size = something else" << Scalars_Poly1->GetNumberOfComponents() << endl;
for(vtkIdType i = 0; i < Scalars_Poly1->GetNumberOfTuples(); i++)
{
float s1, s2;
//cout << "s1=" << s1 << ", s2=" << s2 << endl;
s1 = Scalars_Poly1->GetValue(i);
if ( i < Scalars_Poly2->GetNumberOfTuples()) {
s2 = Scalars_Poly2->GetValue(i);
if ( s1 > 0 && s2 > 0)
{
if (_overlap_preference == WHEN_OVERLAP_USE_SOURCE1) {
Output_Poly_Scalar->InsertNextValue(s1);
}
else if (_overlap_preference == WHEN_OVERLAP_USE_SOURCE2) {
Output_Poly_Scalar->InsertNextValue(s2);
}
}
else if (s1 > 0)
{
Output_Poly_Scalar->InsertNextValue(s1);
}
else if (s2 > 0)
{
Output_Poly_Scalar->InsertNextValue(s2);
}
else {
Output_Poly_Scalar->InsertNextValue(0);
}
}
}
Output_Poly->DeepCopy(Source_Poly1);
if (!_write_to_field_data) {
// Output_Poly->GetPointData()->SetScalars(Output_Poly_Scalar);
Output_Poly->GetPointData()->AddArray(Output_Poly_Scalar);
}
else {
Output_Poly->GetFieldData()->AddArray(Output_Poly_Scalar);
}
_output_la->SetMesh3D(Output_Poly);
} | 31.460784 | 147 | 0.658928 | alonsoJASL |
0cec2b95a7f8a839f3908729413a15dff8e8e029 | 611 | cpp | C++ | sources/Adapters/W32/Midi/W32MidiService.cpp | haiko21/LittleGPTracker | 0f137aa67dfd86379b830cc51ba900b9423127ce | [
"BSD-3-Clause"
] | 66 | 2015-01-29T09:12:51.000Z | 2022-03-23T19:20:49.000Z | sources/Adapters/W32/Midi/W32MidiService.cpp | haiko21/LittleGPTracker | 0f137aa67dfd86379b830cc51ba900b9423127ce | [
"BSD-3-Clause"
] | 18 | 2015-08-19T19:50:31.000Z | 2021-10-12T02:33:09.000Z | sources/Adapters/W32/Midi/W32MidiService.cpp | haiko21/LittleGPTracker | 0f137aa67dfd86379b830cc51ba900b9423127ce | [
"BSD-3-Clause"
] | 20 | 2015-08-19T00:46:57.000Z | 2022-03-14T13:44:49.000Z |
#include "W32MidiService.h"
#include "W32MidiDEvice.h"
#include "System/io/Trace.h"
W32MidiService::W32MidiService() {
} ;
W32MidiService::~W32MidiService() {
} ;
void W32MidiService::buildDriverList() {// Here we just loop over existing Midi out and create a midi device for each of them.
for (unsigned int i=0;i<midiOutGetNumDevs();i++) {
MIDIOUTCAPS infos;
int err = midiOutGetDevCaps (i, &infos, sizeof (MIDIOUTCAPS));
if (err==MMSYSERR_NOERROR) {
if (infos.dwSupport & MIDICAPS_STREAM) {
W32MidiDevice *device=new W32MidiDevice(infos.szPname) ;
Insert(device) ;
}
} ;
} ;
} ;
| 23.5 | 126 | 0.698854 | haiko21 |
0cf0083aa44fe2ba3766871eb0485590ba2126bd | 1,009 | hpp | C++ | hld/system/hld_system_chimera.hpp | brandonbraun653/Thor_STM32 | 2aaba95728936b2d5784e99b96c208a94e3cb8df | [
"MIT"
] | null | null | null | hld/system/hld_system_chimera.hpp | brandonbraun653/Thor_STM32 | 2aaba95728936b2d5784e99b96c208a94e3cb8df | [
"MIT"
] | 36 | 2019-03-24T14:43:25.000Z | 2021-01-11T00:05:30.000Z | hld/system/hld_system_chimera.hpp | brandonbraun653/Thor | 46e022f1791c8644955135c630fdd12a4296e44d | [
"MIT"
] | null | null | null | /********************************************************************************
* File Name:
* hld_system_chimera.hpp
*
* Description:
* Chimera hooks into Thor System
*
* 2020 | Brandon Braun | brandonbraun653@gmail.com
*******************************************************************************/
#pragma once
#ifndef THOR_SYSTEM_CHIMERA_HPP
#define THOR_SYSTEM_CHIMERA_HPP
/* Chimera Includes */
#include <Chimera/common>
#include <Chimera/system>
namespace Chimera::System::Backend
{
Chimera::Status_t initialize();
Chimera::Status_t reset();
Chimera::Status_t systemStartup();
Chimera::System::InterruptMask disableInterrupts();
void enableInterrupts( Chimera::System::InterruptMask &interruptMask );
int maxConcurrentThreads();
Chimera::System::ResetEvent getResetReason();
void getSystemInformation( Chimera::System::Information *&info );
void softwareReset();
bool inISR();
} // namespace Chimera::System::Backend
#endif /* !THOR_SYSTEM_CHIMERA_HPP */
| 29.676471 | 81 | 0.621407 | brandonbraun653 |
0cf128ec565d8b6a7480772b9264c76e4c2be9ed | 8,654 | cpp | C++ | dbms/src/DataStreams/RemoteBlockInputStream.cpp | rudneff/ClickHouse | 3cb59b92bccbeb888d136f7c6e14b622382c0434 | [
"Apache-2.0"
] | 1 | 2017-01-17T17:29:05.000Z | 2017-01-17T17:29:05.000Z | dbms/src/DataStreams/RemoteBlockInputStream.cpp | rudneff/ClickHouse | 3cb59b92bccbeb888d136f7c6e14b622382c0434 | [
"Apache-2.0"
] | 1 | 2017-01-13T21:29:36.000Z | 2017-01-16T18:29:08.000Z | dbms/src/DataStreams/RemoteBlockInputStream.cpp | jbfavre/clickhouse-debian | 3806e3370decb40066f15627a3bca4063b992bfb | [
"Apache-2.0"
] | null | null | null | #include <DB/DataStreams/RemoteBlockInputStream.h>
#include <DB/DataStreams/OneBlockInputStream.h>
#include <DB/Common/VirtualColumnUtils.h>
#include <DB/Common/NetException.h>
namespace DB
{
namespace ErrorCodes
{
extern const int UNKNOWN_PACKET_FROM_SERVER;
extern const int LOGICAL_ERROR;
}
RemoteBlockInputStream::RemoteBlockInputStream(Connection & connection_, const String & query_,
const Settings * settings_, ThrottlerPtr throttler_, const Tables & external_tables_,
QueryProcessingStage::Enum stage_, const Context & context_)
: connection(&connection_), query(query_), throttler(throttler_), external_tables(external_tables_),
stage(stage_), context(context_)
{
init(settings_);
}
RemoteBlockInputStream::RemoteBlockInputStream(ConnectionPool::Entry & pool_entry_, const String & query_,
const Settings * settings_, ThrottlerPtr throttler_, const Tables & external_tables_,
QueryProcessingStage::Enum stage_, const Context & context_)
: pool_entry(pool_entry_), connection(&*pool_entry_), query(query_), throttler(throttler_),
external_tables(external_tables_), stage(stage_), context(context_)
{
init(settings_);
}
RemoteBlockInputStream::RemoteBlockInputStream(ConnectionPoolPtr & pool_, const String & query_,
const Settings * settings_, ThrottlerPtr throttler_, const Tables & external_tables_,
QueryProcessingStage::Enum stage_, const Context & context_)
: pool(pool_), query(query_), throttler(throttler_), external_tables(external_tables_),
stage(stage_), context(context_)
{
init(settings_);
}
RemoteBlockInputStream::RemoteBlockInputStream(ConnectionPoolsPtr & pools_, const String & query_,
const Settings * settings_, ThrottlerPtr throttler_, const Tables & external_tables_,
QueryProcessingStage::Enum stage_, const Context & context_)
: pools(pools_), query(query_), throttler(throttler_), external_tables(external_tables_),
stage(stage_), context(context_)
{
init(settings_);
}
RemoteBlockInputStream::~RemoteBlockInputStream()
{
/** Если прервались в середине цикла общения с репликами, то прервываем
* все соединения, затем читаем и пропускаем оставшиеся пакеты чтобы
* эти соединения не остались висеть в рассихронизированном состоянии.
*/
if (established || isQueryPending())
multiplexed_connections->disconnect();
}
void RemoteBlockInputStream::setPoolMode(PoolMode pool_mode_)
{
pool_mode = pool_mode_;
}
void RemoteBlockInputStream::appendExtraInfo()
{
append_extra_info = true;
}
void RemoteBlockInputStream::readPrefix()
{
if (!sent_query)
sendQuery();
}
void RemoteBlockInputStream::cancel()
{
bool old_val = false;
if (!is_cancelled.compare_exchange_strong(old_val, true, std::memory_order_seq_cst, std::memory_order_relaxed))
return;
{
std::lock_guard<std::mutex> lock(external_tables_mutex);
/// Останавливаем отправку внешних данных.
for (auto & vec : external_tables_data)
for (auto & elem : vec)
if (IProfilingBlockInputStream * stream = dynamic_cast<IProfilingBlockInputStream *>(elem.first.get()))
stream->cancel();
}
if (!isQueryPending() || hasThrownException())
return;
tryCancel("Cancelling query");
}
void RemoteBlockInputStream::sendExternalTables()
{
size_t count = multiplexed_connections->size();
{
std::lock_guard<std::mutex> lock(external_tables_mutex);
external_tables_data.reserve(count);
for (size_t i = 0; i < count; ++i)
{
ExternalTablesData res;
for (const auto & table : external_tables)
{
StoragePtr cur = table.second;
QueryProcessingStage::Enum stage = QueryProcessingStage::Complete;
DB::BlockInputStreams input = cur->read(cur->getColumnNamesList(), ASTPtr(), context, settings,
stage, DEFAULT_BLOCK_SIZE, 1);
if (input.size() == 0)
res.push_back(std::make_pair(std::make_shared<OneBlockInputStream>(cur->getSampleBlock()), table.first));
else
res.push_back(std::make_pair(input[0], table.first));
}
external_tables_data.push_back(std::move(res));
}
}
multiplexed_connections->sendExternalTablesData(external_tables_data);
}
Block RemoteBlockInputStream::readImpl()
{
if (!sent_query)
{
sendQuery();
if (settings.skip_unavailable_shards && (0 == multiplexed_connections->size()))
return {};
}
while (true)
{
if (isCancelled())
return Block();
Connection::Packet packet = multiplexed_connections->receivePacket();
switch (packet.type)
{
case Protocol::Server::Data:
/// Если блок не пуст и не является заголовочным блоком
if (packet.block && (packet.block.rows() > 0))
return packet.block;
break; /// Если блок пуст - получим другие пакеты до EndOfStream.
case Protocol::Server::Exception:
got_exception_from_replica = true;
packet.exception->rethrow();
break;
case Protocol::Server::EndOfStream:
if (!multiplexed_connections->hasActiveConnections())
{
finished = true;
return Block();
}
break;
case Protocol::Server::Progress:
/** Используем прогресс с удалённого сервера.
* В том числе, запишем его в ProcessList,
* и будем использовать его для проверки
* ограничений (например, минимальная скорость выполнения запроса)
* и квот (например, на количество строчек для чтения).
*/
progressImpl(packet.progress);
break;
case Protocol::Server::ProfileInfo:
info.setFrom(packet.profile_info);
break;
case Protocol::Server::Totals:
totals = packet.block;
break;
case Protocol::Server::Extremes:
extremes = packet.block;
break;
default:
got_unknown_packet_from_replica = true;
throw Exception("Unknown packet from server", ErrorCodes::UNKNOWN_PACKET_FROM_SERVER);
}
}
}
void RemoteBlockInputStream::readSuffixImpl()
{
/** Если одно из:
* - ничего не начинали делать;
* - получили все пакеты до EndOfStream;
* - получили с одной реплики эксепшен;
* - получили с одной реплики неизвестный пакет;
* то больше читать ничего не нужно.
*/
if (!isQueryPending() || hasThrownException())
return;
/** Если ещё прочитали не все данные, но они больше не нужны.
* Это может быть из-за того, что данных достаточно (например, при использовании LIMIT).
*/
/// Отправим просьбу прервать выполнение запроса, если ещё не отправляли.
tryCancel("Cancelling query because enough data has been read");
/// Получим оставшиеся пакеты, чтобы не было рассинхронизации в соединениях с репликами.
Connection::Packet packet = multiplexed_connections->drain();
switch (packet.type)
{
case Protocol::Server::EndOfStream:
finished = true;
break;
case Protocol::Server::Exception:
got_exception_from_replica = true;
packet.exception->rethrow();
break;
default:
got_unknown_packet_from_replica = true;
throw Exception("Unknown packet from server", ErrorCodes::UNKNOWN_PACKET_FROM_SERVER);
}
}
void RemoteBlockInputStream::createMultiplexedConnections()
{
Settings * multiplexed_connections_settings = send_settings ? &settings : nullptr;
if (connection != nullptr)
multiplexed_connections = std::make_unique<MultiplexedConnections>(connection, multiplexed_connections_settings, throttler);
else if (pool != nullptr)
multiplexed_connections = std::make_unique<MultiplexedConnections>(pool.get(), multiplexed_connections_settings, throttler,
append_extra_info, pool_mode);
else if (pools != nullptr)
multiplexed_connections = std::make_unique<MultiplexedConnections>(*pools, multiplexed_connections_settings, throttler,
append_extra_info, pool_mode);
else
throw Exception("Internal error", ErrorCodes::LOGICAL_ERROR);
}
void RemoteBlockInputStream::init(const Settings * settings_)
{
if (settings_)
{
send_settings = true;
settings = *settings_;
}
else
send_settings = false;
}
void RemoteBlockInputStream::sendQuery()
{
createMultiplexedConnections();
if (settings.skip_unavailable_shards && 0 == multiplexed_connections->size())
return;
established = true;
multiplexed_connections->sendQuery(query, "", stage, &context.getClientInfo(), true);
established = false;
sent_query = true;
sendExternalTables();
}
void RemoteBlockInputStream::tryCancel(const char * reason)
{
bool old_val = false;
if (!was_cancelled.compare_exchange_strong(old_val, true, std::memory_order_seq_cst, std::memory_order_relaxed))
return;
LOG_TRACE(log, "(" << multiplexed_connections->dumpAddresses() << ") " << reason);
multiplexed_connections->sendCancel();
}
bool RemoteBlockInputStream::isQueryPending() const
{
return sent_query && !finished;
}
bool RemoteBlockInputStream::hasThrownException() const
{
return got_exception_from_replica || got_unknown_packet_from_replica;
}
}
| 28.943144 | 126 | 0.747053 | rudneff |
0cf6b74fca7c1adb038d24ab8b39b50f94811e0c | 4,183 | cpp | C++ | lib/Widgets/widget.cpp | tomfleet/M5PaperUI | cad8ccbbdf2273865eb9cbec70f41f87eca3fadd | [
"Apache-2.0"
] | 24 | 2021-02-25T21:17:22.000Z | 2022-03-01T19:01:13.000Z | lib/Widgets/widget.cpp | sthagen/M5PaperUI | 05025433054d4e59ce8ec01eecbe44ac074b08ec | [
"Apache-2.0"
] | null | null | null | lib/Widgets/widget.cpp | sthagen/M5PaperUI | 05025433054d4e59ce8ec01eecbe44ac074b08ec | [
"Apache-2.0"
] | 10 | 2021-02-27T21:26:46.000Z | 2022-03-13T12:59:40.000Z | #include "widget.hpp"
void Widget::Init() {
// Create a new canvas for this on screen component.
canvas_->createCanvas(width_, height_);
log_d("Initialize widget %s", name_.c_str());
// Initialize the view to be dirty to draw it the first time.
view_dirty_ = true;
int16_t x = has_own_canvas_ ? 0 : x_;
int16_t y = has_own_canvas_ ? 0 : y_;
if (widget_style_.ShouldDraw(WidgetStyle::BORDER)) {
log_d("Drawing outline");
if (border_style_ == BorderStyle::ROUND) {
int16_t r = border_radius_;
int16_t w = width_;
int16_t h = width_;
canvas_->drawFastHLine(x + r, y, w - r - r, border_width_,
border_color_.toInt()); // Top
canvas_->drawFastHLine(x + r, y + h - 1, w - r - r, border_width_,
border_color_.toInt()); // Bottom
canvas_->drawFastVLine(x, y + r, h - r - r, border_width_,
border_color_.toInt()); // Left
canvas_->drawFastVLine(x + w - 1, y + r, h - r - r, border_width_,
border_color_.toInt()); // Right
// TOOD (assert radius < border width)
for (int16_t i = 0; i < border_width_; ++i) {
canvas_->drawCircleHelper(x + r, y + r, r - i, 1,
border_color_.toInt());
canvas_->drawCircleHelper(x + w - r - 1, y + r, r - i, 2,
border_color_.toInt());
canvas_->drawCircleHelper(x + w - r - 1, y + h - r - 1, r - i, 4,
border_color_.toInt());
canvas_->drawCircleHelper(x + r, y + h - r - 1, r - i, 8,
border_color_.toInt());
}
} else {
// Top
canvas_->drawFastHLine(x, y, width_, border_width_,
border_color_.toInt());
// Bottom
canvas_->drawFastHLine(x, y + height_ - 1, width_, border_width_,
border_color_.toInt());
// Left
canvas_->drawFastVLine(x, y, height_, border_width_,
border_color_.toInt());
// Right
canvas_->drawFastVLine(x + width_ - 1, y, height_, border_width_,
border_color_.toInt());
}
}
if (widget_style_.ShouldDraw(WidgetStyle::FILL_W_BORDER)) {
log_d("Drawing fill and border");
if (border_style_ == BorderStyle::ROUND) {
canvas_->fillRoundRect(x + border_width_, y + border_width_,
width_ - (2 * border_width_),
height_ - (2 * border_width_), border_radius_,
background_color_.toInt());
} else {
canvas_->fillRect(
x + border_width_, y + border_width_, width_ - (2 * border_width_),
height_ - (2 * border_width_), background_color_.toInt());
}
}
if (widget_style_.ShouldDraw(WidgetStyle::FILL)) {
log_d("Drawing fill");
canvas_->fillRect(x, y, width_, height_, background_color_.toInt());
}
}
bool Widget::Draw() {
if (view_dirty_) {
log_d("Drawing widget %s at %d %d %d %d %d %d", name_.c_str(), x_,
x_offset_, y_, y_offset_, has_own_canvas_, parent_->update_mode());
if (has_own_canvas_) {
// Only some update modes support grayscale display.
auto update_mode =
use_child_update_mode_ ? update_mode_ : parent_->update_mode();
bool supportsGrayscale =
update_mode == UPDATE_MODE_GC16 || update_mode == UPDATE_MODE_INIT ||
update_mode == UPDATE_MODE_GL16 || update_mode == UPDATE_MODE_GLD16 ||
update_mode == UPDATE_MODE_GLR16;
if (!supportsGrayscale && !background_color_.monochrome()) {
log_d("Update mode of the EPD might not support grayscale display");
}
canvas_->pushCanvas(x_offset_, y_offset_, update_mode);
}
view_dirty_ = false;
}
return view_dirty_;
}
void Widget::BackgroundColor(Grayscale c) { background_color_ = c; }
void Widget::RegisterHandler(handler_fun_t f) { handlers_.push_back(f); }
void Widget::HandleEvent(TouchEvent evt) {
InternalEventHandler(evt);
for (const auto &h : handlers_) {
h(evt, this);
}
} | 38.376147 | 80 | 0.572795 | tomfleet |
0cf8b8fe6861034f7a97eeb78fcb465b7f53e2b4 | 4,075 | hpp | C++ | src/Utils/Logger/ILogger.hpp | Sebajuste/Omeglond3D | 28a3910b47490ec837a29e40e132369f957aedc7 | [
"MIT"
] | 1 | 2019-06-14T08:24:17.000Z | 2019-06-14T08:24:17.000Z | src/Utils/Logger/ILogger.hpp | Sebajuste/Omeglond3D | 28a3910b47490ec837a29e40e132369f957aedc7 | [
"MIT"
] | null | null | null | src/Utils/Logger/ILogger.hpp | Sebajuste/Omeglond3D | 28a3910b47490ec837a29e40e132369f957aedc7 | [
"MIT"
] | null | null | null | #ifndef _DEF_OMEGLOND3D_ILOGGER_HPP
#define _DEF_OMEGLOND3D_ILOGGER_HPP
#include "../Ptr/SmartPtr.hpp"
#include <string>
#include <sstream>
#include <map>
#include <iostream>
namespace OMGL3D
{
namespace UTILS
{
enum LoggerType {
OMGL_LOGGER_DEBUG,
OMGL_LOGGER_STANDART,
OMGL_LOGGER_ERROR,
OMGL_LOGGER_RENDERER
};
enum LoggerTarget {
OMGL_LOGGER_FILE,
OMGL_LOGGER_CONSOLE
};
enum LoggerTag {
OMGL_LOGGER_FLUSH,
OMGL_LOGGER_ENDL
};
class ILogger
{
public:
//-------------------------------------------------
// Destructor
//-------------------------------------------------
virtual ~ILogger();
//-------------------------------------------------
// Add logger for type [OMGL_LOGGER_DEBUG|OMGL_LOGGER_ERROR|OMGL_LOGGER_RENDERER]
//-------------------------------------------------
static void SetLogger(ILogger * logger, const LoggerType & type);
//-------------------------------------------------
// Set the target for a logger type
//-------------------------------------------------
static void SetLogger(const LoggerType & type, const LoggerTarget & target);
//-------------------------------------------------
// Return the logger for type
//-------------------------------------------------
static ILogger & GetLogger(const LoggerType & type);
//-------------------------------------------------
// Destroy all loggers
//-------------------------------------------------
static void DestroyLoggers();
//-------------------------------------------------
// Return the current time
//-------------------------------------------------
static std::string GetCurrentTime();
//-------------------------------------------------
// Return the current date
//-------------------------------------------------
static std::string GetCurrentDate();
//-------------------------------------------------
// Operator << for log
//-------------------------------------------------
template <class T> ILogger & operator <<(const T & toLog);
//-------------------------------------------------
// Operator << for tag log [OMGL_LOGGER_ENDL|OMGL_LOGGER_FLUSH]
//-------------------------------------------------
ILogger & operator <<(const LoggerTag & toLog);
private:
//-------------------------------------------------
// Write a string in the log
//-------------------------------------------------
virtual void Write(const std::string & str)=0;
//-------------------------------------------------
// Write a tag in the log
//-------------------------------------------------
virtual void Write(const LoggerTag & tag)=0;
//-------------------------------------------------
// Destroy a logger who type is the logger type
//-------------------------------------------------
static void Destroy(const LoggerType & type);
struct LoggerLife {
~LoggerLife();
};
//typedef std::map<LoggerType, ILogger*> Loggers;
typedef std::map<LoggerType, ptr<ILogger>::SharedPtr> Loggers;
static Loggers _loggers;
static LoggerLife life;
};
template <class T> ILogger & ILogger::operator <<(const T & toLog)
{
std::ostringstream stream;
stream << toLog;
Write(stream.str());
return *this;
}
}
}
#endif
| 32.34127 | 94 | 0.340859 | Sebajuste |