hexsha stringlengths 40 40 | size int64 7 1.05M | ext stringclasses 13
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 4 269 | max_stars_repo_name stringlengths 5 109 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses 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 48.5k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 269 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses 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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
215910b672deb5fd314958592ff7d14ad68d0d36 | 3,770 | cpp | C++ | engine/source/component/behaviors/behaviorInstance.cpp | Sednari/twitch-tutorial-flappy-birds | 9aaed1cea2ef24ef6a5212c3350db17a017142fe | [
"MIT"
] | 1,309 | 2015-01-01T02:46:14.000Z | 2022-03-14T04:56:02.000Z | engine/source/component/behaviors/behaviorInstance.cpp | Sednari/twitch-tutorial-flappy-birds | 9aaed1cea2ef24ef6a5212c3350db17a017142fe | [
"MIT"
] | 155 | 2015-01-11T19:26:32.000Z | 2021-11-22T04:08:55.000Z | engine/source/component/behaviors/behaviorInstance.cpp | Sednari/twitch-tutorial-flappy-birds | 9aaed1cea2ef24ef6a5212c3350db17a017142fe | [
"MIT"
] | 1,595 | 2015-01-01T23:19:48.000Z | 2022-02-17T07:00:52.000Z | //-----------------------------------------------------------------------------
// Copyright (c) 2013 GarageGames, LLC
//
// 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 "component/behaviors/behaviorInstance.h"
#include "component/behaviors/behaviorTemplate.h"
#include "console/consoleTypes.h"
#include "console/consoleInternal.h"
#include "io/stream.h"
// Script bindings.
#include "behaviorInstance_ScriptBinding.h"
//-----------------------------------------------------------------------------
IMPLEMENT_CONOBJECT(BehaviorInstance);
//-----------------------------------------------------------------------------
BehaviorInstance::BehaviorInstance( BehaviorTemplate* pTemplate ) :
mTemplate( pTemplate ),
mBehaviorOwner( NULL ),
mBehaviorId( 0 )
{
if ( pTemplate != NULL )
{
// Fetch field prototype count.
const U32 fieldCount = pTemplate->getBehaviorFieldCount();
// Set field prototypes.
for( U32 index = 0; index < fieldCount; ++index )
{
// Fetch fields.
BehaviorTemplate::BehaviorField* pField = pTemplate->getBehaviorField( index );
// Set cloned field.
setDataField( pField->mName, NULL, pField->mDefaultValue );
}
}
}
//-----------------------------------------------------------------------------
bool BehaviorInstance::onAdd()
{
if(! Parent::onAdd())
return false;
// Store this object's namespace
mNameSpace = Namespace::global()->find( getTemplateName() );
return true;
}
//-----------------------------------------------------------------------------
void BehaviorInstance::onRemove()
{
Parent::onRemove();
}
//-----------------------------------------------------------------------------
void BehaviorInstance::initPersistFields()
{
addGroup("Behavior");
addField("template", TypeSimObjectName, Offset(mTemplate, BehaviorInstance), "Template this instance was created from.");
addProtectedField( "Owner", TypeSimObjectPtr, Offset(mBehaviorOwner, BehaviorInstance), &setOwner, &defaultProtectedGetFn, "Behavior component owner." );
endGroup("Behavior");
Parent::initPersistFields();
}
//-----------------------------------------------------------------------------
const char* BehaviorInstance::getTemplateName( void )
{
return mTemplate ? mTemplate->getName() : NULL;
}
// Get template.
const char* BehaviorInstance::getTemplate(void* obj, const char* data)
{
return static_cast<BehaviorInstance*>(obj)->getTemplate()->getIdString();
}
| 36.25 | 160 | 0.574271 | Sednari |
215955a3532cb8d5bc4afef8b65931fe7552bed7 | 1,368 | hpp | C++ | include/sprout/algorithm/fit/results.hpp | thinkoid/Sprout | a5a5944bb1779d3bb685087c58c20a4e18df2f39 | [
"BSL-1.0"
] | 4 | 2021-12-29T22:17:40.000Z | 2022-03-23T11:53:44.000Z | dsp/lib/sprout/sprout/algorithm/fit/results.hpp | TheSlowGrowth/TapeLooper | ee8d8dccc27e39a6f6f6f435847e4d5e1b97c264 | [
"MIT"
] | 16 | 2021-10-31T21:41:09.000Z | 2022-01-22T10:51:34.000Z | include/sprout/algorithm/fit/results.hpp | thinkoid/Sprout | a5a5944bb1779d3bb685087c58c20a4e18df2f39 | [
"BSL-1.0"
] | null | null | null | /*=============================================================================
Copyright (c) 2011-2019 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_ALGORITHM_FIT_RESULTS_HPP
#define SPROUT_ALGORITHM_FIT_RESULTS_HPP
#include <type_traits>
#include <sprout/config.hpp>
#include <sprout/container/traits.hpp>
#include <sprout/container/metafunctions.hpp>
#include <sprout/algorithm/fixed/results.hpp>
#include <sprout/sub_array/sub_array.hpp>
namespace sprout {
namespace fit {
namespace results {
//
// algorithm
//
template<typename Result>
struct algorithm {
public:
typedef sprout::sub_array<
typename std::decay<
typename sprout::containers::internal<
typename sprout::fixed::results::algorithm<Result>::type
>::type
>::type
> type;
};
#if SPROUT_USE_TEMPLATE_ALIASES
template<typename Result>
using algorithm_t = typename sprout::fit::results::algorithm<Result>::type;
#endif // #if SPROUT_USE_TEMPLATE_ALIASES
} // namespace results
} // namespace fit
} // namespace sprout
#endif // #ifndef SPROUT_ALGORITHM_FIT_RESULTS_HPP
| 30.4 | 79 | 0.652047 | thinkoid |
215d3d1e4bb9ee62f05c5266e44c2a6d0fd1c418 | 1,272 | cpp | C++ | interpreter-for-cpp/src/Runtime/Executer.cpp | Jenocn/PeakScript | 444ba5f9d0062989d8beca0d76415961f1ae2922 | [
"MIT"
] | 1 | 2020-05-21T09:02:19.000Z | 2020-05-21T09:02:19.000Z | interpreter-for-cpp/src/Runtime/Executer.cpp | Jenocn/PeakScript | 444ba5f9d0062989d8beca0d76415961f1ae2922 | [
"MIT"
] | 8 | 2020-05-29T14:12:00.000Z | 2022-01-22T09:08:47.000Z | interpreter-for-cpp/src/Runtime/Executer.cpp | Jenocn/PeakScript | 444ba5f9d0062989d8beca0d76415961f1ae2922 | [
"MIT"
] | null | null | null | #include "Executer.h"
#include "../Grammar/ParseTool.h"
#include "Sentence/Sentence.h"
#include "Space.h"
using namespace peak::interpreter;
std::shared_ptr<Executer> Executer::Create(const std::string& src) {
if (src.empty()) {
return nullptr;
}
auto parseData = ParseTool::Load(src);
if (!parseData->bSuccess) {
return nullptr;
}
return std::shared_ptr<Executer>(new Executer(parseData));
}
Executer::Executer(std::shared_ptr<ParseData> data)
: _parseData(data) {
_space = std::shared_ptr<Space>(new Space(SpaceType::None));
_outsideSpace = std::shared_ptr<Space>(new Space(SpaceType::None));
}
Executer::~Executer() {
_space->Clear();
_outsideSpace->Clear();
}
bool Executer::Execute() {
_space->Clear();
_space->AddSpaceOfUsing(_outsideSpace);
for (auto sentence : _parseData->sentenceList) {
if (!Sentence::IsSuccess(sentence->Execute(_space))) {
return false;
}
}
return true;
}
std::shared_ptr<Space> Executer::GetSpace() const {
return _space;
}
std::shared_ptr<Variable> Executer::FindVariable(const std::string& name) const {
return _space->FindVariable(name);
}
bool Executer::AddVariable(std::shared_ptr<Variable> variable) {
return _outsideSpace->AddVariable(variable);
}
| 24.941176 | 82 | 0.693396 | Jenocn |
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 |
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 <[email protected]>
#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 |
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 |
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 |
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 |
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 |
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, [email protected]
//========================================================================
#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 |
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 |
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: [email protected]
* 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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 <[email protected]>
//
// 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 <[email protected]> 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 |
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 |
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 |
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 <[email protected]>
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 |
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 |
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 |
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 |
0cf8c9eadf4765bbe91ecff6c28a559fa567608d | 370 | cpp | C++ | 45-jump-game-ii/45-jump-game-ii.cpp | Ananyaas/LeetCodeDaily | e134e20ac02f26dc40881c376656d3294be0df2c | [
"MIT"
] | 2 | 2022-01-02T19:15:00.000Z | 2022-01-05T21:12:24.000Z | 45-jump-game-ii/45-jump-game-ii.cpp | Ananyaas/LeetCodeDaily | e134e20ac02f26dc40881c376656d3294be0df2c | [
"MIT"
] | null | null | null | 45-jump-game-ii/45-jump-game-ii.cpp | Ananyaas/LeetCodeDaily | e134e20ac02f26dc40881c376656d3294be0df2c | [
"MIT"
] | 1 | 2022-03-11T17:11:07.000Z | 2022-03-11T17:11:07.000Z | class Solution {
public:
int jump(vector<int>& nums) {
int curreach=0;
int jumps=0;
int maxreach=0;
for(int i=0;i<nums.size()-1;i++){
maxreach=max(maxreach, i+nums[i]);
if(i==curreach){
jumps++;
curreach=maxreach;
}
}
return jumps;
}
};
| 20.555556 | 46 | 0.42973 | Ananyaas |
0cf9ea794f569df958c7d886479c773b7535927f | 16,404 | cpp | C++ | src/engine/eXl_Main.cpp | eXl-Nic/eXl | a5a0f77f47db3179365c107a184bb38b80280279 | [
"MIT"
] | null | null | null | src/engine/eXl_Main.cpp | eXl-Nic/eXl | a5a0f77f47db3179365c107a184bb38b80280279 | [
"MIT"
] | null | null | null | src/engine/eXl_Main.cpp | eXl-Nic/eXl | a5a0f77f47db3179365c107a184bb38b80280279 | [
"MIT"
] | null | null | null | #include <engine/eXl_Main.hpp>
#include <core/corelib.hpp>
#include <core/log.hpp>
#include <core/plugin.hpp>
#include <core/random.hpp>
#include <core/clock.hpp>
#include <core/coretest.hpp>
#include <core/image/imagestreamer.hpp>
#include <core/resource/resourcemanager.hpp>
#include <core/utils/filetextreader.hpp>
#include <core/stream/inputstream.hpp>
#define IMGUI_API __declspec(dllimport)
#include <imgui.h>
#undef IMGUI_API
#undef IMGUI_IMPL_API
#define IMGUI_API
#define IMGUI_IMPL_API
#include <backends/imgui_impl_sdl.h>
#include <backends/imgui_impl_opengl3.h>
#include <SDL.h>
#include <core/stream/jsonstreamer.hpp>
#include <core/stream/jsonunstreamer.hpp>
#include <fstream>
#include <sstream>
#include <locale>
#include <codecvt>
//#define USE_BAKED
#ifndef __ANDROID__
extern "C"
FILE* __iob_func()
{
static FILE locPtr[] = { *stdin, *stdout, *stderr };
return locPtr;
}
extern "C"
{
__declspec(dllexport) uint32_t NvOptimusEnablement = 0x00000001;
}
#endif
#include <core/name.hpp>
#include <core/input.hpp>
#include <core/type/typemanager.hpp>
#include <math/mathtools.hpp>
#include "console.hpp"
#include "sdlkeytranslator.hpp"
#include "debugpanel.hpp"
#include "debugviews.hpp"
#include "navigatorbench.hpp"
#include <engine/common/debugtool.hpp>
#include <engine/common/menumanager.hpp>
#include <engine/common/app.hpp>
#include <engine/common/transforms.hpp>
#include <engine/gfx/gfxsystem.hpp>
#include <engine/physics/physicsys.hpp>
#include <engine/pathfinding/navigator.hpp>
#include <engine/common/project.hpp>
#include <engine/game/scenariobase.hpp>
#ifndef EXL_SHARED_LIBRARY
namespace eXl
{
Plugin& MathPlugin_GetPlugin();
Plugin& OGLPlugin_GetPlugin();
Plugin& EnginePlugin_GetPlugin();
PluginLoadMap s_StaticPluginMap =
{
{"eXl_OGL", &OGLPlugin_GetPlugin},
{"eXl_Math", &MathPlugin_GetPlugin},
{"eXl_Engine", &EnginePlugin_GetPlugin}
};
}
#endif
using namespace eXl;
class SDLFileInputStream : public InputStream
{
public:
SDLFileInputStream(char const* iPath)
{
m_RWStruct = SDL_RWFromFile(iPath, "rb");
if (m_RWStruct)
{
SDL_RWseek(m_RWStruct, 0, RW_SEEK_END);
m_Size = SDL_RWtell(m_RWStruct);
SDL_RWseek(m_RWStruct, 0, RW_SEEK_SET);
}
else
{
LOG_ERROR << "Could not open " << iPath << "\n";
}
}
~SDLFileInputStream()
{
if (m_RWStruct)
{
SDL_RWclose(m_RWStruct);
}
}
size_t Read(size_t iOffset, size_t iSize, void* oData) override
{
if (m_CurPos != iOffset)
{
SDL_RWseek(m_RWStruct, iOffset, RW_SEEK_SET);
m_CurPos = iOffset;
}
size_t numRead = SDL_RWread(m_RWStruct, oData, iSize, 1);
if (numRead != 0)
{
m_CurPos += iSize;
}
return numRead * iSize;
}
size_t GetSize() const override
{
return m_Size;
}
protected:
SDL_RWops* m_RWStruct;
size_t m_Size = 0;
size_t m_CurPos = 0;
};
class LogPanel : public MenuManager::Panel
{
public:
LogPanel(ImGuiLogState& iLogState) : m_State(iLogState)
{}
private:
void Display() override
{
m_State.Display();
}
ImGuiLogState& m_State;
};
class LuaConsolePanel : public MenuManager::Panel
{
public:
LuaConsolePanel(LuaConsole& iConsole) : m_Console(iConsole)
{}
private:
void Display() override
{
m_Console.Draw();
}
LuaConsole& m_Console;
};
struct DebugVisualizerState
{
float m_TimeScaling = 1.0;
bool m_ViewNavMesh = false;
bool m_ViewPhysic = false;
bool m_ViewNeighbours = false;
bool m_ViewAgents = false;
};
class DebugVisualizerPanel : public MenuManager::Panel
{
public:
DebugVisualizerPanel(DebugVisualizerState& iState) : m_State(iState)
{
}
private:
void Display() override
{
ImGui::DragFloat("Time Scaling", &m_State.m_TimeScaling, 0.1, 0.001, 100.0, "%.3f", ImGuiSliderFlags_Logarithmic);
ImGui::Checkbox("Nav Mesh", &m_State.m_ViewNavMesh);
ImGui::Checkbox("Physic", &m_State.m_ViewPhysic);
ImGui::Checkbox("Neighbours", &m_State.m_ViewNeighbours);
ImGui::Checkbox("Nav Agents", &m_State.m_ViewAgents);
}
DebugVisualizerState& m_State;
};
class ProfilingPanel : public MenuManager::Panel
{
public:
ProfilingPanel(ProfilingState const& iState) : m_State(iState)
{}
private:
void Display() override
{
ImGui::Text("Last Frame Time : %f ms", m_State.m_LastFrameTime);
ImGui::Text("NeighExtraction Time : %f ms", m_State.m_NeighETime);
//ImGui::Text("Navigator Time : %f ms", m_State.m_NavigatorTime);
ImGui::Text("Physic Time : %f ms", m_State.m_PhysicTime);
ImGui::Text("Renderer Time : %f ms", m_State.m_RendererTime);
ImGui::Text("Transform tick Time : %f ms", m_State.m_TransformsTickTime);
}
ProfilingState const& m_State;
};
namespace eXl
{
class SDL_Application : public Engine_Application
{
public:
SDL_Application()
{
SDLKeyTranslator::Init();
}
SDL_Window* win = 0;
SDL_GLContext context = 0;
SDL_Renderer* renderer = 0;
WorldState* m_World;
PropertiesManifest* m_Manifest;
void InitOGL()
{
if (context)
{
return;
}
context = SDL_GL_CreateContext(win);
if (!context)
{
LOG_ERROR << "Failed to create OGL context" << "\n";
}
if (SDL_GL_SetSwapInterval(-1) != 0)
{
SDL_GL_SetSwapInterval(1);
}
SDL_GL_MakeCurrent(win, context);
GfxSystem::StaticInit();
m_World->Init(*m_Manifest).WithGfx();
if (GetScenario())
{
m_World->WithScenario(GetScenario());
}
GfxSystem* gfxSys = m_World->GetWorld().GetSystem<GfxSystem>();
DebugTool::SetDrawer(gfxSys->GetDebugDrawer());
}
void Start_SDLApp()
{
SDL_SetMainReady();
SDL_Init(SDL_INIT_VIDEO);
Vector2i viewportSize(m_Width, m_Height);
uint32_t windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
#ifdef __ANDROID__
SDL_DisplayMode mode;
SDL_GetDisplayMode(0, 0, &mode);
viewportSize.X() = mode.w;
viewportSize.Y() = mode.h;
//windowFlags |= SDL_WINDOW_FULLSCREEN;
#endif
#ifdef __ANDROID__
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
#else
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
#endif
win = SDL_CreateWindow("eXl", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, viewportSize.X(), viewportSize.Y(), windowFlags);
InitOGL();
for (uint32_t logLevel = INFO_STREAM; logLevel <= ERROR_STREAM; ++logLevel)
{
Log_Manager::AddOutput(eXl_NEW ImGuiLogOutput(m_LogState, logLevel), 1 << logLevel);
}
#ifndef __ANDROID__
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
ImGui_ImplSDL2_InitForOpenGL(win, context);
ImGui_ImplOpenGL3_Init();
// Setup style
ImGui::StyleColorsDark();
MenuManager& menuMgr = GetMenuManager();
menuMgr.AddMenu("View")
.AddOpenPanelCommand("Log", [this] {return eXl_NEW LogPanel(m_LogState); })
.AddOpenPanelCommand("Profiling", [this] {return eXl_NEW ProfilingPanel(m_World->GetProfilingState()); })
.AddOpenPanelCommand("Debug", [this] {return eXl_NEW DebugPanel(m_World->GetWorld()); })
.AddOpenPanelCommand("Debug Visualizer", [this] {return eXl_NEW DebugVisualizerPanel(m_DebugVisState); })
//.AddOpenPanelCommand("Console", [this] {return eXl_NEW LuaConsolePanel(m_Console); })
.EndMenu();
NavigatorBench::AddNavigatorBenchMenu(menuMgr, m_World->GetWorld());
#endif
m_World->GetCamera().view.viewportSize = viewportSize;
}
void PumpMessages(float iDelta)
{
SDL_Event curEvent;
while (SDL_PollEvent(&curEvent))
{
#ifndef __ANDROID__
ImGui_ImplSDL2_ProcessEvent(&curEvent);
#endif
if (curEvent.type == SDL_MOUSEMOTION)
{
SDL_MouseMotionEvent& mouseEvt = reinterpret_cast<SDL_MouseMotionEvent&>(curEvent);
m_MousePos.X() = mouseEvt.x;
m_MousePos.Y() = mouseEvt.y;
GetInputSystem().InjectMouseMoveEvent(mouseEvt.x, mouseEvt.y, mouseEvt.xrel, mouseEvt.yrel, false);
}
if (curEvent.type == SDL_MOUSEWHEEL)
{
SDL_MouseWheelEvent& wheelEvt = reinterpret_cast<SDL_MouseWheelEvent&>(curEvent);
GetInputSystem().InjectMouseMoveEvent(wheelEvt.y, wheelEvt.y, wheelEvt.y, wheelEvt.y, true);
}
if (curEvent.type == SDL_MOUSEBUTTONDOWN
|| curEvent.type == SDL_MOUSEBUTTONUP)
{
SDL_MouseButtonEvent& mouseEvt = reinterpret_cast<SDL_MouseButtonEvent&>(curEvent);
MouseButton button;
switch (mouseEvt.button)
{
case SDL_BUTTON_LEFT:
button = MouseButton::Left;
break;
case SDL_BUTTON_RIGHT:
button = MouseButton::Right;
break;
case SDL_BUTTON_MIDDLE:
button = MouseButton::Middle;
break;
default:
continue;
break;
}
if (mouseEvt.button == SDL_BUTTON_RIGHT)
{
PhysicsSystem& phSys = *m_World->GetWorld().GetSystem<PhysicsSystem>();
GfxSystem& gfxSys = *m_World->GetWorld().GetSystem<GfxSystem>();
Vector3f worldPos;
Vector3f viewDir;
gfxSys.ScreenToWorld(m_MousePos, worldPos, viewDir);
List<CollisionData> colResult;
phSys.RayQuery(colResult, worldPos, worldPos - viewDir * 10000);
if (!colResult.empty())
{
DebugTool::SelectObject(colResult.front().obj1);
}
}
GetInputSystem().InjectMouseEvent(button, curEvent.type == SDL_MOUSEBUTTONDOWN);
}
bool keyChanged = false;
if (curEvent.type == SDL_KEYUP
|| curEvent.type == SDL_KEYDOWN)
{
SDL_KeyboardEvent& keyEvt = reinterpret_cast<SDL_KeyboardEvent&>(curEvent);
if (keyEvt.keysym.sym == SDLK_BACKQUOTE)
{
if (curEvent.type == SDL_KEYUP)
{
m_ConsoleOpen = !m_ConsoleOpen;
}
}
else
{
GetInputSystem().InjectKeyEvent(0, SDLKeyTranslator::Translate(keyEvt.keysym.scancode), curEvent.type == SDL_KEYDOWN);
}
}
if (curEvent.type == SDL_WINDOWEVENT)
{
SDL_WindowEvent& winEvt = reinterpret_cast<SDL_WindowEvent&>(curEvent);
if (winEvt.event == SDL_WINDOWEVENT_CLOSE)
{
exit(0);
}
if (winEvt.event == SDL_WINDOWEVENT_RESIZED)
{
Vector2i viewportSize;
viewportSize.X() = winEvt.data1;
viewportSize.Y() = winEvt.data2;
m_World->GetCamera().view.viewportSize = viewportSize;
}
if (winEvt.event == SDL_WINDOWEVENT_SHOWN)
{
InitOGL();
}
}
if (curEvent.type == SDL_QUIT)
{
exit(0);
}
}
}
void Tick(float iDelta) override
{
PumpMessages(iDelta);
if (context == 0)
{
return;
}
Engine_Application::Tick(iDelta);
MenuManager& menuMgr = GetMenuManager();
#ifndef __ANDROID__
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplSDL2_NewFrame(win);
ImGui::NewFrame();
if (ImGui::BeginMainMenuBar())
{
menuMgr.DisplayMenus();
ImGui::EndMainMenuBar();
}
#endif
Transforms& transforms = *m_World->GetWorld().GetSystem<Transforms>();
PhysicsSystem& phSys = *m_World->GetWorld().GetSystem<PhysicsSystem>();
NavigatorSystem& navigator = *m_World->GetWorld().GetSystem<NavigatorSystem>();
{
bool displayPhysSaveState = m_DebugVisState.m_ViewPhysic;
#ifndef __ANDROID__
menuMgr.DisplayPanels();
#endif
if (displayPhysSaveState != m_DebugVisState.m_ViewPhysic)
{
if (m_DebugVisState.m_ViewPhysic)
{
phSys.EnableDebugDraw(*DebugTool::GetDrawer());
}
else
{
phSys.DisableDebugDraw();
}
}
}
World& world = m_World->GetWorld();
if (m_DebugVisState.m_TimeScaling != m_World->GetWorld().GetGameTimeScaling())
{
m_World->GetWorld().SetGameTimeScaling(m_DebugVisState.m_TimeScaling);
}
InputSystem& inputs = GetInputSystem();
//m_CamState.ProcessInputs(world, inputs);
m_World->Tick();
inputs.Clear();
m_World->GetCamera().UpdateView(world);
m_World->Render(m_World->GetCamera().view);
if (m_DebugVisState.m_ViewNavMesh)
{
if (auto const* mesh = navigator.GetNavMesh())
{
DrawNavMesh(*mesh, *DebugTool::GetDrawer());
}
}
//DrawRooms(rooms[0], gfxSys.GetDebugDrawer());
if (m_DebugVisState.m_ViewNeighbours)
{
DrawNeigh(phSys.GetNeighborhoodExtraction(), transforms, *DebugTool::GetDrawer());
}
if (m_DebugVisState.m_ViewAgents)
{
DrawNavigator(navigator, transforms, *DebugTool::GetDrawer());
}
#ifndef __ANDROID__
ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
#endif
SDL_GL_SwapWindow(win);
}
ImGuiLogState m_LogState;
bool m_ConsoleOpen = true;
LuaConsole m_Console;
DebugVisualizerState m_DebugVisState;
Vector2i m_MousePos;
};
}
namespace
{
SDL_Application& GetApp()
{
static SDL_Application s_App;
return s_App;
}
}
eXl_Main::eXl_Main()
{
GetApp();
}
int eXl_Main::Start(int argc, char const* const argv[])
{
SDL_Application& app = GetApp();
InitConsoleLog();
app.SetWindowSize(1024, 768);
app.SetArgs(argc, argv);
WorldState world;
app.m_World = &world;
app.Start();
Path projectPath = app.GetProjectPath();
#if defined(WIN32) && !defined(USE_BAKED)
ResourceManager::SetTextFileReadFactory([](char const* iFilePath)
{
return std::unique_ptr<TextReader>(FileTextReader::Create(iFilePath));
});
#endif
#if defined(__ANDROID__) || defined(USE_BAKED)
ResourceManager::SetTextFileReadFactory([](char const* iFilePath) -> std::unique_ptr<TextReader>
{
std::unique_ptr<SDLFileInputStream> stream = std::make_unique<SDLFileInputStream>(iFilePath);
if (stream->GetSize() > 0)
{
return std::make_unique<InputStreamTextReader>(std::move(stream));
}
return std::unique_ptr<TextReader>();
});
#endif
Path appPath(GetAppPath().begin(), GetAppPath().end());
Project::ProjectTypes types;
PropertiesManifest appManifest = EngineCommon::GetBaseProperties();
app.m_Manifest = &appManifest;
Project* project = nullptr;
if (!projectPath.empty())
{
Path projectDir = projectPath.parent_path();
#if defined(USE_BAKED) && defined(WIN32)
ResourceManager::BootstrapAssetsFromManifest(projectDir);
#else
ResourceManager::BootstrapDirectory(projectDir, true);
#endif
project = ResourceManager::Load<Project>(projectPath);
if (!project)
{
return -1;
}
project->FillProperties(types, appManifest);
ResourceManager::AddManifest(EngineCommon::GetComponents());
ResourceManager::AddManifest(appManifest);
}
#if defined(__ANDROID__)
ResourceManager::BootstrapAssetsFromManifest(String());
#endif
if (!app.GetScenario() && !app.GetMapPath().empty())
{
std::unique_ptr<Scenario_Base> scenario = std::make_unique<Scenario_Base>();
MapResource const* mapRsc = ResourceManager::Load<MapResource>(app.GetMapPath());
if (mapRsc)
{
ResourceHandle<MapResource> mapRef;
mapRef.Set(mapRsc);
scenario->SetMap(mapRef);
}
scenario->SetMainChar(project->m_PlayerArchetype);
app.SetScenario(std::move(scenario));
}
app.Start_SDLApp();
app.DefaultLoop();
return 0;
}
| 24.704819 | 135 | 0.65167 | eXl-Nic |
0cfaee9c4a007ed95be1bb9b8ba542046757d2fb | 6,738 | cpp | C++ | common/MemoryRegion.cpp | zukisoft/vm | 8da577329a295449ed1517bbf27cb489531b18ac | [
"MIT"
] | 2 | 2017-02-02T13:32:14.000Z | 2017-08-20T07:58:49.000Z | common/MemoryRegion.cpp | zukisoft/vm | 8da577329a295449ed1517bbf27cb489531b18ac | [
"MIT"
] | null | null | null | common/MemoryRegion.cpp | zukisoft/vm | 8da577329a295449ed1517bbf27cb489531b18ac | [
"MIT"
] | 2 | 2017-03-09T02:41:25.000Z | 2019-07-10T03:22:23.000Z | //-----------------------------------------------------------------------------
// Copyright (c) 2016 Michael G. Brehm
//
// 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 "stdafx.h"
#include "MemoryRegion.h"
#pragma warning(push, 4)
//-----------------------------------------------------------------------------
// MemoryRegion Destructor
MemoryRegion::~MemoryRegion()
{
// If the region has not been detached, release it with VirtualFreeEx()
if(m_base) VirtualFreeEx(m_process, m_meminfo.AllocationBase, 0, MEM_RELEASE);
}
//-----------------------------------------------------------------------------
// MemoryRegion::Commit
//
// Commits page(s) of memory within the region using the specified protection
//
// Arguments:
//
// address - Base address to be committed
// length - Length of the region to be committed
// protect - Protection flags to be applied to the committed region
void MemoryRegion::Commit(void* address, size_t length, uint32_t protect)
{
// The system will automatically align the provided address downward and
// adjust the length such that entire page(s) will be committed
if(VirtualAllocEx(m_process, address, length, MEM_COMMIT, protect) == nullptr) throw Win32Exception();
}
//-----------------------------------------------------------------------------
// MemoryRegion::Decommit
//
// Decommits page(s) of memory from within the region
//
// Arguments:
//
// address - Base address to be decommitted
// length - Length of the region to be decommitted
void MemoryRegion::Decommit(void* address, size_t length)
{
// The system will automatically align the provided address downward and
// adjust the length such that entire page(s) will be decommitted
if(!VirtualFreeEx(m_process, address, length, MEM_DECOMMIT)) throw Win32Exception();
}
//-----------------------------------------------------------------------------
// MemoryRegion::Detach
//
// Detaches the memory region from the class so that it will not be released
// when the memory region instance is destroyed.
//
// Arguments:
//
// meminfo - MEMORY_BASIC_INFORMATION pointer to receive region data
// length - Optional size_t pointer to receive the region length
//
// NOTE: Returns the base pointer originally set up by Reserve(); the base
// allocation pointer can be accessed via the MEMORY_BASIC_INFORMATION
void* MemoryRegion::Detach(PMEMORY_BASIC_INFORMATION meminfo)
{
// Copy the data regarding the entire allocated region if requested
if(meminfo != nullptr) *meminfo = m_meminfo;
void* base = m_base; // Save original pointer from Reserve()
// Reset member variables to an uninitialized state to prevent use
m_base = nullptr;
m_length = 0;
m_process = INVALID_HANDLE_VALUE;
memset(&m_meminfo, 0, sizeof(MEMORY_BASIC_INFORMATION));
return base; // Return the original base pointer
}
//-----------------------------------------------------------------------------
// MemoryRegion::Protect
//
// Applies new protection flags to page(s) within the allocated region
//
// Arguments:
//
// address - Base address to apply the protection
// length - Length of the memory to apply the protection to
// protect - Virtual memory protection flags
uint32_t MemoryRegion::Protect(void* address, size_t length, uint32_t protect)
{
DWORD oldprotect; // Previous protection flags
// The system will automatically align the provided address downward and
// adjust the length such that entire page(s) will be decommitted
if(!VirtualProtectEx(m_process, address, length, protect, &oldprotect)) throw Win32Exception();
return oldprotect;
}
//-----------------------------------------------------------------------------
// MemoryRegion::Reserve (private, static)
//
// Reserves (and optionally commits) a region of virtual memory. When an address
// has been specified, the system will attempt to construct a region that is aligned
// down to the proper boundary that contains the requested address and length
//
// Arguments:
//
// process - Optional process handle to operate against or INVALID_HANDLE_VALUE
// address - Optional base address to use for the allocation
// length - Length of the memory region to allocate
// flags - Memory region allocation type flags
// protect - Memory region protection flags
std::unique_ptr<MemoryRegion> MemoryRegion::Reserve(HANDLE process, size_t length, void* address, uint32_t flags, uint32_t protect)
{
// Map INVALID_HANDLE_VALUE to the current process handle so that the Ex() version of the
// virtual memory API functions can be used exclusively by the MemoryRegion class instance
if(process == INVALID_HANDLE_VALUE) process = GetCurrentProcess();
// Attempt to reserve a memory region large enough to hold the requested length. If an
// address was specified, it will be automatically rounded down by the system as needed
void* regionbase = VirtualAllocEx(process, address, length, flags, protect);
if(regionbase == nullptr) throw Win32Exception();
// Query to determine the resultant memory region after adjustment by the system
MEMORY_BASIC_INFORMATION meminfo;
if(VirtualQueryEx(process, regionbase, &meminfo, sizeof(MEMORY_BASIC_INFORMATION)) == 0) {
Win32Exception exception; // Save exception code
VirtualFreeEx(process, regionbase, 0, MEM_RELEASE); // Release the region
throw exception;
}
// Region has been successfully reserved using the provided parameters
return std::make_unique<MemoryRegion>(process, (address) ? address : regionbase, length, meminfo);
}
//-----------------------------------------------------------------------------
#pragma warning(pop)
| 40.836364 | 131 | 0.676462 | zukisoft |
49057be46b80676e30a87b97e09854c9ceccbb53 | 2,881 | cpp | C++ | stdlib/test/TestUtility.cpp | LetsPlaySomeUbuntu/XitongOS-test-1 | 792d0c76f9aa4bb2b579d47c2c728394a3acf9f9 | [
"MIT"
] | null | null | null | stdlib/test/TestUtility.cpp | LetsPlaySomeUbuntu/XitongOS-test-1 | 792d0c76f9aa4bb2b579d47c2c728394a3acf9f9 | [
"MIT"
] | null | null | null | stdlib/test/TestUtility.cpp | LetsPlaySomeUbuntu/XitongOS-test-1 | 792d0c76f9aa4bb2b579d47c2c728394a3acf9f9 | [
"MIT"
] | null | null | null | #include "Common.hpp"
#include "TrackableObject.hpp"
#include <FunnyOS/Stdlib/Functional.hpp>
#include <gtest/gtest.h>
using namespace FunnyOS::Stdlib;
TEST(TestUtility, TestStorageEmpty) {
TrackableObject::ResetAll();
Storage<TrackableObject> test{};
ASSERT_EQ(TrackableObject::GetCopyConstructionCount(), 0)
<< "Empty storage initialization called the object constructor";
}
TEST(TestUtility, TestStorageCopy) {
{
TrackableObject::ResetAll();
bool flag = false;
TrackableObject testObject{flag};
flag = false;
Storage<TrackableObject> test{InPlaceConstructorTag::Value, testObject};
ASSERT_FALSE(flag) << "Copy storage initialization called the object constructor";
ASSERT_EQ(TrackableObject::GetStandardConstructionCount(), 1)
<< "Copy storage initialization called the object constructor";
ASSERT_EQ(TrackableObject::GetCopyConstructionCount(), 1)
<< "Copy storage initialization did not call the copy constructor";
ASSERT_TRUE(test.GetObject().IsValidObject()) << "Copied object is invalid";
}
ASSERT_EQ(TrackableObject::GetTotalConstructionCount(), TrackableObject::GetDestructionCount())
<< "Construction count != destruction count";
}
TEST(TestUtility, TestStorageInPlace) {
{
bool flag = false;
TrackableObject::ResetAll();
Storage<TrackableObject> test{InPlaceConstructorTag::Value, flag};
ASSERT_TRUE(flag) << "In-place storage initialization did not call the object constructor";
ASSERT_EQ(TrackableObject::GetTotalConstructionCount(), 1)
<< "In-place storage initialization did not call the object constructor";
ASSERT_TRUE(test.GetObject().IsValidObject()) << "Constructed object is invalid";
}
ASSERT_EQ(TrackableObject::GetTotalConstructionCount(), TrackableObject::GetDestructionCount())
<< "Construction count != destruction count";
}
TEST(TestUtility, TestAssignments) {
{
TrackableObject::ResetAll();
bool unused = false;
TrackableObject test(unused); // construction 1
Storage<TrackableObject> inPlace{InPlaceConstructorTag::Value, unused}; // construction 2
Storage<TrackableObject> copied{inPlace}; // copy 1
Storage<TrackableObject> moved{Move(inPlace)}; // move 1
ASSERT_EQ(TrackableObject::GetStandardConstructionCount(), 2) << "Construction count invalid";
ASSERT_EQ(TrackableObject::GetMoveConstructionCount(), 1) << "Move count invalid";
ASSERT_EQ(TrackableObject::GetCopyConstructionCount(), 1) << "Copy count invalid";
}
ASSERT_EQ(TrackableObject::GetTotalConstructionCount(), TrackableObject::GetDestructionCount())
<< "Construction count != destruction count";
} | 38.413333 | 102 | 0.68865 | LetsPlaySomeUbuntu |
490d678fb4287ec39eed40b88f2ec0d28fb4ab11 | 5,853 | cpp | C++ | Eudora71/PlaylistClient/plgen/plgen.cpp | dusong7/eudora-win | 850a6619e6b0d5abc770bca8eb5f3b9001b7ccd2 | [
"BSD-3-Clause-Clear"
] | 10 | 2018-05-23T10:43:48.000Z | 2021-12-02T17:59:48.000Z | Windows/Eudora71/PlaylistClient/plgen/plgen.cpp | officialrafsan/EUDORA | bf43221f5663ec2338aaf90710a89d1490b92ed2 | [
"MIT"
] | 1 | 2019-03-19T03:56:36.000Z | 2021-05-26T18:36:03.000Z | Windows/Eudora71/PlaylistClient/plgen/plgen.cpp | officialrafsan/EUDORA | bf43221f5663ec2338aaf90710a89d1490b92ed2 | [
"MIT"
] | 11 | 2018-05-23T10:43:53.000Z | 2021-12-27T15:42:58.000Z | // plgen.cpp -- generate a skelleton playlist from a collection of image files
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "assert.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "io.h"
#include "direct.h"
////////////////////////////////////////////////////////////////////////////////
// Utils
inline void trim( char* s )
{
char* c;
for ( c = s; *c == ' '; c++ )
;
if ( c != s )
strcpy( s, c );
for ( c = &s[strlen(s)-1]; *c == ' '; c-- )
;
*(c+1) = 0;
}
////////////////////////////////////////////////////////////////////////////////
// xml generation
char* elements[] = {"clientUpdateResponse", "clientInfo", "reqInterval",
"playlist", "playlistID", "entry", "adID", "title", "src", "url",
"showFor", "showForMax", "dayMax", "blackBefore", "blackAfter",
"startDT", "endDT", "nextAd"};
enum element_ids {clientUpdateResponse, clientInfo, reqInterval, playlist,
playlistID, entry, entryID, title, src, href, showFor, showForMax,
dayMax, blackBefore, blackAfter, startDT, endDT, nextEntry};
const int kNumElements = sizeof(elements)/4;
char* defdata[kNumElements];
// track levels of indentation
int level = 0;
// write out an element start tag
inline void startElement( int id, char** attrs, bool linebreak )
{
for ( int j = level; j > 0; j-- )
printf( "\t" );
printf( "<%s>", elements[id] );
if ( linebreak )
printf( "\n" );
level++;
}
// write out an element end tag
inline void endElement( int id, bool linebreak )
{
level--;
if ( linebreak ) {
for ( int j = level; j > 0; j-- )
printf( "\t" );
}
printf( "</%s>\n", elements[id] );
}
inline void writeElementData( int id )
{
if ( defdata[id] ) {
printf( defdata[id] );
if ( id == src )
*(defdata[src]) = 0;
}
}
inline void outputDataField( int id )
{
startElement( id, 0, false );
writeElementData( id );
endElement( id, false );
}
void initDefdata()
{
char buf[512];
char* key, * value;
memset( defdata, 0, sizeof(defdata) );
FILE* fp = fopen( "plgen.ini", "r" );
if ( fp ) {
while ( fgets( buf, sizeof(buf), fp ) ) {
strtok( buf, "\n" );
key = buf;
value = strchr( buf, '=' );
if ( !value || *key == ';' || *key == '[' )
continue;
*value++ = 0;
trim( value );
for ( int i = 0; i < kNumElements; i++ ) {
if ( i != src && stricmp( key, elements[i] ) == 0 )
defdata[i] = strdup( value );
}
}
fclose( fp );
}
// the src url cannot be initialized from the ini file
defdata[src] = (char*) calloc( 1024, sizeof(char) );
assert( defdata[src] );
}
void disposeDefdata()
{
for ( int i = 0; i < kNumElements; i++ ) {
if ( defdata[i] )
free( defdata[i] );
}
}
////////////////////////////////////////////////////////////////////////////////
// path manglers
inline void ripslash( char* s )
{
int i;
if ( s[(i=strlen(s))-1] == '\\' )
s[i] = 0;
}
inline void makeSearchSpec( char* dirpath, char* out )
{
strcpy( out, dirpath );
ripslash( out );
strcat( out, "\\*" );
}
//
// this is pretty limited right now. it only handles relative paths that are
// at or below the current working directory, or fully qualified paths that
// begin with a drive specifier.
//
void getContentLocation( char* dirpath, char* out, int maxlen )
{
strcpy( out, "file://" );
// if dirpath is fully qualified, just use that
if ( dirpath[1] == ':' ) {
strcpy( out, dirpath );
}
else {
int dpLen = strlen( dirpath );
bool cwd = (*dirpath == '.') && (dpLen == 1);
// magic number is "file://" and one backslash
int maxwdlen = maxlen - (cwd ? 0 : dpLen) - 8;
if ( _getcwd( out+7, maxwdlen ) ) {
ripslash( out );
if ( !cwd ) {
strcat( out, "\\" );
strcat( out, dirpath );
ripslash( out );
}
}
else
*out = 0;
}
}
#define errmsg(s) (fputs( s"\n", stderr ))
int main( int argc, char* argv[] )
{
if ( argc < 2 ) {
errmsg( "plgen -- generate playlist from a collection of image files\n" );
errmsg( " usage: plgen <image path>" );
exit(-1);
}
else if ( argc > 2 ) {
if ( !freopen( argv[2], "w+", stdout ) ) {
fprintf( stderr, "Unable to create %s\n", argv[2] );
exit( -1 );
}
}
else if ( argc > 3 )
errmsg( "plgen -- ignoring additional arguements" );
int ret = -1;
int entries = 0;
long hFind;
bool fileFound;
char srchSpec[_MAX_PATH] = "";
char contentLoc[_MAX_PATH] = "";
struct _finddata_t fileInfo;
initDefdata();
makeSearchSpec( argv[1], srchSpec );
getContentLocation( argv[1], contentLoc, sizeof(contentLoc) );
if ( (hFind = _findfirst( srchSpec, &fileInfo )) != -1 ) {
// first two files are always directories, and we need to find at least
// one file to continue---currently don't do subdirs.
while ( _findnext( hFind, &fileInfo ) == 0 ) {
if ( fileFound = !(fileInfo.attrib & _A_SUBDIR) )
break;
}
if ( fileFound ) {
startElement( clientUpdateResponse, 0, true );
// write the clientInfo block
startElement( clientInfo, 0, true );
outputDataField( reqInterval );
endElement( clientInfo, true );
// the actual playlist starts here
startElement( playlist, 0, true );
outputDataField( playlistID );
do {
// make a full URL to our found file
sprintf( defdata[src], "%s\\%s", contentLoc, fileInfo.name );
startElement( entry, 0, true );
for ( int i = entryID; i < kNumElements; i++ )
outputDataField( i );
endElement( entry, true );
entries++;
} while ( _findnext( hFind, &fileInfo ) == 0 );
endElement( playlist, true );
endElement( clientUpdateResponse, true );
ret = 0;
}
else
errmsg( "plgen -- that directory ain't got a darn thing in it" );
_findclose( hFind );
}
else
errmsg( "plgen -- we don't like that image directory path" );
disposeDefdata();
fprintf( stderr, "%i playlist entries written\n", entries );
return ret;
}
| 21.839552 | 80 | 0.577311 | dusong7 |
491082493c7d0dd575b79f3c56de54fa622f773e | 628 | cpp | C++ | virtual_functions_sau.cpp | saurabhkakade21/Cpp-Practice-Code | ac5e77f1a53bb164f7b265e9291b3ca63a2a2f60 | [
"MIT"
] | null | null | null | virtual_functions_sau.cpp | saurabhkakade21/Cpp-Practice-Code | ac5e77f1a53bb164f7b265e9291b3ca63a2a2f60 | [
"MIT"
] | null | null | null | virtual_functions_sau.cpp | saurabhkakade21/Cpp-Practice-Code | ac5e77f1a53bb164f7b265e9291b3ca63a2a2f60 | [
"MIT"
] | null | null | null | #include <iostream>
#include "virtual_functions.h"
using namespace std;
void Account::withdraw(double amount) const
{
std::cout << "In Account class: Withdraw: " << std::endl;
}
void Checking::withdraw(double amount) const
{
std::cout << "In Checking class: Withdraw: " << std::endl;
}
Account :: ~Account()
{
cout << "Account destructor" << endl;
}
Checking :: ~Checking()
{
cout << "Checking destructor" << endl;
}
int main()
{
Account *p1 = new Account();
Account *p2 = new Checking();
p1->withdraw(1000);
p2->withdraw(2000);
delete p1;
delete p2;
return 0;
} | 16.526316 | 63 | 0.606688 | saurabhkakade21 |
4922604475aeddcd66aa72150aa7787262ad45eb | 4,909 | cpp | C++ | cpp-projects/exvr-designer/widgets/components/config_parameters/image_resource_pw.cpp | FlorianLance/exvr | 4d210780737479e9576c90e9c80391c958787f44 | [
"MIT"
] | null | null | null | cpp-projects/exvr-designer/widgets/components/config_parameters/image_resource_pw.cpp | FlorianLance/exvr | 4d210780737479e9576c90e9c80391c958787f44 | [
"MIT"
] | null | null | null | cpp-projects/exvr-designer/widgets/components/config_parameters/image_resource_pw.cpp | FlorianLance/exvr | 4d210780737479e9576c90e9c80391c958787f44 | [
"MIT"
] | null | null | null |
/***********************************************************************************
** exvr-designer **
** MIT License **
** Copyright (c) [2018] [Florian Lance][EPFL-LNCO] **
** 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 "image_resource_pw.hpp"
// local
#include "ex_widgets/ex_resources_list_w.hpp"
#include "ex_widgets/ex_line_edit_w.hpp"
#include "ex_widgets/ex_radio_button_w.hpp"
#include "ex_widgets/ex_spin_box_w.hpp"
#include "ex_widgets/ex_checkbox_w.hpp"
using namespace tool::ex;
struct ImageResourceInitConfigParametersW::Impl{
ExResourcesListW imagesList{"images_list"};
};
ImageResourceInitConfigParametersW::ImageResourceInitConfigParametersW() : ConfigParametersW(), m_p(std::make_unique<Impl>()){
}
void ImageResourceInitConfigParametersW::insert_widgets(){
add_widget(ui::F::gen(ui::L::VB(), {m_p->imagesList()}, LStretch{false}, LMargins{true}, QFrame::Box));
no_end_stretch();
}
void ImageResourceInitConfigParametersW::init_and_register_widgets(){
add_input_ui(m_p->imagesList.init_widget(Resource::Type::Image, "Images:"));
}
void ImageResourceInitConfigParametersW::create_connections(){
connect(&m_p->imagesList, &ExResourcesListW::ui_change_signal, this, [&]{
});
}
void ImageResourceInitConfigParametersW::late_update_ui(){}
struct ImageResourceConfigParametersW::Impl{
ExCheckBoxW startExp{"start_exp"};
ExCheckBoxW startRoutine{"start_routine"};
ExCheckBoxW stopRoutine{"stop_routine"};
QButtonGroup group1;
ExRadioButtonW sendAlias{"use_alias"};
ExRadioButtonW sendId{"use_id"};
ExLineEditW alias{"alias"};
ExSpinBoxW id{"id"};
};
ImageResourceConfigParametersW::ImageResourceConfigParametersW() : ConfigParametersW(), m_p(std::make_unique<Impl>()){
}
void ImageResourceConfigParametersW::insert_widgets(){
layout()->setContentsMargins(0,0,0,0);
add_widget(ui::F::gen(ui::L::VB(), {ui::W::txt("Send current image when:"), m_p->startExp(),m_p->startRoutine(),m_p->stopRoutine()}, LStretch{false}, LMargins{true}, QFrame::NoFrame));
add_widget(ui::F::gen(ui::L::HB(), {ui::W::txt("Using:"), m_p->sendAlias(),m_p->sendId()}, LStretch{true}, LMargins{true}, QFrame::NoFrame));
add_widget(ui::F::gen(ui::L::HB(), {ui::W::txt("From init config images resources list:")}, LStretch{true}, LMargins{true}, QFrame::NoFrame));
add_widget(ui::F::gen(ui::L::HB(), {ui::W::txt("Id"), m_p->id(), ui::W::txt("Alias"), m_p->alias()}, LStretch{false}, LMargins{true}, QFrame::NoFrame));
}
void ImageResourceConfigParametersW::init_and_register_widgets(){
add_input_ui(m_p->startExp.init_widget(" experiment starts", true));
add_input_ui(m_p->startRoutine.init_widget(" routine starts", true));
add_input_ui(m_p->stopRoutine.init_widget(" routine stops", true));
add_inputs_ui(
ExRadioButtonW::init_group_widgets(m_p->group1,
{&m_p->sendId, &m_p->sendAlias},
{
"id",
"alias",
},
{true,false}
));
add_input_ui(m_p->alias.init_widget(""));
add_input_ui(m_p->id.init_widget(MinV<int>{0}, V<int>{0}, MaxV<int>{10000}, StepV<int>{1}));
}
void ImageResourceConfigParametersW::create_connections(){
}
void ImageResourceConfigParametersW::late_update_ui(){
}
| 46.311321 | 188 | 0.6209 | FlorianLance |
49264aa1408b8a207f6b72118b7c3808be7ad7f9 | 4,650 | cc | C++ | src/GUI_language.cc | edrosten/gvars | 62f5a78025dd616483487c9069f6b7f16c57922f | [
"BSD-2-Clause"
] | 15 | 2015-01-27T10:49:32.000Z | 2019-02-17T20:41:06.000Z | src/GUI_language.cc | edrosten/gvars | 62f5a78025dd616483487c9069f6b7f16c57922f | [
"BSD-2-Clause"
] | 2 | 2016-07-13T01:13:32.000Z | 2020-08-18T07:48:26.000Z | src/GUI_language.cc | edrosten/gvars | 62f5a78025dd616483487c9069f6b7f16c57922f | [
"BSD-2-Clause"
] | 15 | 2015-02-25T03:28:45.000Z | 2022-01-05T12:25:51.000Z | /*
This file is part of the GVars3 Library.
Copyright (C) 2005 The Authors
This library is free software, see LICENSE file for details
*/
#include "gvars3/instances.h"
#include "gvars3/GStringUtil.h"
#include <vector>
#include <iostream>
#include <set>
#include <pthread.h>
using namespace std;
namespace GVars3
{
template<class C> class ThreadLocal
{
private:
pthread_key_t key;
static void deleter(void* v)
{
delete static_cast<C*>(v);
}
public:
ThreadLocal()
{
pthread_key_create(&key, deleter);
pthread_setspecific(key, new C);
}
~ThreadLocal()
{
deleter(pthread_getspecific(key));
pthread_setspecific(key, 0);
pthread_key_delete(key);
}
C& operator()()
{
return *static_cast<C*>(pthread_getspecific(key));
}
};
template<class A, class B> class MutexMap
{
private:
map<A, B> _map;
pthread_mutex_t mutex;
public:
MutexMap()
{
pthread_mutex_init(&mutex, 0);
}
~MutexMap()
{
pthread_mutex_destroy(&mutex);
}
B get(const A& a)
{
B b;
pthread_mutex_lock(&mutex);
b = _map[a];
pthread_mutex_unlock(&mutex);
return b;
}
void set(const A&a, const B& b)
{
pthread_mutex_lock(&mutex);
_map[a] = b;
pthread_mutex_unlock(&mutex);
}
};
class GUI_language
{
public:
GUI_language()
{
GUI.RegisterCommand(".", collect_lineCB, this);
GUI.RegisterCommand("function", functionCB, this);
GUI.RegisterCommand("endfunction", endfunctionCB, this);
GUI.RegisterCommand("if_equal", gui_if_equalCB, this);
GUI.RegisterCommand("else", gui_if_elseCB, this);
GUI.RegisterCommand("endif", gui_endifCB, this);
}
~GUI_language()
{
}
private:
pthread_mutex_t functionlist_mutex;
ThreadLocal<string> current_function, if_gvar, if_string;
ThreadLocal<vector<string> > collection, ifbit, elsebit;
MutexMap<string, vector<string> > functions;
static GUI_language& C(void* v)
{
return *static_cast<GUI_language*>(v);
}
#define CallBack(X) static void X##CB(void* t, string a, string b){C(t).X(a, b);}
CallBack(collect_line);
void collect_line(string, string l)
{
collection().push_back(l);
}
CallBack(function);
void function(string name, string args)
{
vector<string> vs = ChopAndUnquoteString(args);
if(vs.size() != 1)
{
cerr << "Error: " << name << " takes 1 argument: " << name << " name\n";
return;
}
current_function()=vs[0];
collection().clear();
}
CallBack(endfunction)
void endfunction(string name, string args)
{
if(current_function() == "")
{
cerr << "Error: " << name << ": no current function.\n";
return;
}
vector<string> vs = ChopAndUnquoteString(args);
if(vs.size() != 0)
cerr << "Warning: " << name << " takes 0 arguments.\n";
functions.set(current_function(), collection());
GUI.RegisterCommand(current_function(), runfuncCB, this);
current_function().clear();
collection().clear();
}
CallBack(runfunc)
void runfunc(string name, string /*args*/)
{
vector<string> v = functions.get(name);
for(unsigned int i=0; i < v.size(); i++)
GUI.ParseLine(v[i]);
}
CallBack(gui_if_equal)
void gui_if_equal(string name, string args)
{
vector<string> vs = ChopAndUnquoteString(args);
if(vs.size() != 2)
{
cerr << "Error: " << name << " takes 2 arguments: " << name << " gvar string\n";
return;
}
collection().clear();
if_gvar() = vs[0];
if_string() = vs[1];
}
CallBack(gui_if_else)
void gui_if_else(string /*name*/, string /*args*/)
{
ifbit() = collection();
if(ifbit().empty())
ifbit().push_back("");
collection().clear();
}
CallBack(gui_endif)
void gui_endif(string /*name*/, string /*args*/)
{
if(ifbit().empty())
ifbit() = collection();
else
elsebit() = collection();
collection().clear();
//Save a copy, since it canget trashed
vector<string> ib = ifbit(), eb = elsebit();
string gv = if_gvar(), st = if_string();
ifbit().clear();
elsebit().clear();
if_gvar().clear();
if_string().clear();
if(GV3::get_var(gv) == st)
for(unsigned int i=0; i < ib.size(); i++)
GUI.ParseLine(ib[i]);
else
for(unsigned int i=0; i < eb.size(); i++)
GUI.ParseLine(eb[i]);
}
};
GUI_language* get_new_lang()
{
return new GUI_language;
}
void remove_lang(GUI_language* l)
{
delete l;
}
//GUI_language GUI_language_instance;
}
| 19.294606 | 85 | 0.603226 | edrosten |
49277029a1c42eca60530c5336de2404ab50bdf4 | 956 | hpp | C++ | addons/niarms/caliber/556/m4.hpp | Theseus-Aegis/GTRecoilSystem | 308f260af7a2a8839d1f7a0b43d77d49c062ff6c | [
"MIT"
] | null | null | null | addons/niarms/caliber/556/m4.hpp | Theseus-Aegis/GTRecoilSystem | 308f260af7a2a8839d1f7a0b43d77d49c062ff6c | [
"MIT"
] | null | null | null | addons/niarms/caliber/556/m4.hpp | Theseus-Aegis/GTRecoilSystem | 308f260af7a2a8839d1f7a0b43d77d49c062ff6c | [
"MIT"
] | null | null | null | // M4 Variants Inherits (Some are broken with no barrel length at all.)
// AR15 Sanitised Carbine - Short Barrel
class hlc_rifle_RU556: hlc_ar15_base {
recoil = QCLASS(556_ShortBarrel);
};
// BCM 'Jack' Carbine - Medium Barrel
class hlc_rifle_bcmjack: hlc_ar15_base {
recoil = QCLASS(556_MediumBarrel);
};
// Colt M4A1 Carbine - Medium Barrel
class hlc_rifle_M4: hlc_ar15_base {
recoil = QCLASS(556_MediumBarrel);
};
// GL
class hlc_rifle_m4m203: hlc_rifle_M4 {
recoil = QCLASS(556_GL_Medium);
};
// Colt R0727 Carbine - Medium Barrel
class hlc_rifle_Colt727: hlc_ar15_base {
recoil = QCLASS(556_MediumBarrel);
};
// GL
class hlc_rifle_Colt727_GL: hlc_rifle_Colt727 {
recoil = QCLASS(556_GL_Medium);
};
// MK18 MOD 0 - Short Barrel
class hlc_rifle_mk18mod0: hlc_rifle_CQBR {
recoil = QCLASS(556_ShortBarrel);
};
// RRA LAR-15 AMR - Long Barrel
class hlc_rifle_SAMR: hlc_ar15_base {
recoil = QCLASS(556_LongBarrel);
};
| 23.9 | 71 | 0.733264 | Theseus-Aegis |
492b6a5354667eb85291c9137703773c80e1b941 | 649 | cpp | C++ | include/hydro/parser/__ast/VarDecl.cpp | hydraate/hydro | 42037a8278dcfdca68fb5cceaf6988da861f0eff | [
"Apache-2.0"
] | null | null | null | include/hydro/parser/__ast/VarDecl.cpp | hydraate/hydro | 42037a8278dcfdca68fb5cceaf6988da861f0eff | [
"Apache-2.0"
] | null | null | null | include/hydro/parser/__ast/VarDecl.cpp | hydraate/hydro | 42037a8278dcfdca68fb5cceaf6988da861f0eff | [
"Apache-2.0"
] | null | null | null | //
// __ __ __
// / / / /__ __ ____/ /_____ ____
// / /_/ // / / // __ // ___// __ \
// / __ // /_/ // /_/ // / / /_/ /
// /_/ /_/ \__, / \__,_//_/ \____/
// /____/
//
// The Hydro Programming Language
//
#include "VarDecl.hpp"
namespace hydro
{
VarDecl::VarDecl(lex_token token, ast_mod mods, ast_name name, ast_htype type, ast_expr defaultValue, Symbol *symbol) : Decl{token, mods, name, symbol}, _type{type}, _defaultValue(defaultValue) {}
VarDecl::~VarDecl() {}
} // namespace hydro
| 29.5 | 196 | 0.448382 | hydraate |
4934662d731fa57f4a638f3f7a1abf1216a2a8d7 | 4,267 | cpp | C++ | tools/apf_tools/FieldConverter.cpp | schuetzepaul/allpix-squared | 737eba52fe13f56134c4e88a7928d1a5103dd40a | [
"MIT"
] | 3 | 2019-03-04T22:31:32.000Z | 2021-04-20T11:19:17.000Z | tools/apf_tools/FieldConverter.cpp | schuetzepaul/allpix-squared | 737eba52fe13f56134c4e88a7928d1a5103dd40a | [
"MIT"
] | 27 | 2019-04-01T12:25:46.000Z | 2021-09-03T12:20:19.000Z | tools/apf_tools/FieldConverter.cpp | schuetzepaul/allpix-squared | 737eba52fe13f56134c4e88a7928d1a5103dd40a | [
"MIT"
] | 15 | 2017-08-08T14:57:51.000Z | 2021-06-26T17:16:21.000Z | /**
* @file
* @brief Small converter for field data INIT <-> APF
*/
#include <algorithm>
#include <fstream>
#include <string>
#include "core/utils/log.h"
#include "tools/field_parser.h"
#include "tools/units.h"
using namespace allpix;
/**
* @brief Main function running the application
*/
int main(int argc, const char* argv[]) {
int return_code = 0;
try {
// Register the default set of units with this executable:
register_units();
// Add cout as the default logging stream
Log::addStream(std::cout);
// If no arguments are provided, print the help:
bool print_help = false;
if(argc == 1) {
print_help = true;
return_code = 1;
}
// Parse arguments
FileType format_to = FileType::UNKNOWN;
std::string file_input;
std::string file_output;
std::string units;
bool scalar = false;
for(int i = 1; i < argc; i++) {
if(strcmp(argv[i], "-h") == 0) {
print_help = true;
} else if(strcmp(argv[i], "-v") == 0 && (i + 1 < argc)) {
try {
LogLevel log_level = Log::getLevelFromString(std::string(argv[++i]));
Log::setReportingLevel(log_level);
} catch(std::invalid_argument& e) {
LOG(ERROR) << "Invalid verbosity level \"" << std::string(argv[i]) << "\", ignoring overwrite";
}
} else if(strcmp(argv[i], "--to") == 0 && (i + 1 < argc)) {
std::string format = std::string(argv[++i]);
std::transform(format.begin(), format.end(), format.begin(), ::tolower);
format_to = (format == "init" ? FileType::INIT : format == "apf" ? FileType::APF : FileType::UNKNOWN);
} else if(strcmp(argv[i], "--input") == 0 && (i + 1 < argc)) {
file_input = std::string(argv[++i]);
} else if(strcmp(argv[i], "--output") == 0 && (i + 1 < argc)) {
file_output = std::string(argv[++i]);
} else if(strcmp(argv[i], "--units") == 0 && (i + 1 < argc)) {
units = std::string(argv[++i]);
} else if(strcmp(argv[i], "--scalar") == 0) {
scalar = true;
} else {
LOG(ERROR) << "Unrecognized command line argument \"" << argv[i] << "\"";
print_help = true;
return_code = 1;
}
}
// Print help if requested or no arguments given
if(print_help) {
std::cout << "Allpix Squared Field Converter Tool" << std::endl;
std::cout << std::endl;
std::cout << "Usage: field_converter <parameters>" << std::endl;
std::cout << std::endl;
std::cout << "Parameters (all mandatory):" << std::endl;
std::cout << " --to <format> file format of the output file" << std::endl;
std::cout << " --input <file> input field file" << std::endl;
std::cout << " --output <file> output field file" << std::endl;
std::cout << " --units <units> units the field is provided in" << std::endl << std::endl;
std::cout << "Options:" << std::endl;
std::cout << " --scalar Convert scalar field. Default is vector field" << std::endl;
std::cout << std::endl;
std::cout << "For more help, please see <https://cern.ch/allpix-squared>" << std::endl;
return return_code;
}
FieldQuantity quantity = (scalar ? FieldQuantity::SCALAR : FieldQuantity::VECTOR);
FieldParser<double> field_parser(quantity);
LOG(STATUS) << "Reading input file from " << file_input;
auto field_data = field_parser.getByFileName(file_input, units);
FieldWriter<double> field_writer(quantity);
LOG(STATUS) << "Writing output file to " << file_output;
field_writer.writeFile(field_data, file_output, format_to, (format_to == FileType::INIT ? units : ""));
} catch(std::exception& e) {
LOG(FATAL) << "Fatal internal error" << std::endl << e.what() << std::endl << "Cannot continue.";
return_code = 127;
}
return return_code;
}
| 40.638095 | 118 | 0.525428 | schuetzepaul |
4937b18a69ca34d4cdd487b596ac767fe7e0e319 | 5,308 | cpp | C++ | example/net/pingpong/main.cpp | zizzzw/fflib | ba9b465347b650d86c34876fbfae48bc31194d97 | [
"MIT"
] | 1 | 2022-02-08T07:28:07.000Z | 2022-02-08T07:28:07.000Z | example/net/pingpong/main.cpp | zizzzw/fflib | ba9b465347b650d86c34876fbfae48bc31194d97 | [
"MIT"
] | null | null | null | example/net/pingpong/main.cpp | zizzzw/fflib | ba9b465347b650d86c34876fbfae48bc31194d97 | [
"MIT"
] | 2 | 2022-01-06T02:16:09.000Z | 2022-01-19T12:49:54.000Z | /***********************************************
The MIT License (MIT)
Copyright (c) 2012 Athrun Arthur <[email protected]>
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 "ff/network.h"
#include <chrono>
#include <iostream>
define_nt(msg, std::string);
define_nt(uid, uint64_t, "uid");
typedef ff::net::ntpackage<110, msg, uid> ping_msg;
typedef ff::net::ntpackage<111, msg, uid> pong_msg;
class client : public ff::net::routine {
public:
client() : ff::net::routine("client") {}
virtual void initialize(ff::net::net_mode nm,
const std::vector<std::string> &args) {
pkghub.tcp_to_recv_pkg<pong_msg>(std::bind(&client::onRecvPong, this,
std::placeholders::_1,
std::placeholders::_2));
pnn = new ff::net::net_nervure(nm);
pnn->add_pkg_hub(pkghub);
pnn->add_tcp_client("127.0.0.1", 6891);
pnn->get_event_handler()->listen<ff::net::event::tcp_get_connection>(
std::bind(&client::onConnSucc, this, std::placeholders::_1));
pnn->get_event_handler()->listen<ff::net::event::tcp_lost_connection>(
std::bind(&client::onLostConn, this, std::placeholders::_1, pnn));
}
virtual void run() { pnn->run(); }
protected:
void sendPingMsg(ff::net::tcp_connection_base *pConn) {
char *pContent = new char[16];
const char *str = "ping world!";
std::memcpy(pContent, str, std::strlen(str) + 1);
std::shared_ptr<ping_msg> pMsg(new ping_msg());
pMsg->template set<msg, uid>(std::string("ping world"), 1);
pConn->send(pMsg);
ff::net::mout << "service running..." << std::endl;
}
void onRecvPong(std::shared_ptr<pong_msg> pPong,
ff::net::tcp_connection_base *from) {
// pong_msg &msg = *pPong.get();
ff::net::mout << "got pong!" << pPong->template get<msg>() << ", "
<< pPong->template get<uid>() << std::endl;
sendPingMsg(from);
}
void onConnSucc(ff::net::tcp_connection_base *pConn) {
ff::net::mout << "connect success" << std::endl;
sendPingMsg(pConn);
}
void onLostConn(ff::net::tcp_connection_base *pConn,
ff::net::net_nervure *pbn) {
ff::net::mout << "Server lost!" << std::endl;
pbn->stop();
}
protected:
ff::net::typed_pkg_hub pkghub;
ff::net::net_nervure *pnn;
};
class server : public ff::net::routine {
public:
server() : ff::net::routine("server") {}
virtual void initialize(ff::net::net_mode nm,
const std::vector<std::string> &args) {
pkghub.tcp_to_recv_pkg<ping_msg>(std::bind(&server::onRecvPing, this,
std::placeholders::_1,
std::placeholders::_2));
pnn = new ff::net::net_nervure(nm);
pnn->add_pkg_hub(pkghub);
pnn->add_tcp_server("127.0.0.1", 6891);
pnn->get_event_handler()->listen<ff::net::event::tcp_lost_connection>(
std::bind(&server::onLostTCPConnection, this, std::placeholders::_1));
}
virtual void run() {
std::thread monitor_thrd(std::bind(&server::press_and_stop, this));
pnn->run();
monitor_thrd.join();
}
protected:
void onRecvPing(std::shared_ptr<ping_msg> pPing,
ff::net::tcp_connection_base *from) {
// pPing->print();
auto ping_uid = pPing->template get<uid>();
std::this_thread::sleep_for(std::chrono::seconds(1));
std::shared_ptr<pong_msg> pkg(new pong_msg());
pkg->template set<uid>(ping_uid + 1);
pkg->template set<msg>(pPing->template get<msg>());
from->send(pkg);
}
void onLostTCPConnection(ff::net::tcp_connection_base *pConn) {
ff::net::mout << "lost connection!" << std::endl;
}
void press_and_stop() {
ff::net::mout << "Press any key to quit..." << std::endl;
std::cin.get();
pnn->stop();
ff::net::mout << "Stopping, please wait..." << std::endl;
}
protected:
ff::net::typed_pkg_hub pkghub;
ff::net::net_nervure *pnn;
};
int main(int argc, char *argv[]) {
ff::net::application app("pingpong");
app.initialize(argc, argv);
client c;
server s;
app.register_routine(&c);
app.register_routine(&s);
app.run();
return 0;
}
| 33.808917 | 79 | 0.625283 | zizzzw |
4937e32fa2051008dd83b908374d158619aa19b4 | 463 | cpp | C++ | Class 11/44.cpp | AniMysore74/Computer-Class | 4764603b51cebfd99ac3c7a4968c9672e7b27526 | [
"Apache-2.0"
] | null | null | null | Class 11/44.cpp | AniMysore74/Computer-Class | 4764603b51cebfd99ac3c7a4968c9672e7b27526 | [
"Apache-2.0"
] | null | null | null | Class 11/44.cpp | AniMysore74/Computer-Class | 4764603b51cebfd99ac3c7a4968c9672e7b27526 | [
"Apache-2.0"
] | null | null | null | //Read two strings and copy the shorter string into the bigger string
#include<iostream.h>
#include<conio.h>
#include<string.h>
int main()
{
char str1[30],str2[30];
cout<<"Enter string 1 : ";
cin>>str1;
cout<<"Enter string 2 : ";
cin>>str2;
if(strlen(str1)>strlen(str2))
strcpy(str2,str1);
else
strcpy(str1,str2);
cout<<"The value of the strings now are: \n"<<"String 1 : "<<str1<<"\nString 2 : "<<str2;
getch();
return 0;
}
| 23.15 | 97 | 0.62203 | AniMysore74 |
493cba69db4dd39e04d0e0ecda6753a61bd40570 | 20,992 | cpp | C++ | src/read.cpp | johelegp/tmxpp | efbd52e575fb8cd8fcfebd274b379f11fc036637 | [
"Unlicense"
] | null | null | null | src/read.cpp | johelegp/tmxpp | efbd52e575fb8cd8fcfebd274b379f11fc036637 | [
"Unlicense"
] | null | null | null | src/read.cpp | johelegp/tmxpp | efbd52e575fb8cd8fcfebd274b379f11fc036637 | [
"Unlicense"
] | 1 | 2018-03-12T02:32:46.000Z | 2018-03-12T02:32:46.000Z | #include <optional>
#include <string>
#include <utility>
#include <tmxpp.hpp>
#include <tmxpp/Constrained.hpp>
#include <tmxpp/exceptions.hpp>
#include <tmxpp/impl/Xml.hpp>
#include <tmxpp/impl/exceptions.hpp>
#include <tmxpp/impl/read_utility.hpp>
#include <tmxpp/impl/tmx_info.hpp>
#include <tmxpp/impl/to_color.hpp>
#include <tmxpp/impl/to_data_flipped_id.hpp>
#include <tmxpp/impl/to_point.hpp>
namespace tmxpp {
namespace impl {
namespace {
using namespace tmx_info;
iSize read_isize(Xml::Element element)
{
return {from_string<iSize::Dimension>(value(element, size_width)),
from_string<iSize::Dimension>(value(element, size_height))};
}
std::optional<pxSize> read_optional_size(Xml::Element element)
{
auto w{optional_value(element, size_width)};
auto h{optional_value(element, size_height)};
if (bool{w} != bool{h})
throw Exception{"Expected both " + std::string{get(size_width)} +
" and " + std::string{get(size_height)} + ", or none."};
if (!w)
return {};
return pxSize{from_string<pxSize::Dimension>(*w),
from_string<pxSize::Dimension>(*h)};
}
pxSize read_tile_size(Xml::Element element)
{
return {from_string<pxSize::Dimension>(value(element, tile_size_width)),
from_string<pxSize::Dimension>(value(element, tile_size_height))};
}
namespace properties {
Property::Value read_value(Xml::Element property)
{
auto value{optional_value(property, property_value)};
if (!value)
return std::string{get(property.value())};
auto alternative{optional_value(property, property_alternative)};
if (!alternative || *alternative == property_alternative_string)
return std::string{get(*value)};
if (*alternative == property_alternative_int)
return from_string<int>(*value);
if (*alternative == property_alternative_double)
return from_string<double>(*value);
if (*alternative == property_alternative_bool) {
if (*value == property_value_true)
return true;
if (*value == property_value_false)
return false;
throw Exception{"Bad property bool value: " + std::string{get(*value)}};
}
if (*alternative == property_alternative_color)
return to_color(*value);
if (*alternative == property_alternative_file)
return File{get(*value)};
throw Invalid_attribute{property_alternative, *alternative};
}
Non_empty<std::string> read_name(Xml::Element property)
{
return Non_empty<std::string>{
std::string{get(value(property, property_name))}};
}
Property read_property(Xml::Element property)
{
return {read_name(property), read_value(property)};
}
Properties read_properties(Xml::Element element)
{
auto properties{element.optional_child(tmx_info::properties)};
if (!properties)
return {};
return transform<Properties>(properties->children(property), read_property);
}
} // namespace properties
using properties::read_properties;
namespace image {
File read_source(Xml::Element image)
{
return get(value(image, image_source));
}
std::optional<Color> read_transparent(Xml::Element image)
{
if (auto color{optional_value(image, image_transparent)})
return to_color(*color);
return {};
}
Image read_image(Xml::Element image)
{
return {read_source(image), read_transparent(image),
read_optional_size(image)};
}
} // namespace image
using image::read_image;
namespace animation {
Local_tile_id read_id(Xml::Element frame)
{
return from_string<Local_tile_id>(value(frame, frame_id));
}
Non_negative<Frame::Duration> read_duration(Xml::Element frame)
{
return Non_negative<Frame::Duration>{Frame::Duration{
from_string<Frame::Duration::rep>(value(frame, frame_duration))}};
}
Frame read_frame(Xml::Element frame)
{
return {read_id(frame), read_duration(frame)};
}
Animation read_animation(Xml::Element tile)
{
auto animation{tile.optional_child(tmx_info::animation)};
if (!animation)
return {};
return transform<Animation>(animation->children(frame), read_frame);
}
} // namespace animation
using animation::read_animation;
namespace object_layer {
Object_layer read_object_layer(Xml::Element object_layer);
} // namespace object_layer
using object_layer::read_object_layer;
namespace tile_set {
Global_tile_id read_first_id(Xml::Element tile_set)
{
return from_string<Global_tile_id>(value(tile_set, tile_set_first_id));
}
File read_tsx(Xml::Element tile_set)
{
if (auto tsx{optional_value(tile_set, tile_set_tsx)})
return get(*tsx);
return {};
}
std::string read_name(Xml::Element tile_set)
{
if (auto name{optional_value(tile_set, tile_set_name)})
return std::string{get(*name)};
return {};
}
Non_negative<int> read_tile_count(Xml::Element tile_set)
{
return Non_negative<int>{
from_string<int>(value(tile_set, tile_set_tile_count))};
}
Non_negative<int> read_columns(Xml::Element tile_set)
{
return Non_negative<int>{
from_string<int>(value(tile_set, tile_set_columns))};
}
Offset read_tile_offset(Xml::Element tile_set)
{
auto tile_offset{tile_set.optional_child(tmx_info::tile_offset)};
if (!tile_offset)
return {};
return {from_string<Pixels>(value(*tile_offset, tile_offset_x)),
from_string<Pixels>(value(*tile_offset, tile_offset_y))};
}
Local_tile_id read_tile_id(Xml::Element tile)
{
return from_string<Local_tile_id>(value(tile, tile_set_tile_id));
}
std::optional<Object_layer> read_tile_collision_shape(Xml::Element tile)
{
if (auto collision_shape{tile.optional_child(tmx_info::object_layer)})
return read_object_layer(*collision_shape);
return {};
}
namespace tile_set {
Non_negative<Pixels> read_spacing(Xml::Element tile_set)
{
auto spacing{optional_value(tile_set, tile_set_spacing)};
return Non_negative<Pixels>{spacing ? from_string<Pixels>(*spacing)
: Pixels{}};
}
Non_negative<Pixels> read_margin(Xml::Element tile_set)
{
auto margin{optional_value(tile_set, tile_set_margin)};
return Non_negative<Pixels>{margin ? from_string<Pixels>(*margin)
: Pixels{}};
}
iSize read_size(Xml::Element tile_set)
{
auto tile_count{*read_tile_count(tile_set)};
auto columns{*read_columns(tile_set)};
if (columns == 0)
throw Exception{"Invalid tile set columns value: 0"};
return {iSize::Dimension{columns}, iSize::Dimension{tile_count / columns}};
}
Tile_set::Tile read_tile(Xml::Element tile)
{
return {read_tile_id(tile), read_properties(tile),
read_tile_collision_shape(tile), read_animation(tile)};
}
Tile_set::Tiles read_tiles(Xml::Element tile_set)
{
return transform<Tile_set::Tiles>(
tile_set.children(tile_set_tile), read_tile);
}
Tile_set read_tile_set(Xml::Element tile_set, Global_tile_id first_id, File tsx)
{
return {first_id,
std::move(tsx),
read_name(tile_set),
read_tile_size(tile_set),
read_spacing(tile_set),
read_margin(tile_set),
read_size(tile_set),
read_tile_offset(tile_set),
read_properties(tile_set),
read_image(tile_set.child(tmx_info::image)),
read_tiles(tile_set)};
}
} // namespace tile_set
namespace image_collection {
Image_collection::Tile read_tile(Xml::Element tile)
{
return {read_tile_id(tile), read_properties(tile),
read_image(tile.child(tmx_info::image)),
read_tile_collision_shape(tile), read_animation(tile)};
}
Image_collection::Tiles read_tiles(Xml::Element image_collection)
{
return transform<Image_collection::Tiles>(
image_collection.children(tile_set_tile), read_tile);
}
Image_collection read_image_collection(
Xml::Element image_collection, Global_tile_id first_id, File tsx)
{
return {first_id,
std::move(tsx),
read_name(image_collection),
read_tile_size(image_collection),
read_tile_count(image_collection),
read_columns(image_collection),
read_tile_offset(image_collection),
read_properties(image_collection),
read_tiles(image_collection)};
}
} // namespace image_collection
// Requires: The tile set is internal or a TSX.
// Returns: `true` if the `Element` represents a `Tile_set`, and `false` if it
// represents an `Image_collection`.
bool is_tile_set(Xml::Element tile_set)
{
return bool{tile_set.optional_child(tmx_info::image)};
}
Map::Tile_set read_map_tile_set(
Xml::Element tile_set, const std::experimental::filesystem::path& tsx_base)
{
auto first_id{read_first_id(tile_set)};
auto tsx{read_tsx(tile_set)};
if (tsx.empty()) {
if (is_tile_set(tile_set))
return tile_set::read_tile_set(tile_set, first_id, tsx);
return image_collection::read_image_collection(tile_set, first_id, tsx);
}
return read_tsx(first_id, std::move(tsx), tsx_base);
}
} // namespace tile_set
using tile_set::tile_set::read_tile_set;
using tile_set::image_collection::read_image_collection;
using tile_set::read_map_tile_set;
namespace data {
Data::Encoding read_encoding(Xml::Element data)
{
auto encoding{value(data, data_encoding)};
if (encoding == data_encoding_csv)
return Data::Encoding::csv;
if (encoding == data_encoding_base64)
return Data::Encoding::base64;
throw Invalid_attribute{data_encoding, encoding};
}
Data::Compression read_compression(Xml::Element data)
{
auto compression{optional_value(data, data_compression)};
if (!compression)
return Data::Compression::none;
if (*compression == data_compression_zlib)
return Data::Compression::zlib;
throw Invalid_attribute{data_compression, *compression};
}
Data::Format read_format(Xml::Element data)
{
return {read_encoding(data), read_compression(data)};
}
Data::Flipped_ids read_ids(Data::Format format, Xml::Element::Value data)
{
if (format != Data::Encoding::csv)
throw Exception{"Can only handle csv-encoded data."};
return transform<Data::Flipped_ids>(
tokenize(get(data), ",\n"), to_data_flipped_id);
}
Data read_data(Xml::Element data)
{
auto format{read_format(data)};
return {format, read_ids(format, data.value())};
}
} // namespace data
using data::read_data;
namespace layer {
std::string read_name(Xml::Element layer)
{
if (auto name{optional_value(layer, layer_name)})
return std::string{get(*name)};
return {};
}
Unit_interval read_opacity(Xml::Element layer)
{
if (auto opacity{optional_value(layer, layer_opacity)})
return from_string<Unit_interval>(*opacity);
return Unit_interval{1};
}
bool read_visible(Xml::Element layer)
{
if (auto visible{optional_value(layer, layer_visible)})
return from_string<bool>(*visible);
return true;
}
Offset read_offset(Xml::Element layer)
{
auto x{optional_value(layer, offset_x)};
auto y{optional_value(layer, offset_y)};
return {x ? from_string<Pixels>(*x) : Pixels{0},
y ? from_string<Pixels>(*y) : Pixels{0}};
}
Layer read_layer(Xml::Element layer)
{
return {read_name(layer), read_opacity(layer), read_visible(layer),
read_offset(layer), read_properties(layer)};
}
} // namespace layer
using layer::read_layer;
namespace tile_layer {
Tile_layer read_tile_layer(Xml::Element tile_layer)
{
return {read_layer(tile_layer), read_isize(tile_layer),
read_data(tile_layer.child(tmx_info::data))};
}
} // namespace tile_layer
using tile_layer::read_tile_layer;
namespace object {
Unique_id read_unique_id(Xml::Element object)
{
return from_string<Unique_id>(value(object, object_unique_id));
}
std::string read_name(Xml::Element object)
{
if (auto name{optional_value(object, object_name)})
return std::string{get(*name)};
return {};
}
std::string read_type(Xml::Element object)
{
if (auto type{optional_value(object, object_type)})
return std::string{get(*type)};
return {};
}
Point read_position(Xml::Element object)
{
return {from_string<Point::Coordinate>(value(object, point_x)),
from_string<Point::Coordinate>(value(object, point_y))};
}
Object::Polygon::Points read_points(Xml::Element poly)
{
return transform<Object::Polygon::Points>(
tokenize(get(value(poly, object_polygon_points)), " "), to_point);
}
std::optional<Object::Shape> read_shape(Xml::Element object)
{
if (auto polyline{object.optional_child(object_polyline)})
return Object::Polyline{read_points(*polyline)};
if (auto polygon{object.optional_child(object_polygon)})
return Object::Polygon{read_points(*polygon)};
auto size{read_optional_size(object)};
if (!size)
return {};
if (object.optional_child(object_ellipse))
return Object::Ellipse{*size};
return Object::Rectangle{*size};
}
Degrees read_clockwise_rotation(Xml::Element object)
{
if (auto rotation{optional_value(object, object_clockwise_rotation)})
return from_string<Degrees>(*rotation);
return {};
}
std::optional<Global_tile_id> read_global_id(Xml::Element object)
{
if (auto global_id{optional_value(object, object_global_id)})
return from_string<Global_tile_id>(*global_id);
return {};
}
bool read_visible(Xml::Element object)
{
return layer::read_visible(object);
}
Object read_object(Xml::Element object)
{
return {read_unique_id(object), read_name(object),
read_type(object), read_position(object),
read_shape(object), read_clockwise_rotation(object),
read_global_id(object), read_visible(object),
read_properties(object)};
}
} // namespace object
using object::read_object;
namespace object_layer {
std::optional<Color> read_color(Xml::Element object_layer)
{
if (auto color{optional_value(object_layer, object_layer_color)})
return to_color(*color);
return {};
}
Object_layer::Draw_order read_draw_order(Xml::Element object_layer)
{
auto draw_order{optional_value(object_layer, object_layer_draw_order)};
if (!draw_order || *draw_order == object_layer_draw_order_top_down)
return Object_layer::Draw_order::top_down;
if (*draw_order == object_layer_draw_order_index)
return Object_layer::Draw_order::index;
throw Invalid_attribute{object_layer_draw_order, *draw_order};
}
Object_layer::Objects read_objects(Xml::Element object_layer)
{
return transform<Object_layer::Objects>(
object_layer.children(tmx_info::object), read_object);
}
Object_layer read_object_layer(Xml::Element object_layer)
{
return {read_layer(object_layer), read_color(object_layer),
read_draw_order(object_layer), read_objects(object_layer)};
}
} // namespace object_layer
namespace image_layer {
std::optional<Image> read_image(Xml::Element image_layer)
{
if (auto image{image_layer.optional_child(tmx_info::image)})
return impl::read_image(*image);
return {};
}
Image_layer read_image_layer(Xml::Element image_layer)
{
return {read_layer(image_layer), read_image(image_layer)};
}
} // namespace image_layer
using image_layer::read_image_layer;
namespace map {
std::string read_version(Xml::Element map)
{
return std::string{get(value(map, map_version))};
}
Map::Staggered::Axis read_axis(Xml::Element map)
{
auto axis{value(map, map_staggered_axis)};
if (axis == map_staggered_axis_x)
return Map::Staggered::Axis::x;
if (axis == map_staggered_axis_y)
return Map::Staggered::Axis::y;
throw Invalid_attribute{map_staggered_axis, axis};
}
Map::Staggered::Index read_index(Xml::Element map)
{
auto index{value(map, map_staggered_index)};
if (index == map_staggered_index_even)
return Map::Staggered::Index::even;
if (index == map_staggered_index_odd)
return Map::Staggered::Index::odd;
throw Invalid_attribute{map_staggered_index, index};
}
Pixels read_side_length(Xml::Element map)
{
return from_string<Pixels>(value(map, map_hexagonal_side_legth));
}
Map::Orientation read_orientation(Xml::Element map)
{
auto orientation{value(map, map_orientation)};
if (orientation == map_orthogonal)
return Map::Orthogonal{};
if (orientation == map_isometric)
return Map::Isometric{};
if (orientation == map_staggered)
return Map::Staggered{read_axis(map), read_index(map)};
if (orientation == map_hexagonal)
return Map::Hexagonal{read_axis(map), read_index(map),
read_side_length(map)};
throw Invalid_attribute{map_orientation, orientation};
}
Map::Render_order read_render_order(Xml::Element map)
{
auto render_order{optional_value(map, map_render_order)};
if (!render_order || *render_order == map_render_order_right_down)
return Map::Render_order::right_down;
if (*render_order == map_render_order_right_up)
return Map::Render_order::right_up;
if (*render_order == map_render_order_left_down)
return Map::Render_order::left_down;
if (*render_order == map_render_order_left_up)
return Map::Render_order::left_up;
throw Invalid_attribute{map_render_order, *render_order};
}
std::optional<Color> read_background(Xml::Element map)
{
if (auto color{optional_value(map, map_background)})
return to_color(*color);
return {};
}
Unique_id read_next_id(Xml::Element map)
{
return from_string<Unique_id>(value(map, map_next_id));
}
Map::Tile_sets read_tile_sets(
Xml::Element map, const std::experimental::filesystem::path& tsx_base)
{
return transform<Map::Tile_sets>(
map.children(tmx_info::tile_set), [&](Xml::Element tile_set) {
return read_map_tile_set(tile_set, tsx_base);
});
}
Map::Layer read_layer(Xml::Element layer)
{
auto name{layer.name()};
if (name == tmx_info::tile_layer)
return read_tile_layer(layer);
if (name == tmx_info::object_layer)
return read_object_layer(layer);
if (name == tmx_info::image_layer)
return read_image_layer(layer);
throw Invalid_element{name};
}
Map::Layers read_layers(Xml::Element map)
{
return transform<Map::Layers>(
children(
map, {tmx_info::tile_layer, tmx_info::object_layer,
tmx_info::image_layer}),
read_layer);
}
Map read_map(
Xml::Element map, const std::experimental::filesystem::path& tsx_base)
{
return {
read_version(map), read_orientation(map), read_render_order(map),
read_isize(map), read_tile_size(map), read_background(map),
read_next_id(map), read_properties(map), read_tile_sets(map, tsx_base),
read_layers(map)};
}
} // namespace map
using map::read_map;
} // namespace
} // namespace impl
Map read_tmx(const std::experimental::filesystem::path& path) try {
const impl::Xml tmx{path.string().c_str()};
auto map{tmx.root()};
if (map.name() == impl::tmx_info::map)
return impl::read_map(map, path.parent_path());
throw impl::Invalid_element{map.name()};
}
catch (const Invalid_argument& e) {
throw Exception{e.what()};
}
Map::Tile_set read_tsx(
Global_tile_id first_id, File tsx,
const std::experimental::filesystem::path& base) try {
const impl::Xml xml{absolute(tsx, base).string().c_str()};
auto tile_set{xml.root()};
if (tile_set.name() != impl::tmx_info::tile_set)
throw impl::Invalid_element{tile_set.name()};
if (impl::tile_set::is_tile_set(tile_set))
return impl::read_tile_set(tile_set, first_id, std::move(tsx));
return impl::read_image_collection(tile_set, first_id, std::move(tsx));
}
catch (const Invalid_argument& e) {
throw Exception{e.what()};
}
Tile_set read_tile_set(
Global_tile_id first_id, File tsx,
const std::experimental::filesystem::path& base) try {
const impl::Xml xml{absolute(tsx, base).string().c_str()};
auto tile_set{xml.root()};
if (tile_set.name() == impl::tmx_info::tile_set)
return impl::read_tile_set(tile_set, first_id, std::move(tsx));
throw impl::Invalid_element{tile_set.name()};
}
catch (const Invalid_argument& e) {
throw Exception{e.what()};
}
Image_collection read_image_collection(
Global_tile_id first_id, File tsx,
const std::experimental::filesystem::path& base) try {
const impl::Xml xml{absolute(tsx, base).string().c_str()};
auto image_collection{xml.root()};
if (image_collection.name() == impl::tmx_info::tile_set)
return impl::read_image_collection(
image_collection, first_id, std::move(tsx));
throw impl::Invalid_element{image_collection.name()};
}
catch (const Invalid_argument& e) {
throw Exception{e.what()};
}
} // namespace tmxpp
| 26.878361 | 80 | 0.696361 | johelegp |
493e58662abd643a58435769c9eeb6a94210dd76 | 1,825 | hpp | C++ | sprig/checksum_hasher.hpp | bolero-MURAKAMI/Sprig | 51ce4db4f4d093dee659a136f47249e4fe91fc7a | [
"BSL-1.0"
] | 2 | 2017-10-24T13:56:24.000Z | 2018-09-28T13:21:22.000Z | sprig/checksum_hasher.hpp | bolero-MURAKAMI/Sprig | 51ce4db4f4d093dee659a136f47249e4fe91fc7a | [
"BSL-1.0"
] | null | null | null | sprig/checksum_hasher.hpp | bolero-MURAKAMI/Sprig | 51ce4db4f4d093dee659a136f47249e4fe91fc7a | [
"BSL-1.0"
] | 2 | 2016-04-12T03:26:06.000Z | 2018-09-28T13:21:22.000Z | /*=============================================================================
Copyright (c) 2010-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprig
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPRIG_CHECKSUM_HASHER_HPP
#define SPRIG_CHECKSUM_HASHER_HPP
#include <sprig/config/config.hpp>
#ifdef SPRIG_USING_PRAGMA_ONCE
# pragma once
#endif // #ifdef SPRIG_USING_PRAGMA_ONCE
#include <cstddef>
#include <boost/range.hpp>
#include <boost/foreach.hpp>
namespace sprig {
//
// checksum_hasher
//
template<typename Checksum, std::size_t BlockSize = 64>
class checksum_hasher {
public:
typedef Checksum checksum_type;
typedef std::size_t size_type;
typedef typename checksum_type::value_type value_type;
public:
static size_type const block_size = BlockSize;
public:
template<typename Pointer>
static value_type calculate_block(Pointer first, Pointer last) {
checksum_type checksum;
checksum.process_block(first, last);
return checksum.checksum();
}
template<typename Pointer>
static value_type calculate_bytes(Pointer data, size_type size) {
checksum_type checksum;
checksum.process_bytes(data, size);
return checksum.checksum();
}
template<typename Range>
static value_type calculate(Range const& range) {
checksum_type checksum;
BOOST_FOREACH(typename boost::range_value<Range>::type e, range) {
checksum.process_byte(e);
}
return checksum.checksum();
}
public:
template<typename Range>
value_type operator()(Range const& range) const {
return calculate(range);
}
};
} // namespace sprig
#endif // #ifndef SPRIG_CHECKSUM_HASHER_HPP
| 28.968254 | 79 | 0.691507 | bolero-MURAKAMI |
494a570c53b95b59524070539d9382776ee25c9e | 33,440 | cpp | C++ | src/modules/SD2/scripts/kalimdor/silithus.cpp | muscnx/Mangos021SD2 | 695bb6a4822bb9173ab8e9077cb6259869ca2f32 | [
"PostgreSQL",
"Zlib",
"OpenSSL"
] | null | null | null | src/modules/SD2/scripts/kalimdor/silithus.cpp | muscnx/Mangos021SD2 | 695bb6a4822bb9173ab8e9077cb6259869ca2f32 | [
"PostgreSQL",
"Zlib",
"OpenSSL"
] | null | null | null | src/modules/SD2/scripts/kalimdor/silithus.cpp | muscnx/Mangos021SD2 | 695bb6a4822bb9173ab8e9077cb6259869ca2f32 | [
"PostgreSQL",
"Zlib",
"OpenSSL"
] | null | null | null | /**
* ScriptDev2 is an extension for mangos providing enhanced features for
* area triggers, creatures, game objects, instances, items, and spells beyond
* the default database scripting in mangos.
*
* Copyright (C) 2006-2013 ScriptDev2 <http://www.scriptdev2.com/>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* World of Warcraft, and all World of Warcraft or Warcraft art, images,
* and lore are copyrighted by Blizzard Entertainment, Inc.
*/
/**
* ScriptData
* SDName: Silithus
* SD%Complete: 100
* SDComment: Quest support: 8519.
* SDCategory: Silithus
* EndScriptData
*/
/**
* ContentData
* npc_anachronos_the_ancient
* EndContentData
*/
#include "precompiled.h"
/*###
## npc_anachronos_the_ancient
###*/
enum
{
// Dragons
NPC_MERITHRA_OF_THE_DREAM = 15378,
NPC_CAELESTRASZ = 15379,
NPC_ARYGOS = 15380,
NPC_ANACHRONOS_THE_ANCIENT = 15381,
NPC_ANACHRONOS_QUEST_TRIGGER = 15454, // marks some movement for the dragons
// Elfs
NPC_FANDRAL_STAGHELM = 15382,
NPC_KALDOREI_INFANTRY = 15423,
// Qiraji warriors
NPC_QIRAJI_WASP = 15414,
NPC_QIRAJI_DRONE = 15421,
NPC_QIRAJI_TANK = 15422,
NPC_ANUBISATH_CONQUEROR = 15424,
QUEST_A_PAWN_ON_THE_ETERNAL_BOARD = 8519,
// Yells -> in chronological order
SAY_ANACHRONOS_INTRO_1 = -1000740,
SAY_FANDRAL_INTRO_2 = -1000741,
SAY_MERITHRA_INTRO_3 = -1000742,
EMOTE_ARYGOS_NOD = -1000743,
SAY_CAELESTRASZ_INTRO_4 = -1000744,
EMOTE_MERITHRA_GLANCE = -1000745,
SAY_MERITHRA_INTRO_5 = -1000746,
SAY_MERITHRA_ATTACK_1 = -1000747,
SAY_ARYGOS_ATTACK_2 = -1000748,
SAY_ARYGOS_ATTACK_3 = -1000749,
SAY_CAELESTRASZ_ATTACK_4 = -1000750,
SAY_CAELESTRASZ_ATTACK_5 = -1000751,
SAY_ANACHRONOS_SEAL_1 = -1000752,
SAY_FANDRAL_SEAL_2 = -1000753,
SAY_ANACHRONOS_SEAL_3 = -1000754,
SAY_ANACHRONOS_SEAL_4 = -1000755,
SAY_ANACHRONOS_SEAL_5 = -1000756,
SAY_FANDRAL_SEAL_6 = -1000757,
EMOTE_FANDRAL_EXHAUSTED = -1000758,
SAY_ANACHRONOS_EPILOGUE_1 = -1000759,
SAY_ANACHRONOS_EPILOGUE_2 = -1000760,
SAY_ANACHRONOS_EPILOGUE_3 = -1000761,
EMOTE_ANACHRONOS_SCEPTER = -1000762,
SAY_FANDRAL_EPILOGUE_4 = -1000763,
SAY_FANDRAL_EPILOGUE_5 = -1000764,
EMOTE_FANDRAL_SHATTER = -1000765,
SAY_ANACHRONOS_EPILOGUE_6 = -1000766,
SAY_FANDRAL_EPILOGUE_7 = -1000767,
EMOTE_ANACHRONOS_DISPPOINTED = -1000768,
EMOTE_ANACHRONOS_PICKUP = -1000769,
SAY_ANACHRONOS_EPILOGUE_8 = -1000770,
// Spells
SPELL_GREEN_DRAGON_TRANSFORM = 25105,
SPELL_RED_DRAGON_TRANSFORM = 25106,
SPELL_BLUE_DRAGON_TRANSFORM = 25107,
SPELL_BRONZE_DRAGON_TRANSFORM = 25108,
SPELL_MERITHRA_WAKE = 25145, // should trigger 25172 on targets
SPELL_ARYGOS_VENGEANCE = 25149,
SPELL_CAELESTRASZ_MOLTEN_RAIN = 25150,
SPELL_TIME_STOP = 25158, // Anachronos stops the battle - should trigger 25171
SPELL_GLYPH_OF_WARDING = 25166, // Sends event 9427 - should activate Go 176148
SPELL_PRISMATIC_BARRIER = 25159, // Sends event 9425 - should activate Go 176146
SPELL_CALL_ANCIENTS = 25167, // Sends event 9426 - should activate Go 176147
SPELL_SHATTER_HAMMER = 25182, // Breakes the scepter - needs DB coords
POINT_ID_DRAGON_ATTACK = 1,
POINT_ID_EXIT = 2,
POINT_ID_GATE = 3,
POINT_ID_SCEPTER_1 = 4,
POINT_ID_SCEPTER_2 = 5,
POINT_ID_EPILOGUE = 6,
DATA_HANDLE_SCEPTER = 7, // dummy members - used in dialogue helper
DATA_MERITHRA_ATTACK = 8,
DATA_CAELASTRASZ_ATTACK = 9,
MAX_DRAGONS = 4,
MAX_CONQUERORS = 3,
MAX_QIRAJI = 6,
MAX_KALDOREI = 20,
};
/* Known event issues:
* The Kaldorei and Qiraji soldiers don't have the correct flags and factions in DB
* The Ahn'Qiraj gate gameobjects are missing from DB
* The spells used by the dragons upon the Qiraji need core support
* The script events sent by the spells which close the AQ gate needs DB support
* Can't make Fandral equip the Scepter when Anachronos handles it to him
*/
static const DialogueEntry aEventDialogue[] =
{
{NPC_ANACHRONOS_THE_ANCIENT, 0, 2000}, // summon the dragons
{SAY_ANACHRONOS_INTRO_1, NPC_ANACHRONOS_THE_ANCIENT, 3000},
{EMOTE_ONESHOT_SHOUT, NPC_ANACHRONOS_THE_ANCIENT, 3000}, // make Anachronos shout and summon the warriors
{SAY_FANDRAL_INTRO_2, NPC_FANDRAL_STAGHELM, 6000},
{EMOTE_MERITHRA_GLANCE, NPC_MERITHRA_OF_THE_DREAM, 2000},
{SAY_MERITHRA_INTRO_3, NPC_MERITHRA_OF_THE_DREAM, 3000},
{EMOTE_ARYGOS_NOD, NPC_ARYGOS, 4000},
{SAY_CAELESTRASZ_INTRO_4, NPC_CAELESTRASZ, 9000},
{SAY_MERITHRA_INTRO_5, NPC_MERITHRA_OF_THE_DREAM, 5000},
{NPC_ANACHRONOS_QUEST_TRIGGER, 0, 0}, // send Merithra to fight
{DATA_MERITHRA_ATTACK, 0, 5000}, // make Merithra wait
{SAY_MERITHRA_ATTACK_1, NPC_MERITHRA_OF_THE_DREAM, 1000},
{SPELL_GREEN_DRAGON_TRANSFORM, 0, 6000},
{SAY_ARYGOS_ATTACK_2, NPC_ARYGOS, 5000},
{NPC_ARYGOS, 0, 1000}, // send Arygos to fight
{POINT_ID_EXIT, 0, 4000}, // make Merithra exit
{SAY_ARYGOS_ATTACK_3, NPC_ARYGOS, 4000},
{SPELL_BLUE_DRAGON_TRANSFORM, 0, 5000},
{SPELL_ARYGOS_VENGEANCE, 0, 7000},
{POINT_ID_DRAGON_ATTACK, 0, 1000}, // make Arygos exit
{SAY_CAELESTRASZ_ATTACK_4, NPC_CAELESTRASZ, 5000},
{NPC_CAELESTRASZ, 0, 0}, // send Caelestrasz to fight
{DATA_CAELASTRASZ_ATTACK, 0, 3000}, // make Caelestrasz wait
{SAY_CAELESTRASZ_ATTACK_5, NPC_CAELESTRASZ, 5000},
{SPELL_RED_DRAGON_TRANSFORM, 0, 4000}, // transform Caelestrasz
{SPELL_CAELESTRASZ_MOLTEN_RAIN, 0, 6000}, // Caelestrasz casts molten rain
{SAY_ANACHRONOS_SEAL_1, NPC_ANACHRONOS_THE_ANCIENT, 5000},
{SAY_FANDRAL_SEAL_2, NPC_FANDRAL_STAGHELM, 3000},
{SAY_ANACHRONOS_SEAL_3, NPC_ANACHRONOS_THE_ANCIENT, 1000},
{POINT_ID_GATE, 0, 1000}, // send Anachronos to the gate
{NPC_FANDRAL_STAGHELM, 0, 0}, // send Fandral to the gate
{SPELL_TIME_STOP, 0, 7000}, // Anachronos casts Time Stop
{SPELL_PRISMATIC_BARRIER, 0, 15000},
{SPELL_GLYPH_OF_WARDING, 0, 4000},
{SAY_ANACHRONOS_SEAL_5, NPC_ANACHRONOS_THE_ANCIENT, 3000},
{SAY_FANDRAL_SEAL_6, NPC_FANDRAL_STAGHELM, 9000},
{EMOTE_FANDRAL_EXHAUSTED, NPC_FANDRAL_STAGHELM, 1000},
{SAY_ANACHRONOS_EPILOGUE_1, NPC_ANACHRONOS_THE_ANCIENT, 6000},
{SAY_ANACHRONOS_EPILOGUE_2, NPC_ANACHRONOS_THE_ANCIENT, 5000},
{SAY_ANACHRONOS_EPILOGUE_3, NPC_ANACHRONOS_THE_ANCIENT, 15000},
{DATA_HANDLE_SCEPTER, NPC_ANACHRONOS_THE_ANCIENT, 3000}, // handle the scepter
{SAY_FANDRAL_EPILOGUE_4, NPC_FANDRAL_STAGHELM, 3000},
{POINT_ID_SCEPTER_2, 0, 4000}, // make Anachronos stand
{SAY_FANDRAL_EPILOGUE_5, NPC_FANDRAL_STAGHELM, 12000},
{EMOTE_FANDRAL_SHATTER, NPC_FANDRAL_STAGHELM, 3000},
{SAY_ANACHRONOS_EPILOGUE_6, NPC_ANACHRONOS_THE_ANCIENT, 0},
{SAY_FANDRAL_EPILOGUE_7, NPC_FANDRAL_STAGHELM, 8000},
{POINT_ID_EPILOGUE, 0, 4000}, // move Fandral to Anachronos
{EMOTE_ANACHRONOS_DISPPOINTED, NPC_ANACHRONOS_THE_ANCIENT, 1000},
{POINT_ID_SCEPTER_1, 0, 0}, // make Anachronos pick the pieces
{0, 0, 0},
};
struct EventLocations
{
float m_fX, m_fY, m_fZ, m_fO;
uint32 m_uiEntry;
};
static EventLocations aEternalBoardNPCs[MAX_DRAGONS] =
{
{ -8029.301f, 1534.612f, 2.609f, 3.121f, NPC_FANDRAL_STAGHELM},
{ -8034.227f, 1536.580f, 2.609f, 6.161f, NPC_ARYGOS},
{ -8031.935f, 1532.658f, 2.609f, 1.012f, NPC_CAELESTRASZ},
{ -8034.106f, 1534.224f, 2.609f, 0.290f, NPC_MERITHRA_OF_THE_DREAM},
};
static EventLocations aEternalBoardMovement[] =
{
{ -8159.951f, 1525.241f, 74.994f}, // 0 Flight position for dragons
{ -8106.238f, 1525.948f, 2.639f}, // 1 Anachronos gate location
{ -8103.861f, 1525.923f, 2.677f}, // 2 Fandral gate location
{ -8107.387f, 1523.641f, 2.609f}, // 3 Shattered scepter
{ -8100.921f, 1527.740f, 2.871f}, // 4 Fandral epilogue location
{ -8115.270f, 1515.926f, 3.305f}, // 5 Anachronos gather broken scepter 1
{ -8116.879f, 1530.615f, 3.762f}, // 6 Anachronos gather broken scepter 2
{ -7997.790f, 1548.664f, 3.738f}, // 7 Fandral exit location
{ -8061.933f, 1496.196f, 2.556f}, // 8 Anachronos launch location
{ -8008.705f, 1446.063f, 44.104f}, // 9 Anachronos flight location
{ -8085.748f, 1521.484f, 2.624f} // 10 Anchor point for the army summoning
};
struct npc_anachronos_the_ancientAI : public ScriptedAI, private DialogueHelper
{
npc_anachronos_the_ancientAI(Creature* pCreature) : ScriptedAI(pCreature),
DialogueHelper(aEventDialogue)
{
Reset();
}
uint32 m_uiEventTimer;
uint8 m_uiEventStage;
ObjectGuid m_fandralGuid;
ObjectGuid m_merithraGuid;
ObjectGuid m_CaelestraszGuid;
ObjectGuid m_arygosGuid;
ObjectGuid m_playerGuid;
ObjectGuid m_triggerGuid;
GuidList m_lQirajiWarriorsList;
void Reset() override
{
// We summon the rest of the dragons on timer
m_uiEventTimer = 100;
m_uiEventStage = 0;
}
void JustDidDialogueStep(int32 iEntry) override
{
switch (iEntry)
{
case NPC_ANACHRONOS_THE_ANCIENT:
// Call the other dragons
DoSummonDragons();
break;
case EMOTE_ONESHOT_SHOUT:
// Summon warriors
DoSummonWarriors();
m_creature->HandleEmote(EMOTE_ONESHOT_SHOUT);
break;
case SAY_FANDRAL_INTRO_2:
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->SetFacingToObject(m_creature);
}
break;
case EMOTE_MERITHRA_GLANCE:
if (Creature* pMerithra = m_creature->GetMap()->GetCreature(m_merithraGuid))
{
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->SetFacingToObject(pMerithra);
}
}
break;
case NPC_ANACHRONOS_QUEST_TRIGGER:
// Move Merithra to attack
if (Creature* pTrigger = GetClosestCreatureWithEntry(m_creature, NPC_ANACHRONOS_QUEST_TRIGGER, 35.0f))
{
m_triggerGuid = pTrigger->GetObjectGuid();
if (Creature* pMerithra = m_creature->GetMap()->GetCreature(m_merithraGuid))
{
pMerithra->SetWalk(false);
pMerithra->GetMotionMaster()->MovePoint(POINT_ID_DRAGON_ATTACK, pTrigger->GetPositionX(), pTrigger->GetPositionY(), pTrigger->GetPositionZ());
}
}
break;
case SPELL_GREEN_DRAGON_TRANSFORM:
if (Creature* pMerithra = m_creature->GetMap()->GetCreature(m_merithraGuid))
{
pMerithra->CastSpell(pMerithra, SPELL_GREEN_DRAGON_TRANSFORM, false);
}
break;
case SAY_ARYGOS_ATTACK_2:
if (Creature* pMerithra = m_creature->GetMap()->GetCreature(m_merithraGuid))
{
pMerithra->CastSpell(pMerithra, SPELL_MERITHRA_WAKE, false);
}
break;
case NPC_ARYGOS:
// Move Arygos to attack
if (Creature* pTrigger = m_creature->GetMap()->GetCreature(m_triggerGuid))
{
if (Creature* pArygos = m_creature->GetMap()->GetCreature(m_arygosGuid))
{
pArygos->SetWalk(false);
pArygos->GetMotionMaster()->MovePoint(POINT_ID_DRAGON_ATTACK, pTrigger->GetPositionX(), pTrigger->GetPositionY(), pTrigger->GetPositionZ());
}
}
break;
case POINT_ID_EXIT:
// Move Merithra to the exit point
if (Creature* pMerithra = m_creature->GetMap()->GetCreature(m_merithraGuid))
{
pMerithra->SetByteValue(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND);
pMerithra->SetLevitate(true);
pMerithra->GetMotionMaster()->MovePoint(POINT_ID_EXIT, aEternalBoardMovement[0].m_fX, aEternalBoardMovement[0].m_fY, aEternalBoardMovement[0].m_fZ);
pMerithra->ForcedDespawn(9000);
}
break;
case SPELL_BLUE_DRAGON_TRANSFORM:
if (Creature* pArygos = m_creature->GetMap()->GetCreature(m_arygosGuid))
{
pArygos->CastSpell(pArygos, SPELL_BLUE_DRAGON_TRANSFORM, false);
}
break;
case SPELL_ARYGOS_VENGEANCE:
if (Creature* pArygos = m_creature->GetMap()->GetCreature(m_arygosGuid))
{
pArygos->CastSpell(pArygos, SPELL_ARYGOS_VENGEANCE, false);
}
break;
case POINT_ID_DRAGON_ATTACK:
// Move Arygos to the exit point
if (Creature* pArygos = m_creature->GetMap()->GetCreature(m_arygosGuid))
{
pArygos->SetByteValue(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND);
pArygos->SetLevitate(true);
pArygos->GetMotionMaster()->MovePoint(POINT_ID_EXIT, aEternalBoardMovement[0].m_fX, aEternalBoardMovement[0].m_fY, aEternalBoardMovement[0].m_fZ);
pArygos->ForcedDespawn(9000);
}
break;
case NPC_CAELESTRASZ:
// Move Caelestrasz to attack
if (Creature* pTrigger = m_creature->GetMap()->GetCreature(m_triggerGuid))
{
if (Creature* pCaelestrasz = m_creature->GetMap()->GetCreature(m_CaelestraszGuid))
{
pCaelestrasz->SetWalk(false);
pCaelestrasz->GetMotionMaster()->MovePoint(POINT_ID_DRAGON_ATTACK, pTrigger->GetPositionX(), pTrigger->GetPositionY(), pTrigger->GetPositionZ());
}
}
break;
case SPELL_RED_DRAGON_TRANSFORM:
if (Creature* pCaelestrasz = m_creature->GetMap()->GetCreature(m_CaelestraszGuid))
{
pCaelestrasz->CastSpell(pCaelestrasz, SPELL_RED_DRAGON_TRANSFORM, false);
}
break;
case SPELL_CAELESTRASZ_MOLTEN_RAIN:
if (Creature* pCaelestrasz = m_creature->GetMap()->GetCreature(m_CaelestraszGuid))
{
pCaelestrasz->CastSpell(pCaelestrasz, SPELL_CAELESTRASZ_MOLTEN_RAIN, false);
}
break;
case SAY_ANACHRONOS_SEAL_1:
// Send Caelestrasz on flight
if (Creature* pCaelestrasz = m_creature->GetMap()->GetCreature(m_CaelestraszGuid))
{
pCaelestrasz->SetByteValue(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND);
pCaelestrasz->SetLevitate(true);
pCaelestrasz->GetMotionMaster()->MovePoint(POINT_ID_EXIT, aEternalBoardMovement[0].m_fX, aEternalBoardMovement[0].m_fY, aEternalBoardMovement[0].m_fZ);
pCaelestrasz->ForcedDespawn(9000);
}
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
m_creature->SetFacingToObject(pFandral);
}
break;
case SAY_FANDRAL_SEAL_2:
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->SetFacingToObject(m_creature);
}
break;
case POINT_ID_GATE:
// Send Anachronos to the gate
m_creature->SetWalk(false);
m_creature->GetMotionMaster()->MovePoint(POINT_ID_GATE, aEternalBoardMovement[1].m_fX, aEternalBoardMovement[1].m_fY, aEternalBoardMovement[1].m_fZ);
break;
case NPC_FANDRAL_STAGHELM:
// Send Fandral to the gate
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->SetWalk(false);
pFandral->GetMotionMaster()->MovePoint(POINT_ID_GATE, aEternalBoardMovement[2].m_fX, aEternalBoardMovement[2].m_fY, aEternalBoardMovement[2].m_fZ);
}
break;
case SPELL_PRISMATIC_BARRIER:
DoCastSpellIfCan(m_creature, SPELL_PRISMATIC_BARRIER);
break;
case SPELL_GLYPH_OF_WARDING:
DoCastSpellIfCan(m_creature, SPELL_GLYPH_OF_WARDING);
break;
case SAY_FANDRAL_SEAL_6:
// Here Anachronos should continue to cast something
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->CastSpell(pFandral, SPELL_CALL_ANCIENTS, false);
}
break;
case EMOTE_FANDRAL_EXHAUSTED:
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->SetStandState(UNIT_STAND_STATE_KNEEL);
m_creature->SetFacingToObject(pFandral);
}
break;
case DATA_HANDLE_SCEPTER:
// Give the scepter to Fandral (it should equip it somehow)
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
DoScriptText(EMOTE_ANACHRONOS_SCEPTER, m_creature, pFandral);
}
m_creature->SetStandState(UNIT_STAND_STATE_KNEEL);
break;
case SAY_FANDRAL_EPILOGUE_4:
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->SetStandState(UNIT_STAND_STATE_STAND);
}
break;
case POINT_ID_SCEPTER_2:
m_creature->SetStandState(UNIT_STAND_STATE_STAND);
break;
case EMOTE_FANDRAL_SHATTER:
// Shatter the scepter
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->CastSpell(pFandral, SPELL_SHATTER_HAMMER, false);
}
break;
case SAY_ANACHRONOS_EPILOGUE_6:
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->SetWalk(true);
pFandral->GetMotionMaster()->MovePoint(POINT_ID_SCEPTER_1, aEternalBoardMovement[3].m_fX, aEternalBoardMovement[3].m_fY, aEternalBoardMovement[3].m_fZ);
}
break;
case POINT_ID_EPILOGUE:
// Make Fandral leave
if (Creature* pFandral = m_creature->GetMap()->GetCreature(m_fandralGuid))
{
pFandral->GetMotionMaster()->MovePoint(POINT_ID_EXIT, aEternalBoardMovement[7].m_fX, aEternalBoardMovement[7].m_fY, aEternalBoardMovement[7].m_fZ);
}
break;
case POINT_ID_SCEPTER_1:
// Anachronos collects the pieces
m_creature->SetWalk(true);
m_creature->GetMotionMaster()->MovePoint(POINT_ID_SCEPTER_1, aEternalBoardMovement[5].m_fX, aEternalBoardMovement[5].m_fY, aEternalBoardMovement[5].m_fZ);
break;
}
}
Creature* GetSpeakerByEntry(uint32 uiEntry) override
{
switch (uiEntry)
{
case NPC_ANACHRONOS_THE_ANCIENT:
return m_creature;
case NPC_ARYGOS:
return m_creature->GetMap()->GetCreature(m_arygosGuid);
case NPC_CAELESTRASZ:
return m_creature->GetMap()->GetCreature(m_CaelestraszGuid);
case NPC_MERITHRA_OF_THE_DREAM:
return m_creature->GetMap()->GetCreature(m_merithraGuid);
case NPC_FANDRAL_STAGHELM:
return m_creature->GetMap()->GetCreature(m_fandralGuid);
default:
return NULL;
}
}
void DoSummonDragons()
{
for (uint8 i = 0; i < MAX_DRAGONS; ++i)
{
m_creature->SummonCreature(aEternalBoardNPCs[i].m_uiEntry, aEternalBoardNPCs[i].m_fX, aEternalBoardNPCs[i].m_fY, aEternalBoardNPCs[i].m_fZ, aEternalBoardNPCs[i].m_fO, TEMPSUMMON_CORPSE_DESPAWN, 0);
}
// Also summon the 3 anubisath conquerors
float fX, fY, fZ;
for (uint8 i = 0; i < MAX_CONQUERORS; ++i)
{
m_creature->GetRandomPoint(aEternalBoardMovement[10].m_fX, aEternalBoardMovement[10].m_fY, aEternalBoardMovement[10].m_fZ, 20.0f, fX, fY, fZ);
m_creature->SummonCreature(NPC_ANUBISATH_CONQUEROR, fX, fY, fZ, 0, TEMPSUMMON_CORPSE_DESPAWN, 0);
}
}
void DoSummonWarriors()
{
float fX, fY, fZ;
// Summon kaldorei warriors
for (uint8 i = 0; i < MAX_KALDOREI; ++i)
{
m_creature->GetRandomPoint(aEternalBoardMovement[10].m_fX, aEternalBoardMovement[10].m_fY, aEternalBoardMovement[10].m_fZ, 10.0f, fX, fY, fZ);
m_creature->SummonCreature(NPC_KALDOREI_INFANTRY, fX, fY, fZ, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
}
// Summon Qiraji warriors
for (uint8 i = 0; i < MAX_QIRAJI; ++i)
{
m_creature->GetRandomPoint(aEternalBoardMovement[10].m_fX, aEternalBoardMovement[10].m_fY, aEternalBoardMovement[10].m_fZ, 15.0f, fX, fY, fZ);
m_creature->SummonCreature(NPC_QIRAJI_WASP, fX, fY, fZ, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
m_creature->GetRandomPoint(aEternalBoardMovement[10].m_fX, aEternalBoardMovement[10].m_fY, aEternalBoardMovement[10].m_fZ, 15.0f, fX, fY, fZ);
m_creature->SummonCreature(NPC_QIRAJI_DRONE, fX, fY, fZ, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
m_creature->GetRandomPoint(aEternalBoardMovement[10].m_fX, aEternalBoardMovement[10].m_fY, aEternalBoardMovement[10].m_fZ, 15.0f, fX, fY, fZ);
m_creature->SummonCreature(NPC_QIRAJI_TANK, fX, fY, fZ, 0.0f, TEMPSUMMON_CORPSE_DESPAWN, 0);
}
}
void DoUnsummonArmy()
{
for (GuidList::const_iterator itr = m_lQirajiWarriorsList.begin(); itr != m_lQirajiWarriorsList.end(); ++itr)
{
if (Creature* pTemp = m_creature->GetMap()->GetCreature(*itr))
{
pTemp->ForcedDespawn();
}
}
}
void JustSummoned(Creature* pSummoned) override
{
// Also remove npc flags where needed
switch (pSummoned->GetEntry())
{
case NPC_FANDRAL_STAGHELM:
m_fandralGuid = pSummoned->GetObjectGuid();
break;
case NPC_MERITHRA_OF_THE_DREAM:
m_merithraGuid = pSummoned->GetObjectGuid();
pSummoned->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
break;
case NPC_CAELESTRASZ:
m_CaelestraszGuid = pSummoned->GetObjectGuid();
pSummoned->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
break;
case NPC_ARYGOS:
m_arygosGuid = pSummoned->GetObjectGuid();
pSummoned->SetUInt32Value(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_NONE);
break;
case NPC_ANUBISATH_CONQUEROR:
case NPC_QIRAJI_WASP:
case NPC_QIRAJI_DRONE:
case NPC_QIRAJI_TANK:
case NPC_KALDOREI_INFANTRY:
m_lQirajiWarriorsList.push_back(pSummoned->GetObjectGuid());
break;
}
}
void MovementInform(uint32 uiType, uint32 uiPointId) override
{
if (uiType != POINT_MOTION_TYPE)
{
return;
}
switch (uiPointId)
{
case POINT_ID_GATE:
// Cast time stop when he reaches the gate
DoCastSpellIfCan(m_creature, SPELL_TIME_STOP);
StartNextDialogueText(SPELL_TIME_STOP);
break;
case POINT_ID_SCEPTER_1:
// Pickup the pieces
DoScriptText(EMOTE_ANACHRONOS_PICKUP, m_creature);
m_creature->SetStandState(UNIT_STAND_STATE_KNEEL);
m_uiEventTimer = 2000;
break;
case POINT_ID_SCEPTER_2:
// Pickup the pieces
DoScriptText(SAY_ANACHRONOS_EPILOGUE_8, m_creature);
m_creature->SetStandState(UNIT_STAND_STATE_KNEEL);
m_uiEventTimer = 4000;
break;
case POINT_ID_EXIT:
DoCastSpellIfCan(m_creature, SPELL_BRONZE_DRAGON_TRANSFORM);
m_uiEventTimer = 4000;
break;
}
}
void SummonedMovementInform(Creature* pSummoned, uint32 uiType, uint32 uiPointId) override
{
if (uiType != POINT_MOTION_TYPE)
{
return;
}
if (pSummoned->GetEntry() == NPC_FANDRAL_STAGHELM)
{
switch (uiPointId)
{
case POINT_ID_EPILOGUE:
// Face Anachronos and restart the dialogue
pSummoned->SetFacingToObject(m_creature);
StartNextDialogueText(SAY_FANDRAL_EPILOGUE_7);
DoUnsummonArmy();
break;
case POINT_ID_SCEPTER_1:
pSummoned->GetMotionMaster()->MovePoint(POINT_ID_EPILOGUE, aEternalBoardMovement[4].m_fX, aEternalBoardMovement[4].m_fY, aEternalBoardMovement[4].m_fZ);
break;
case POINT_ID_EXIT:
pSummoned->ForcedDespawn();
break;
}
}
else if (uiPointId == POINT_ID_DRAGON_ATTACK)
{
switch (pSummoned->GetEntry())
{
case NPC_MERITHRA_OF_THE_DREAM:
StartNextDialogueText(DATA_MERITHRA_ATTACK);
break;
case NPC_CAELESTRASZ:
StartNextDialogueText(DATA_CAELASTRASZ_ATTACK);
break;
}
}
}
void UpdateAI(const uint32 uiDiff) override
{
DialogueUpdate(uiDiff);
if (m_uiEventTimer)
{
if (m_uiEventTimer <= uiDiff)
{
switch (m_uiEventStage)
{
case 0:
// Start the dialogue
StartNextDialogueText(NPC_ANACHRONOS_THE_ANCIENT);
m_uiEventTimer = 0;
break;
case 1:
// Do the epilogue movement
m_creature->GetMotionMaster()->MovePoint(POINT_ID_SCEPTER_2, aEternalBoardMovement[6].m_fX, aEternalBoardMovement[6].m_fY, aEternalBoardMovement[6].m_fZ);
m_creature->SetStandState(UNIT_STAND_STATE_STAND);
m_uiEventTimer = 0;
break;
case 2:
// Complete quest and despawn gate
if (Player* pPlayer = m_creature->GetMap()->GetPlayer(m_playerGuid))
{
pPlayer->GroupEventHappens(QUEST_A_PAWN_ON_THE_ETERNAL_BOARD, m_creature);
}
m_creature->SetStandState(UNIT_STAND_STATE_STAND);
m_uiEventTimer = 4000;
break;
case 3:
// Move to exit
m_creature->SetWalk(false);
m_creature->GetMotionMaster()->MovePoint(POINT_ID_EXIT, aEternalBoardMovement[8].m_fX, aEternalBoardMovement[8].m_fY, aEternalBoardMovement[8].m_fZ);
m_uiEventTimer = 0;
break;
case 4:
// Take off and fly
m_creature->SetByteValue(UNIT_FIELD_BYTES_1, 3, UNIT_BYTE1_FLAG_ALWAYS_STAND);
m_creature->SetLevitate(true);
m_creature->GetMotionMaster()->MovePoint(0, aEternalBoardMovement[9].m_fX, aEternalBoardMovement[9].m_fY, aEternalBoardMovement[9].m_fZ);
m_creature->ForcedDespawn(10000);
m_uiEventTimer = 0;
break;
}
++m_uiEventStage;
}
else
{
m_uiEventTimer -= uiDiff;
}
}
}
};
CreatureAI* GetAI_npc_anachronos_the_ancient(Creature* pCreature)
{
return new npc_anachronos_the_ancientAI(pCreature);
}
bool QuestAcceptGO_crystalline_tear(Player* pPlayer, GameObject* pGo, const Quest* pQuest)
{
// Summon the controller dragon at GO position (orientation is wrong - hardcoded)
if (pQuest->GetQuestId() == QUEST_A_PAWN_ON_THE_ETERNAL_BOARD)
{
// Check if event is already in progress first
if (GetClosestCreatureWithEntry(pGo, NPC_ANACHRONOS_THE_ANCIENT, 90.0f))
{
return true;
}
if (Creature* pAnachronos = pPlayer->SummonCreature(NPC_ANACHRONOS_THE_ANCIENT, pGo->GetPositionX(), pGo->GetPositionY(), pGo->GetPositionZ(), 3.75f, TEMPSUMMON_CORPSE_DESPAWN, 0))
{
// Send the player's guid in order to handle the quest complete
if (npc_anachronos_the_ancientAI* pAnachronosAI = dynamic_cast<npc_anachronos_the_ancientAI*>(pAnachronos->AI()))
{
pAnachronosAI->m_playerGuid = pPlayer->GetObjectGuid();
}
}
}
return true;
}
void AddSC_silithus()
{
Script* pNewScript;
pNewScript = new Script;
pNewScript->Name = "npc_anachronos_the_ancient";
pNewScript->GetAI = &GetAI_npc_anachronos_the_ancient;
pNewScript->RegisterSelf();
pNewScript = new Script;
pNewScript->Name = "go_crystalline_tear";
pNewScript->pQuestAcceptGO = &QuestAcceptGO_crystalline_tear;
pNewScript->RegisterSelf();
}
| 44.946237 | 209 | 0.56866 | muscnx |
495c81ed964a4da5bb18a389a89de9808d24104c | 16,536 | cpp | C++ | src/main/DLSFile.cpp | ElSaico/vgmtrans | 8fa6f4adf6437e47c2bddf0e8a96bef7cd13ff88 | [
"Zlib"
] | null | null | null | src/main/DLSFile.cpp | ElSaico/vgmtrans | 8fa6f4adf6437e47c2bddf0e8a96bef7cd13ff88 | [
"Zlib"
] | null | null | null | src/main/DLSFile.cpp | ElSaico/vgmtrans | 8fa6f4adf6437e47c2bddf0e8a96bef7cd13ff88 | [
"Zlib"
] | null | null | null | /**
* VGMTrans (c) - 2002-2021
* Licensed under the zlib license
* See the included LICENSE for more information
*/
#include "pch.h"
#include <algorithm>
#include <memory>
#include <numeric>
#include "DLSFile.h"
#include "VGMInstrSet.h"
#include "VGMSamp.h"
#include "Root.h"
using namespace std;
// *******
// DLSFile
// *******
DLSFile::DLSFile(string dls_name) : RiffFile(dls_name, "DLS ") {
}
std::vector<DLSInstr *> DLSFile::GetInstruments() {
std::vector<DLSInstr *> instrs(m_instrs.size());
std::transform(std::begin(m_instrs), std::end(m_instrs), std::begin(instrs), [](auto &instr_pointer) {
return instr_pointer.get();
});
return instrs;
}
std::vector<DLSWave *> DLSFile::GetWaves() {
std::vector<DLSWave *> waves(m_waves.size());
std::transform(std::begin(m_waves), std::end(m_waves), std::begin(waves), [](auto &wave_pointer) {
return wave_pointer.get();
});
return waves;
}
DLSInstr *DLSFile::AddInstr(unsigned long bank, unsigned long instrNum) {
auto instr = m_instrs.emplace_back(std::make_unique<DLSInstr>(bank, instrNum)).get();
return instr;
}
DLSInstr *DLSFile::AddInstr(unsigned long bank, unsigned long instrNum, std::string instr_name) {
auto instr = m_instrs.emplace_back(std::make_unique<DLSInstr>(bank, instrNum, instr_name)).get();
return instr;
}
void DLSFile::DeleteInstr(unsigned long, unsigned long) {
}
DLSWave *DLSFile::AddWave(uint16_t formatTag, uint16_t channels, int samplesPerSec,
int aveBytesPerSec, uint16_t blockAlign, uint16_t bitsPerSample,
uint32_t waveDataSize, unsigned char *waveData, string wave_name) {
auto wave = m_waves
.emplace_back(std::make_unique<DLSWave>(formatTag, channels, samplesPerSec,
aveBytesPerSec, blockAlign, bitsPerSample,
waveDataSize, waveData, wave_name))
.get();
return wave;
}
// GetSize returns total DLS size, including the "RIFF" header size
uint32_t DLSFile::GetSize() {
uint32_t dls_size = 0;
dls_size += 12; // "RIFF" + size + "DLS "
dls_size += COLH_SIZE; // COLH chunk (collection chunk - tells how many instruments)
dls_size += LIST_HDR_SIZE; //"lins" list (list of instruments - contains all the "ins " lists)
for (auto &instr : m_instrs) {
dls_size += instr->GetSize();
}
dls_size += 16; // "ptbl" + size + cbSize + cCues
dls_size += static_cast<uint32_t>(m_waves.size()) * sizeof(uint32_t); // each wave gets a poolcue
dls_size += LIST_HDR_SIZE; //"wvpl" list (wave pool - contains all the "wave" lists)
for (auto &wave : m_waves) {
dls_size += wave->GetSize();
}
dls_size += LIST_HDR_SIZE; //"INFO" list
dls_size += 8; //"INAM" + size
dls_size += static_cast<uint32_t>(name.size()); // size of name string
return dls_size;
}
int DLSFile::WriteDLSToBuffer(vector<uint8_t> &buf) {
uint32_t theDWORD;
PushTypeOnVectBE<uint32_t>(buf, 0x52494646); //"RIFF"
PushTypeOnVect<uint32_t>(buf, GetSize() - 8); // size
PushTypeOnVectBE<uint32_t>(buf, 0x444C5320); //"DLS "
PushTypeOnVectBE<uint32_t>(buf, 0x636F6C68); //"colh "
PushTypeOnVect<uint32_t>(buf, 4); // size
PushTypeOnVect<uint32_t>(
buf, static_cast<uint32_t>(m_instrs.size())); // cInstruments - number of instruments
theDWORD = 4; // account for 4 "lins" bytes
for (auto &instr : m_instrs)
theDWORD += instr->GetSize(); // each "ins " list
WriteLIST(buf, 0x6C696E73, theDWORD); // Write the "lins" LIST
for (auto &instr : m_instrs) {
instr->Write(buf);
}
PushTypeOnVectBE<uint32_t>(buf, 0x7074626C); //"ptbl"
theDWORD = 8;
theDWORD += static_cast<uint32_t>(m_waves.size()) * sizeof(uint32_t); // each wave gets a poolcue
PushTypeOnVect<uint32_t>(buf, theDWORD); // size
PushTypeOnVect<uint32_t>(buf, 8); // cbSize
PushTypeOnVect<uint32_t>(buf, static_cast<uint32_t>(m_waves.size())); // cCues
theDWORD = 0;
for (auto &wave : m_waves) {
PushTypeOnVect<uint32_t>(buf, theDWORD); // write the poolcue for each sample
theDWORD += wave->GetSize(); // increment the offset to the next wave
}
theDWORD = 4;
for (auto &wave : m_waves) {
theDWORD += wave->GetSize(); // each "wave" list
}
WriteLIST(buf, 0x7776706C, theDWORD); // Write the "wvpl" LIST
for (auto &wave : m_waves) {
wave->Write(buf); // Write each "wave" list
}
theDWORD = 12 + static_cast<uint32_t>(name.size()); //"INFO" + "INAM" + size + the string size
WriteLIST(buf, 0x494E464F, theDWORD); // write the "INFO" list
PushTypeOnVectBE<uint32_t>(buf, 0x494E414D); //"INAM"
PushTypeOnVect<uint32_t>(buf, static_cast<uint32_t>(name.size())); // size
PushBackStringOnVector(buf, name); // The Instrument Name string
return true;
}
// I should probably make this function part of a parent class for both Midi and DLS file
bool DLSFile::SaveDLSFile(const std::wstring &filepath) {
vector<uint8_t> dlsBuf;
WriteDLSToBuffer(dlsBuf);
return pRoot->UI_WriteBufferToFile(filepath, dlsBuf.data(), static_cast<uint32_t>(dlsBuf.size()));
}
// *******
// DLSInstr
// ********
DLSInstr::DLSInstr(uint32_t bank, uint32_t instrument)
: ulBank(bank), ulInstrument(instrument), m_name("Untitled instrument") {
RiffFile::AlignName(m_name);
}
DLSInstr::DLSInstr(uint32_t bank, uint32_t instrument, string instrName)
: ulBank(bank), ulInstrument(instrument), m_name(instrName) {
RiffFile::AlignName(m_name);
}
uint32_t DLSInstr::GetSize() const {
uint32_t dls_size = 0;
dls_size += LIST_HDR_SIZE; //"ins " list
dls_size += INSH_SIZE; // insh chunk
dls_size += LIST_HDR_SIZE; //"lrgn" list
for (auto &rgn : m_regions) {
dls_size += rgn->GetSize();
}
dls_size += LIST_HDR_SIZE; //"INFO" list
dls_size += 8; //"INAM" + size
dls_size += static_cast<uint32_t>(m_name.size()); // size of name string
return dls_size;
}
void DLSInstr::Write(vector<uint8_t> &buf) {
uint32_t temp = GetSize() - 8;
RiffFile::WriteLIST(buf, 0x696E7320, temp); // write "ins " list
PushTypeOnVectBE<uint32_t>(buf, 0x696E7368); //"insh"
PushTypeOnVect<uint32_t>(buf, INSH_SIZE - 8); // size
PushTypeOnVect<uint32_t>(buf, static_cast<uint32_t>(m_regions.size())); // cRegions
PushTypeOnVect<uint32_t>(buf, ulBank); // ulBank
PushTypeOnVect<uint32_t>(buf, ulInstrument); // ulInstrument
temp = 4;
for (auto &rgn : m_regions) {
temp += rgn->GetSize();
}
RiffFile::WriteLIST(buf, 0x6C72676E, temp); // write the "lrgn" list
for (auto ® : m_regions) {
reg->Write(buf);
}
temp = 12 + static_cast<uint32_t>(m_name.size()); //"INFO" + "INAM" + size + the string size
RiffFile::WriteLIST(buf, 0x494E464F, temp); // write the "INFO" list
PushTypeOnVectBE<uint32_t>(buf, 0x494E414D); //"INAM"
temp = static_cast<uint32_t>(m_name.size());
PushTypeOnVect<uint32_t>(buf, temp); // size
PushBackStringOnVector(buf, m_name); // The Instrument Name string
}
DLSRgn *DLSInstr::AddRgn() {
auto reg = m_regions.emplace_back(std::make_unique<DLSRgn>()).get();
return reg;
}
// ******
// DLSRgn
// ******
uint32_t DLSRgn::GetSize() const {
uint32_t size = 0;
size += LIST_HDR_SIZE; //"rgn2" list
size += RGNH_SIZE; // rgnh chunk
if (m_wsmp) {
size += m_wsmp->GetSize();
}
size += WLNK_SIZE;
if (m_art) {
size += m_art->GetSize();
}
return size;
}
void DLSRgn::Write(vector<uint8_t> &buf) {
RiffFile::WriteLIST(buf, 0x72676E32, (GetSize() - 8)); // write "rgn2" list
PushTypeOnVectBE<uint32_t>(buf, 0x72676E68); //"rgnh"
PushTypeOnVect<uint32_t>(buf, static_cast<uint32_t>(RGNH_SIZE - 8)); // size
PushTypeOnVect<uint16_t>(buf, usKeyLow); // usLow (key)
PushTypeOnVect<uint16_t>(buf, usKeyHigh); // usHigh (key)
PushTypeOnVect<uint16_t>(buf, usVelLow); // usLow (vel)
PushTypeOnVect<uint16_t>(buf, usVelHigh); // usHigh (vel)
PushTypeOnVect<uint16_t>(buf, 1); // fusOptions
PushTypeOnVect<uint16_t>(buf, 0); // usKeyGroup
// new for dls2
PushTypeOnVect<uint16_t>(buf, 1); // NO CLUE
if (m_wsmp)
m_wsmp->Write(buf); // write the "wsmp" chunk
PushTypeOnVectBE<uint32_t>(buf, 0x776C6E6B); //"wlnk"
PushTypeOnVect<uint32_t>(buf, WLNK_SIZE - 8); // size
PushTypeOnVect<uint16_t>(buf, fusOptions); // fusOptions
PushTypeOnVect<uint16_t>(buf, usPhaseGroup); // usPhaseGroup
PushTypeOnVect<uint32_t>(buf, channel); // ulChannel
PushTypeOnVect<uint32_t>(buf, tableIndex); // ulTableIndex
if (m_art)
m_art->Write(buf);
}
DLSArt *DLSRgn::AddArt() {
m_art = std::make_unique<DLSArt>();
return m_art.get();
}
DLSWsmp *DLSRgn::AddWsmp() {
m_wsmp = std::make_unique<DLSWsmp>();
return m_wsmp.get();
}
void DLSRgn::SetRanges(uint16_t keyLow, uint16_t keyHigh, uint16_t velLow, uint16_t velHigh) {
usKeyLow = keyLow;
usKeyHigh = keyHigh;
usVelLow = velLow;
usVelHigh = velHigh;
}
void DLSRgn::SetWaveLinkInfo(uint16_t options, uint16_t phaseGroup, uint32_t theChannel,
uint32_t theTableIndex) {
fusOptions = options;
usPhaseGroup = phaseGroup;
channel = theChannel;
tableIndex = theTableIndex;
}
// ******
// DLSArt
// ******
uint32_t DLSArt::GetSize(void) {
uint32_t size = 0;
size += LIST_HDR_SIZE; //"lar2" list
size += 16; //"art2" chunk + size + cbSize + cConnectionBlocks
for (auto &block : m_blocks)
size += block->GetSize(); // each connection block
return size;
}
void DLSArt::Write(vector<uint8_t> &buf) {
RiffFile::WriteLIST(buf, 0x6C617232, GetSize() - 8); // write "lar2" list
PushTypeOnVectBE<uint32_t>(buf, 0x61727432); //"art2"
PushTypeOnVect<uint32_t>(buf, GetSize() - LIST_HDR_SIZE - 8); // size
PushTypeOnVect<uint32_t>(buf, 8); // cbSize
PushTypeOnVect<uint32_t>(buf, static_cast<uint32_t>(m_blocks.size())); // cConnectionBlocks
for (auto &block : m_blocks) {
block->Write(buf); // each connection block
}
}
void DLSArt::AddADSR(long attack_time, uint16_t atk_transform, long decay_time, long sustain_lev,
long release_time, uint16_t rls_transform) {
m_blocks.emplace_back(std::make_unique<ConnectionBlock>(
CONN_SRC_NONE, CONN_SRC_NONE, CONN_DST_EG1_ATTACKTIME, atk_transform, attack_time));
m_blocks.emplace_back(std::make_unique<ConnectionBlock>(
CONN_SRC_NONE, CONN_SRC_NONE, CONN_DST_EG1_DECAYTIME, CONN_TRN_NONE, decay_time));
m_blocks.emplace_back(std::make_unique<ConnectionBlock>(
CONN_SRC_NONE, CONN_SRC_NONE, CONN_DST_EG1_SUSTAINLEVEL, CONN_TRN_NONE, sustain_lev));
m_blocks.emplace_back(std::make_unique<ConnectionBlock>(
CONN_SRC_NONE, CONN_SRC_NONE, CONN_DST_EG1_RELEASETIME, rls_transform, release_time));
}
void DLSArt::AddPan(long pan) {
m_blocks.emplace_back(std::make_unique<ConnectionBlock>(CONN_SRC_NONE, CONN_SRC_NONE,
CONN_DST_PAN, CONN_TRN_NONE, pan));
}
// ***************
// ConnectionBlock
// ***************
void ConnectionBlock::Write(vector<uint8_t> &buf) {
PushTypeOnVect<uint16_t>(buf, usSource); // usSource
PushTypeOnVect<uint16_t>(buf, usControl); // usControl
PushTypeOnVect<uint16_t>(buf, usDestination); // usDestination
PushTypeOnVect<uint16_t>(buf, usTransform); // usTransform
PushTypeOnVect<int32_t>(buf, lScale); // lScale
}
// *******
// DLSWsmp
// *******
uint32_t DLSWsmp::GetSize() const {
uint32_t size = 0;
size += 28; // all the variables minus the loop info
if (cSampleLoops)
size += 16; // plus the loop info
return size;
}
void DLSWsmp::Write(vector<uint8_t> &buf) {
PushTypeOnVectBE<uint32_t>(buf, 0x77736D70); //"wsmp"
PushTypeOnVect<uint32_t>(buf, GetSize() - 8); // size
PushTypeOnVect<uint32_t>(buf, 20); // cbSize (size of structure without loop record)
PushTypeOnVect<uint16_t>(buf, usUnityNote); // usUnityNote
PushTypeOnVect<int16_t>(buf, sFineTune); // sFineTune
PushTypeOnVect<int32_t>(buf, lAttenuation); // lAttenuation
PushTypeOnVect<uint32_t>(buf, 1); // fulOptions
PushTypeOnVect<uint32_t>(buf, cSampleLoops); // cSampleLoops
if (cSampleLoops) // if it loops, write the loop structure
{
PushTypeOnVect<uint32_t>(buf, 16);
PushTypeOnVect<uint32_t>(buf, ulLoopType); // ulLoopType
PushTypeOnVect<uint32_t>(buf, ulLoopStart);
PushTypeOnVect<uint32_t>(buf, ulLoopLength);
}
}
void DLSWsmp::SetLoopInfo(Loop &loop, VGMSamp *samp) {
const int origFormatBytesPerSamp = samp->bps / 8;
double compressionRatio = samp->GetCompressionRatio();
// If the sample loops, but the loop length is 0, then assume the length should
// extend to the end of the sample.
if (loop.loopStatus && loop.loopLength == 0)
loop.loopLength = samp->dataLength - loop.loopStart;
cSampleLoops = loop.loopStatus;
ulLoopType = loop.loopType;
// In DLS, the value is in number of samples
// if the val is a raw offset of the original format, multiply it by the compression ratio
ulLoopStart = (loop.loopStartMeasure == LM_BYTES)
? (uint32_t)((loop.loopStart * compressionRatio) / origFormatBytesPerSamp)
: loop.loopStart;
ulLoopLength = (loop.loopLengthMeasure == LM_BYTES)
? (uint32_t)((loop.loopLength * compressionRatio) / origFormatBytesPerSamp)
: loop.loopLength;
}
void DLSWsmp::SetPitchInfo(uint16_t unityNote, short fineTune, long attenuation) {
usUnityNote = unityNote;
sFineTune = fineTune;
lAttenuation = attenuation;
}
// *******
// DLSWave
// *******
uint32_t DLSWave::GetSize() const {
uint32_t size = 0;
size += LIST_HDR_SIZE; //"wave" list
size += 8; //"fmt " chunk + size
size += 18; // fmt chunk data
size += 8; //"data" chunk + size
size += this->GetSampleSize(); // dataSize; //size of sample data
size += LIST_HDR_SIZE; //"INFO" list
size += 8; //"INAM" + size
size += static_cast<uint32_t>(m_name.size()); // size of name string
return size;
}
void DLSWave::Write(vector<uint8_t> &buf) {
RiffFile::WriteLIST(buf, 0x77617665, GetSize() - 8); // write "wave" list
PushTypeOnVectBE<uint32_t>(buf, 0x666D7420); //"fmt "
PushTypeOnVect<uint32_t>(buf, 18); // size
PushTypeOnVect<uint16_t>(buf, wFormatTag); // wFormatTag
PushTypeOnVect<uint16_t>(buf, wChannels); // wChannels
PushTypeOnVect<uint32_t>(buf, dwSamplesPerSec); // dwSamplesPerSec
PushTypeOnVect<uint32_t>(buf, dwAveBytesPerSec); // dwAveBytesPerSec
PushTypeOnVect<uint16_t>(buf, wBlockAlign); // wBlockAlign
PushTypeOnVect<uint16_t>(buf, wBitsPerSample); // wBitsPerSample
PushTypeOnVect<uint16_t>(buf, 0); // cbSize DLS2 specific. I don't know anything else
PushTypeOnVectBE<uint32_t>(buf, 0x64617461); // "data"
/* size: this is the ACTUAL size, not the even-aligned size */
PushTypeOnVect<uint32_t>(buf, m_wave_data.size());
buf.insert(buf.end(), std::begin(m_wave_data), std::end(m_wave_data)); // Write the sample
if (m_wave_data.size() % 2) {
buf.push_back(0);
}
uint32_t info_sig =
12 + static_cast<uint32_t>(m_name.size()); //"INFO" + "INAM" + size + the string size
RiffFile::WriteLIST(buf, 0x494E464F, info_sig); // write the "INFO" list
PushTypeOnVectBE<uint32_t>(buf, 0x494E414D); //"INAM"
PushTypeOnVect<uint32_t>(buf, static_cast<uint32_t>(m_name.size())); // size
PushBackStringOnVector(buf, m_name);
}
| 37.496599 | 104 | 0.630261 | ElSaico |
4962490e27a68a782d18e4e218cb6f682fc56ea0 | 27,433 | cc | C++ | tests/value_test.cc | tegtmeye/cmd_options | 03f2644e57413b38074545867ca539019201349e | [
"BSD-3-Clause"
] | null | null | null | tests/value_test.cc | tegtmeye/cmd_options | 03f2644e57413b38074545867ca539019201349e | [
"BSD-3-Clause"
] | null | null | null | tests/value_test.cc | tegtmeye/cmd_options | 03f2644e57413b38074545867ca539019201349e | [
"BSD-3-Clause"
] | null | null | null | #include "cmd_options.h"
#include "test_detail.h"
#include <boost/test/unit_test.hpp>
/**
Check for fundmental and STL value handling
*/
namespace co = cmd_options;
typedef std::basic_string<detail::check_char_t> string_type;
typedef co::basic_option_pack<detail::check_char_t> option_pack_type;
typedef co::basic_option_description<detail::check_char_t>
option_description_type;
typedef co::basic_options_group<detail::check_char_t> options_group_type;
typedef co::basic_variable_map<detail::check_char_t> variable_map_type;
typedef detail::std_stream_select<detail::check_char_t> stream_select;
namespace cmd_options {
struct userdef_struct {
userdef_struct(const string_type &str=string_type()) :_str(str) {}
bool operator==(const userdef_struct &rhs) const {
return rhs._str == _str;
}
string_type _str;
};
/*
operator>> and operator << are only going to be called in one of two
ways, char in the case where CharT is one of {char,char16_t,char32_t}
which means UTF and wchar_t which may be UCS2 or something else. Use
SFINAE so that this class be be used with all types for testing
*/
template<typename CharT>
inline typename std::enable_if<std::is_same<CharT,char>::value,
std::basic_ostream<CharT> &>::type
operator<<(std::basic_ostream<CharT> &out, const userdef_struct &ts)
{
return (out << detail::asUTF8(ts._str));
}
template<typename CharT>
inline typename std::enable_if<std::is_same<CharT,wchar_t>::value,
std::basic_ostream<CharT> &>::type
operator<<(std::basic_ostream<CharT> &out, const userdef_struct &ts)
{
return (out << ts._str);
}
template<typename CharT>
inline typename std::enable_if<std::is_same<CharT,char>::value,
std::basic_istream<CharT> &>::type
operator>>(std::basic_istream<CharT> &in, userdef_struct &rhs)
{
std::istreambuf_iterator<CharT> first(in);
std::istreambuf_iterator<CharT> last;
rhs._str = detail::fromUTF8<::detail::check_char_t>({first,last});
return in;
}
template<typename CharT>
inline typename std::enable_if<std::is_same<CharT,wchar_t>::value,
std::basic_istream<CharT> &>::type
operator>>(std::basic_istream<CharT> &in, userdef_struct &rhs)
{
std::istreambuf_iterator<CharT> first(in);
std::istreambuf_iterator<CharT> last;
rhs._str.assign(first,last);
return in;
}
struct userdef_convert_struct {
userdef_convert_struct(const string_type &str=string_type()) :_str(str) {}
bool operator==(const userdef_convert_struct &rhs) const {
return rhs._str == _str;
}
string_type _str;
};
/*
These 4 functions should never be chosen by the compiler, the EZ
interface should pick up the specialized
'convert_value<userdef_convert_struct>' structure instead of
choosing these.
*/
template<typename CharT>
inline typename std::enable_if<std::is_same<CharT,char>::value,
std::basic_ostream<CharT> &>::type
operator<<(std::basic_ostream<CharT> &, const userdef_convert_struct &)
{
throw 1;
}
template<typename CharT>
inline typename std::enable_if<std::is_same<CharT,wchar_t>::value,
std::basic_ostream<CharT> &>::type
operator<<(std::basic_ostream<CharT> &, const userdef_convert_struct &)
{
throw 1;
}
template<typename CharT>
inline typename std::enable_if<std::is_same<CharT,char>::value,
std::basic_istream<CharT> &>::type
operator>>(std::basic_istream<CharT> &, userdef_convert_struct &)
{
throw 1;
}
template<typename CharT>
inline typename std::enable_if<std::is_same<CharT,wchar_t>::value,
std::basic_istream<CharT> &>::type
operator>>(std::basic_istream<CharT> &, userdef_convert_struct &)
{
throw 1;
}
template<>
struct convert_value<userdef_convert_struct> {
static userdef_convert_struct from_string(const string_type &str)
{
return userdef_convert_struct(str);
}
static void to_string(string_type &str, const userdef_convert_struct &val)
{
str = val._str;
}
};
template<typename CharT>
std::basic_string<CharT> userdef_transform(const std::basic_string<CharT> &in)
{
return std::basic_string<CharT>(in.rbegin(),in.rend());
}
/**
Userdefined conversion function. Convert the contents of the string to
a T using operator>>. If all goes well, just replace the value with
the one supplied to the constructor. Just used to check that the
userdefined version is used.
*/
template<typename T, typename CharT>
struct userdef_cvt {
T operator()(const std::basic_string<CharT> &str) const
{
return co::convert_value<T>::from_string(str+str);
}
void operator()(std::basic_string<CharT> &str, const T &val) const {
co::convert_value<T>::to_string(str,val);
str = str+str;
}
};
/**
Userdefined conversion function. Convert the contents of the given value to a string using operator<<. If all goes well, just replace the string with
the one supplied to the constructor. Just used to check that the
userdefined version is used.
*/
template<typename T, typename CharT>
struct userdef_to_string {
userdef_to_string(const std::basic_string<CharT> &val) :_val(val) {}
void operator()(std::basic_string<CharT> &str, const T &val)
{
std::basic_stringstream<CharT> out;
if(!(out << val))
throw 1;
str = _val;
}
std::basic_string<CharT> &_val;
};
}
BOOST_AUTO_TEST_SUITE( value_test_suite )
/**
Check fundamental values
*/
BOOST_AUTO_TEST_CASE( bool_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--bool=1"),
_LIT("--bool=0"),
_LIT("--bool=true"),
_LIT("--bool=false"),
};
options = options_group_type{
co::make_option(_LIT("bool"),co::basic_value<bool,detail::check_char_t>(),
_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("bool"),static_cast<bool>(1)),
detail::check_value(_LIT("bool"),static_cast<bool>(0)),
detail::check_value(_LIT("bool"),static_cast<bool>(1)),
detail::check_value(_LIT("bool"),static_cast<bool>(0)),
}
));
std::vector<const detail::check_char_t *> argv2{
_LIT("--bool=11"),
};
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("11"));
}
);
return true;
}
);
std::vector<const detail::check_char_t *> argv3{
_LIT("--bool=foobar"),
};
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv3.data(),
argv3.data()+argv3.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foobar"));
}
);
return true;
}
);
std::vector<const detail::check_char_t *> argv4{
_LIT("--bool=truefoo"),
};
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv4.data(),
argv4.data()+argv4.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("truefoo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( CharT_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--CharT=a"),
};
options = options_group_type{
co::make_option(_LIT("CharT"),
co::basic_value<detail::check_char_t,detail::check_char_t>(),
_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("CharT"),static_cast<detail::check_char_t>('a'))
}
));
std::vector<const detail::check_char_t *> argv2{
_LIT("--CharT=aa"),
};
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("aa"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( short_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--short=11"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--short=foo"),
};
std::vector<const detail::check_char_t *> argv3{
_LIT("--short=3.14"),
};
std::vector<const detail::check_char_t *> argv4{
_LIT("--short=11 foo"),
};
options = options_group_type{
co::make_option(_LIT("short"),
co::basic_value<short,detail::check_char_t>(),_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("short"),static_cast<short>(11)),
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv3.data(),
argv3.data()+argv3.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("3.14"));
}
);
return true;
}
);
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv4.data(),
argv4.data()+argv4.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("11 foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( ushort_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--ushort=21"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--ushort=foo"),
};
options = options_group_type{
co::make_option(_LIT("ushort"),
co::basic_value<unsigned short,detail::check_char_t>(),_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("ushort"),static_cast<unsigned short>(21))
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( int_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--int=12"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--int=foo"),
};
options = options_group_type{
co::make_option(_LIT("int"),
co::basic_value<int,detail::check_char_t>(),_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("int"),static_cast<int>(12)),
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( uint_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--uint=22"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--uint=foo"),
};
options = options_group_type{
co::make_option(_LIT("uint"),
co::basic_value<unsigned int,detail::check_char_t>(),_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("uint"),static_cast<unsigned int>(22)),
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( long_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--long=13"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--long=foo"),
};
options = options_group_type{
co::make_option(_LIT("long"),
co::basic_value<long,detail::check_char_t>(),_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("long"),static_cast<long>(13)),
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( ulong_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--ulong=23"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--ulong=foo"),
};
options = options_group_type{
co::make_option(_LIT("ulong"),
co::basic_value<unsigned long,detail::check_char_t>(),_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("ulong"),static_cast<unsigned long>(23)),
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( longlong_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--longlong=14"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--longlong=foo"),
};
options = options_group_type{
co::make_option(_LIT("longlong"),
co::basic_value<long long,detail::check_char_t>(),_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("longlong"),static_cast<long long>(14)),
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( ulonglong_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--ulonglong=24"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--ulonglong=foo"),
};
options = options_group_type{
co::make_option(_LIT("ulonglong"),
co::basic_value<unsigned long long,detail::check_char_t>(),
_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("ulonglong"),
static_cast<unsigned long long>(24)),
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( float_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--float=5.1"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--float=foo"),
};
options = options_group_type{
co::make_option(_LIT("float"),
co::basic_value<float,detail::check_char_t>(),_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("float"),static_cast<float>(5.1),
detail::essentiallyEqual<float>()),
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( double_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--double=6.1"),
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--double=foo"),
};
options = options_group_type{
co::make_option(_LIT("double"),
co::basic_value<double,detail::check_char_t>(),_LIT("case 6")),
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("double"),static_cast<double>(6.1),
detail::essentiallyEqual<double>()),
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
BOOST_AUTO_TEST_CASE( long_double_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--longdouble=7.1")
};
std::vector<const detail::check_char_t *> argv2{
_LIT("--longdouble=foo"),
};
options = options_group_type{
co::make_option(_LIT("longdouble"),
co::basic_value<long double,detail::check_char_t>(),
_LIT("case 6"))
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("longdouble"),static_cast<long double>(7.1),
detail::essentiallyEqual<long double>())
}
));
BOOST_CHECK_EXCEPTION(co::parse_arguments(argv2.data(),
argv2.data()+argv2.size(),options),
co::invalid_argument_error, [](const co::invalid_argument_error &ex) {
BOOST_CHECK_EXCEPTION(std::rethrow_if_nested(ex),
std::invalid_argument, [](const std::invalid_argument &e) {
return (e.what() == std::string("foo"));
}
);
return true;
}
);
}
/**
Check all fundamental values for clash
*/
BOOST_AUTO_TEST_CASE( fundamental_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--CharT=a"),
_LIT("--short=11"),
_LIT("--ushort=21"),
_LIT("--int=12"),
_LIT("--uint=22"),
_LIT("--long=13"),
_LIT("--ulong=23"),
_LIT("--longlong=14"),
_LIT("--ulonglong=24"),
_LIT("--float=5.1"),
_LIT("--double=6.1"),
_LIT("--longdouble=7.1")
};
options = options_group_type{
co::make_option(_LIT("CharT"),
co::basic_value<detail::check_char_t,detail::check_char_t>(),
_LIT("case 6")),
co::make_option(_LIT("short"),
co::basic_value<short,detail::check_char_t>(),_LIT("case 6")),
co::make_option(_LIT("ushort"),
co::basic_value<unsigned short,detail::check_char_t>(),_LIT("case 6")),
co::make_option(_LIT("int"),
co::basic_value<int,detail::check_char_t>(),_LIT("case 6")),
co::make_option(_LIT("uint"),
co::basic_value<unsigned int,detail::check_char_t>(),_LIT("case 6")),
co::make_option(_LIT("long"),
co::basic_value<long,detail::check_char_t>(),_LIT("case 6")),
co::make_option(_LIT("ulong"),
co::basic_value<unsigned long,detail::check_char_t>(),_LIT("case 6")),
co::make_option(_LIT("longlong"),
co::basic_value<long long,detail::check_char_t>(),_LIT("case 6")),
co::make_option(_LIT("ulonglong"),
co::basic_value<unsigned long long,detail::check_char_t>(),
_LIT("case 6")),
co::make_option(_LIT("float"),
co::basic_value<float,detail::check_char_t>(),_LIT("case 6")),
co::make_option(_LIT("double"),
co::basic_value<double,detail::check_char_t>(),_LIT("case 6")),
co::make_option(_LIT("longdouble"),
co::basic_value<long double,detail::check_char_t>(),
_LIT("case 6"))
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("CharT"),static_cast<detail::check_char_t>('a')),
detail::check_value(_LIT("double"),static_cast<double>(6.1),
detail::essentiallyEqual<double>()),
detail::check_value(_LIT("float"),static_cast<float>(5.1),
detail::essentiallyEqual<float>()),
detail::check_value(_LIT("int"),static_cast<int>(12)),
detail::check_value(_LIT("long"),static_cast<long>(13)),
detail::check_value(_LIT("longdouble"),static_cast<long double>(7.1),
detail::essentiallyEqual<long double>()),
detail::check_value(_LIT("longlong"),static_cast<long long>(14)),
detail::check_value(_LIT("short"),static_cast<short>(11)),
detail::check_value(_LIT("uint"),static_cast<unsigned int>(22)),
detail::check_value(_LIT("ulong"),static_cast<unsigned long>(23)),
detail::check_value(_LIT("ulonglong"),
static_cast<unsigned long long>(24)),
detail::check_value(_LIT("ushort"),static_cast<unsigned short>(21))
}
));
}
BOOST_AUTO_TEST_CASE( string_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--string=Hello World")
};
options = options_group_type{
co::make_option(_LIT("string"),
co::basic_value<string_type,detail::check_char_t>(),
_LIT("case 6"))
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("string"),
static_cast<string_type>(_LIT("Hello World"))),
}
));
}
BOOST_AUTO_TEST_CASE( userdef_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--userdef=Hello World")
};
options = options_group_type{
co::make_option(_LIT("userdef"),
co::basic_value<co::userdef_struct,detail::check_char_t>(),
_LIT("case 6"))
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("userdef"),
static_cast<co::userdef_struct>(_LIT("Hello World"))),
}
));
}
BOOST_AUTO_TEST_CASE( userdef_convert_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--userdef=Hello World")
};
options = options_group_type{
co::make_option(_LIT("userdef"),
co::basic_value<co::userdef_convert_struct,detail::check_char_t>(),
_LIT("case 6"))
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("userdef"),
static_cast<co::userdef_convert_struct>(_LIT("Hello World"))),
}
));
}
BOOST_AUTO_TEST_CASE( userdef_custom_value_test )
{
variable_map_type vm;
options_group_type options;
std::vector<const detail::check_char_t *> argv{
_LIT("--userdef=Hello World"),
_LIT("--userdef2"),
};
co::userdef_cvt<string_type,detail::check_char_t> cvt;
options = options_group_type{
co::make_option(_LIT("userdef"),
co::basic_value<string_type,detail::check_char_t>()
.from_string(cvt)
.transform(&co::userdef_transform<detail::check_char_t>),
_LIT("case 6")),
co::make_option(_LIT("userdef2"),
co::basic_value<string_type,detail::check_char_t>()
.implicit(string_type(_LIT("foobar")))
.to_string(cvt),
_LIT("case 6"))
};
std::tie(std::ignore,vm) =
co::parse_arguments(argv.data(),argv.data()+argv.size(),options);
std::cerr << detail::to_string(vm,co::basic_value<string_type,detail::check_char_t>())
<< "\n";
BOOST_REQUIRE(detail::vm_check(vm,{
detail::check_value(_LIT("userdef"),
static_cast<string_type>(_LIT("dlroW olleHdlroW olleH"))),
detail::check_value(_LIT("userdef2"),
static_cast<string_type>(_LIT("foobar"))),
}
));
}
BOOST_AUTO_TEST_SUITE_END()
| 28.546306 | 152 | 0.654103 | tegtmeye |
4968673bfa0f63dcef4200d781306c8c9558e714 | 997 | cpp | C++ | 8PRO128-TP3/Cube.cpp | Hexzhe/8PRO128-TP3 | 24dc226465c7e216752ded07592a013e88e7e3e2 | [
"MIT"
] | null | null | null | 8PRO128-TP3/Cube.cpp | Hexzhe/8PRO128-TP3 | 24dc226465c7e216752ded07592a013e88e7e3e2 | [
"MIT"
] | null | null | null | 8PRO128-TP3/Cube.cpp | Hexzhe/8PRO128-TP3 | 24dc226465c7e216752ded07592a013e88e7e3e2 | [
"MIT"
] | null | null | null | #include "Cube.h"
Cube::Cube() : Carre()
{
}
Cube::Cube(double c) : Carre(c)
{
}
double Cube::aire() const
{
return 6 * Carre::aire();
}
double Cube::face() const
{
return Carre::aire();
}
double Cube::volume() const
{
return pow(Carre::largeur, 3);
}
void Cube::afficher(std::ostream& os) const
{
os << "Cube:" << std::endl;
os << this->getEntete() << std::endl;
os << std::setw(9) << std::setprecision(2) << std::fixed << this->Carre::largeur << " ";
os << std::setw(9) << std::setprecision(2) << std::fixed << this->aire() << " ";
os << std::setw(9) << std::setprecision(2) << std::fixed << this->face() << " ";
os << std::setw(9) << std::setprecision(2) << std::fixed << this->volume();
}
std::string Cube::getEntete()
{
return "cote aire face vol";
}
std::istream& operator>>(std::istream& is, Cube& cube)
{
is >> cube.largeur >> cube.longueur;
return is;
}
std::ostream& operator<<(std::ostream& os, const Cube& cube)
{
cube.afficher(os);
return os;
}
| 18.811321 | 89 | 0.584754 | Hexzhe |
496e7a5477cb415b4d3b490873c1fd81bdcb341c | 1,394 | hpp | C++ | src/visual-scripting/processors/math/trigonometric/TrigonometricProcessors.hpp | inexorgame/entity-system | 230a6f116fb02caeace79bc9b32f17fe08687c36 | [
"MIT"
] | 19 | 2018-10-11T09:19:48.000Z | 2020-04-19T16:36:58.000Z | src/visual-scripting/processors/math/trigonometric/TrigonometricProcessors.hpp | inexorgame-obsolete/entity-system-inactive | 230a6f116fb02caeace79bc9b32f17fe08687c36 | [
"MIT"
] | 132 | 2018-07-28T12:30:54.000Z | 2020-04-25T23:05:33.000Z | src/visual-scripting/processors/math/trigonometric/TrigonometricProcessors.hpp | inexorgame-obsolete/entity-system-inactive | 230a6f116fb02caeace79bc9b32f17fe08687c36 | [
"MIT"
] | 3 | 2019-03-02T16:19:23.000Z | 2020-02-18T05:15:29.000Z | #pragma once
#include "visual-scripting/processors/math/trigonometric/CosProcessor.hpp"
#include "visual-scripting/processors/math/trigonometric/SinProcessor.hpp"
#include "visual-scripting/processors/math/trigonometric/TanProcessor.hpp"
namespace inexor::visual_scripting {
using SinProcessorPtr = std::shared_ptr<SinProcessor>;
using CosProcessorPtr = std::shared_ptr<CosProcessor>;
using TanProcessorPtr = std::shared_ptr<TanProcessor>;
/// @class TrigonometricProcessors
/// @brief Management of the trigonometric processors.
class TrigonometricProcessors : public LifeCycleComponent
{
public:
/// @brief Constructs the trigonometric processors.
/// @note The dependencies of this class will be injected automatically.
/// @param sin_processor The sin generator.
/// @param cos_processor The cos generator.
/// @param tan_processor The tan generator.
TrigonometricProcessors(SinProcessorPtr sin_processor, CosProcessorPtr cos_processor, TanProcessorPtr tan_processor);
/// Destructor.
~TrigonometricProcessors();
/// Returns the name of the component
std::string get_component_name() override;
private:
/// The sin generator.
SinProcessorPtr sin_processor;
/// The cos generator.
CosProcessorPtr cos_processor;
/// The tan generator.
TanProcessorPtr tan_processor;
};
} // namespace inexor::visual_scripting
| 32.418605 | 121 | 0.763271 | inexorgame |
4974fd6e1e94bf2869e15e129f5e0999fed1378b | 1,711 | cpp | C++ | client/main.cpp | name1e5s/Trace-It | bb42ed21dc16b3fb5bfed3cb5592c9232c43ace2 | [
"WTFPL"
] | null | null | null | client/main.cpp | name1e5s/Trace-It | bb42ed21dc16b3fb5bfed3cb5592c9232c43ace2 | [
"WTFPL"
] | null | null | null | client/main.cpp | name1e5s/Trace-It | bb42ed21dc16b3fb5bfed3cb5592c9232c43ace2 | [
"WTFPL"
] | null | null | null | #include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include <QQmlEngine>
#include <QQuickStyle>
#include <client.h>
#include <table_model_user.h>
#include <table_model_word.h>
int main(int argc, char *argv[]) {
QGuiApplication app(argc, argv);
if (Client::Instance().SocketClient::connect()) {
UserTableModel userTableModel;
userTableModel.setColumn(5);
WordTableModel wordTableModel;
wordTableModel.setColumn(3);
qRegisterMetaType<QVector<QVector<QString>>>("QVector<QVector<QString>>");
QObject::connect(&Client::Instance(), &Client::updateUserTable,
&userTableModel, &UserTableModel::onModelUpdate);
QObject::connect(&Client::Instance(), &Client::updateWordTable,
&wordTableModel, &WordTableModel::onModelUpdate);
userTableModel.init();
wordTableModel.init();
QQuickStyle::setStyle("Material");
QQmlApplicationEngine engine;
qmlRegisterType<Client>("com.name1e5s.game", 1, 0, "Client");
engine.rootContext()->setContextProperty("game_client",
&Client::Instance());
engine.rootContext()->setContextProperty("userTableModel", &userTableModel);
engine.rootContext()->setContextProperty("wordTableModel", &wordTableModel);
qmlRegisterType<UserTableModel>("com.name1e5s.game", 1, 0,
"UserTableModel");
qmlRegisterType<WordTableModel>("com.name1e5s.game", 1, 0,
"WordTableModel");
engine.load(QUrl(QStringLiteral("qrc:/ui/ui/MemoryGame.qml")));
return app.exec();
} else {
qDebug() << "Connect to server failed.";
return 1;
}
}
| 38.886364 | 80 | 0.660432 | name1e5s |
497550b899bbf298f8b45c9805b7c9bfccd81308 | 4,094 | cpp | C++ | Engine/source/gui/editor/guiSeparatorCtrl.cpp | fr1tz/alux3d | 249a3b51751ce3184d52879b481f83eabe89e7e3 | [
"MIT"
] | 46 | 2015-01-05T17:34:43.000Z | 2022-01-04T04:03:09.000Z | Engine/source/gui/editor/guiSeparatorCtrl.cpp | fr1tz/alux3d | 249a3b51751ce3184d52879b481f83eabe89e7e3 | [
"MIT"
] | 10 | 2015-01-20T23:14:46.000Z | 2019-04-05T22:04:15.000Z | Engine/source/gui/editor/guiSeparatorCtrl.cpp | fr1tz/terminal-overload | 85f0689a40022e5eb7e54dcb6ddfb5ddd82a0a60 | [
"CC-BY-4.0"
] | 9 | 2015-08-08T18:46:06.000Z | 2021-02-01T13:53:20.000Z | // Copyright information can be found in the file named COPYING
// located in the root directory of this distribution.
#include "platform/platform.h"
#include "gui/editor/guiSeparatorCtrl.h"
#include "gfx/gfxDevice.h"
#include "gfx/gfxDrawUtil.h"
#include "console/console.h"
#include "console/consoleTypes.h"
#include "gui/core/guiCanvas.h"
#include "gui/core/guiDefaultControlRender.h"
IMPLEMENT_CONOBJECT(GuiSeparatorCtrl);
ConsoleDocClass( GuiSeparatorCtrl,
"@brief A control that renders a horizontal or vertical separator with "
"an optional text label (horizontal only)\n\n"
"@tsexample\n"
"new GuiSeparatorCtrl()\n"
"{\n"
" profile = \"GuiDefaultProfile\";\n"
" position = \"505 0\";\n"
" extent = \"10 17\";\n"
" minExtent = \"10 17\";\n"
" canSave = \"1\";\n"
" visible = \"1\";\n"
" horizSizing = \"left\";\n"
"};\n"
"@endtsexample\n\n"
"@ingroup GuiControls\n");
ImplementEnumType( GuiSeparatorType,
"GuiSeparatorCtrl orientations\n\n"
"@ingroup GuiControls" )
{ GuiSeparatorCtrl::separatorTypeVertical, "Vertical" },
{ GuiSeparatorCtrl::separatorTypeHorizontal,"Horizontal" }
EndImplementEnumType;
//--------------------------------------------------------------------------
GuiSeparatorCtrl::GuiSeparatorCtrl() : GuiControl()
{
mInvisible = false;
mTextLeftMargin = 0;
mMargin = 2;
setExtent( 12, 35 );
mSeparatorType = GuiSeparatorCtrl::separatorTypeVertical;
}
//--------------------------------------------------------------------------
void GuiSeparatorCtrl::initPersistFields()
{
addField("caption", TypeRealString, Offset(mText, GuiSeparatorCtrl),
"Optional text label to display." );
addField("type", TYPEID< separatorTypeOptions >(), Offset(mSeparatorType, GuiSeparatorCtrl),
"Orientation of separator." );
addField("borderMargin", TypeS32, Offset(mMargin, GuiSeparatorCtrl));
addField("invisible", TypeBool, Offset(mInvisible, GuiSeparatorCtrl));// Nonsense. Should use GuiControl's visibility.
addField("leftMargin", TypeS32, Offset(mTextLeftMargin, GuiSeparatorCtrl),
"Left margin of text label." );
Parent::initPersistFields();
}
//--------------------------------------------------------------------------
void GuiSeparatorCtrl::onRender(Point2I offset, const RectI &updateRect)
{
Parent::onRender( offset, updateRect );
if( mInvisible )
return;
if( mText.isNotEmpty() && mSeparatorType != separatorTypeVertical )
{
// If text is present and we have a left margin, then draw some separator, then the
// text, and then the rest of the separator.
S32 posx = offset.x + mMargin;
S32 fontheight = mProfile->mFont->getHeight();
S32 seppos = (fontheight - 2) / 2 + offset.y;
if( mTextLeftMargin > 0 )
{
RectI rect( Point2I( posx, seppos ), Point2I( mTextLeftMargin, 2 ) );
renderSlightlyLoweredBox(rect, mProfile);
posx += mTextLeftMargin;
}
GFX->getDrawUtil()->setBitmapModulation( mProfile->mFontColor );
posx = GFX->getDrawUtil()->drawText(mProfile->mFont, Point2I(posx,offset.y), mText, mProfile->mFontColors);
RectI rect( Point2I( posx, seppos ), Point2I( getWidth() - posx + offset.x, 2 ) );
// Space text and separator a bit apart at right end.
rect.point.x += 2;
rect.extent.x -= 2;
if( rect.extent.x > 0 )
renderSlightlyLoweredBox( rect, mProfile );
}
else
{
if( mSeparatorType == separatorTypeHorizontal )
{
S32 seppos = getHeight() / 2 + offset.y;
RectI rect(Point2I(offset.x + mMargin ,seppos),Point2I(getWidth() - (mMargin * 2),2));
renderSlightlyLoweredBox(rect, mProfile);
}
else
{
S32 seppos = getWidth() / 2 + offset.x;
RectI rect(Point2I(seppos, offset.y + mMargin),Point2I(2, getHeight() - (mMargin * 2)));
renderSlightlyLoweredBox(rect, mProfile);
}
}
renderChildControls(offset, updateRect);
}
| 33.016129 | 134 | 0.616268 | fr1tz |
4977978f702f2eed6831ad916e1378d2eeff5c35 | 1,043 | hpp | C++ | include/usb_asio/asio.hpp | MiSo1289/usb-asio | cd6aac7b9bfad1c617aa0e6d1eefeea8b00cfcdf | [
"MIT"
] | 47 | 2020-08-24T17:53:04.000Z | 2022-03-11T16:03:22.000Z | include/usb_asio/asio.hpp | MiSo1289/usb-asio | cd6aac7b9bfad1c617aa0e6d1eefeea8b00cfcdf | [
"MIT"
] | null | null | null | include/usb_asio/asio.hpp | MiSo1289/usb-asio | cd6aac7b9bfad1c617aa0e6d1eefeea8b00cfcdf | [
"MIT"
] | null | null | null | #pragma once
#ifdef USB_ASIO_USE_STANDALONE_ASIO
#include <system_error>
#include <asio/any_io_executor.hpp>
#include <asio/async_result.hpp>
#include <asio/buffer.hpp>
#include <asio/execution_context.hpp>
#include <asio/io_context.hpp>
#include <asio/post.hpp>
#else
#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/async_result.hpp>
#include <boost/asio/buffer.hpp>
#include <boost/asio/execution_context.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/post.hpp>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>
#endif
namespace usb_asio
{
#ifdef USB_ASIO_USE_STANDALONE_ASIO
namespace asio = ::asio;
using error_code = std::error_code;
using error_category = std::error_category;
using system_error = std::system_error;
#else
namespace asio = boost::asio;
using error_code = boost::system::error_code;
using error_category = boost::system::error_category;
using system_error = boost::system::system_error;
#endif
} // namespace usb_asio
| 24.255814 | 57 | 0.759348 | MiSo1289 |
4977abe2470f73cf156380faef231cc60f016cdb | 618 | cpp | C++ | Junior_Core/Src/Source/GameSystem.cpp | DeltaGoldenFlag/JuniorEngine | 9581f863d5bd412a4ab48b7ea893151798829856 | [
"BSD-3-Clause"
] | 1 | 2019-06-13T00:14:02.000Z | 2019-06-13T00:14:02.000Z | Junior_Core/Src/Source/GameSystem.cpp | DeltaGoldenFlag/JuniorEngine | 9581f863d5bd412a4ab48b7ea893151798829856 | [
"BSD-3-Clause"
] | null | null | null | Junior_Core/Src/Source/GameSystem.cpp | DeltaGoldenFlag/JuniorEngine | 9581f863d5bd412a4ab48b7ea893151798829856 | [
"BSD-3-Clause"
] | null | null | null | /*
* Author: David Wong
* Email: [email protected]
* File name: GameSystem.cpp
* Description: Defines a general manner to organize all the systems
* Created: 18-Dec-2018
* Last Modified: 18-Dec-2018
*/
// Includes
#include "GameSystem.h"
#include <iostream> // Output stream
// Public Member Functions
namespace Junior
{
GameSystem::GameSystem(const char* name)
: name_(name)
{}
void GameSystemAssert(bool success, const char* errorMessage)
{
if (!success)
{
std::cout << "[ERROR]: " << errorMessage << std::endl;
}
}
const char* GameSystem::GetName() const
{
return name_;
}
} | 18.176471 | 67 | 0.687702 | DeltaGoldenFlag |
4978a415b1118ac8fe42ba3a6e56d732ae933c64 | 459 | hpp | C++ | src/algorithms/euler/problem9.hpp | iamantony/CppNotes | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | [
"MIT"
] | 2 | 2020-07-31T14:13:56.000Z | 2021-02-03T09:51:43.000Z | src/algorithms/euler/problem9.hpp | iamantony/CppNotes | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | [
"MIT"
] | 28 | 2015-09-22T07:38:21.000Z | 2018-10-02T11:00:58.000Z | src/algorithms/euler/problem9.hpp | iamantony/CppNotes | 2707db6560ad80b0e5e286a04b2d46e5c0280b3f | [
"MIT"
] | 2 | 2018-10-11T14:10:50.000Z | 2021-02-27T08:53:50.000Z | #ifndef PROBLEM9_H_
#define PROBLEM9_H_
#include "problem.hpp"
// Problem 9:
// A Pythagorean triplet is a set of three natural numbers, a < b < c,
// for which a^2 + b^2 = c^2
// For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
// There exists exactly one Pythagorean triplet for which a + b + c = 1000.
// Find the product abc.
class Problem9 : public Problem
{
// == METHODS ==
private:
virtual void DoSolve() override;
};
#endif /* PROBLEM9_H_ */
| 20.863636 | 75 | 0.64488 | iamantony |
4979ee93a9e60b56119769aeaf61c4f545e3f578 | 6,761 | hpp | C++ | src/lib/nas/ie1.hpp | aligungr/ue-ran-sim | 564f9d228723f03adfa2b02df2ea019bdf305085 | [
"MIT"
] | 16 | 2020-04-16T02:07:37.000Z | 2020-07-23T10:48:27.000Z | src/lib/nas/ie1.hpp | aligungr/ue-ran-sim | 564f9d228723f03adfa2b02df2ea019bdf305085 | [
"MIT"
] | 8 | 2020-07-13T17:11:35.000Z | 2020-08-03T16:46:31.000Z | src/lib/nas/ie1.hpp | aligungr/ue-ran-sim | 564f9d228723f03adfa2b02df2ea019bdf305085 | [
"MIT"
] | 9 | 2020-03-04T15:05:08.000Z | 2020-07-30T06:18:18.000Z | //
// This file is a part of UERANSIM open source project.
// Copyright (c) 2021 ALİ GÜNGÖR.
//
// The software and all associated files are licensed under GPL-3.0
// and subject to the terms and conditions defined in LICENSE file.
//
#pragma once
#include "base.hpp"
#include "enums.hpp"
#include <utils/octet_string.hpp>
#include <utils/octet_view.hpp>
namespace nas
{
struct IE5gsIdentityType : InformationElement1
{
EIdentityType value{};
IE5gsIdentityType() = default;
explicit IE5gsIdentityType(EIdentityType value);
static IE5gsIdentityType Decode(int val);
static int Encode(const IE5gsIdentityType &ie);
};
struct IE5gsRegistrationType : InformationElement1
{
EFollowOnRequest followOnRequestPending{};
ERegistrationType registrationType{};
IE5gsRegistrationType() = default;
IE5gsRegistrationType(EFollowOnRequest followOnRequestPending, ERegistrationType registrationType);
static IE5gsRegistrationType Decode(int val);
static int Encode(const IE5gsRegistrationType &ie);
};
struct IEAccessType : InformationElement1
{
EAccessType value{};
IEAccessType() = default;
explicit IEAccessType(EAccessType value);
static IEAccessType Decode(int val);
static int Encode(const IEAccessType &ie);
};
struct IEAllowedSscMode : InformationElement1
{
ESsc1 ssc1{};
ESsc2 ssc2{};
ESsc3 ssc3{};
IEAllowedSscMode() = default;
IEAllowedSscMode(ESsc1 ssc1, ESsc2 ssc2, ESsc3 ssc3);
static IEAllowedSscMode Decode(int val);
static int Encode(const IEAllowedSscMode &ie);
};
struct IEAlwaysOnPduSessionIndication : InformationElement1
{
EAlwaysOnPduSessionIndication value{};
IEAlwaysOnPduSessionIndication() = default;
explicit IEAlwaysOnPduSessionIndication(EAlwaysOnPduSessionIndication value);
static IEAlwaysOnPduSessionIndication Decode(int val);
static int Encode(const IEAlwaysOnPduSessionIndication &ie);
};
struct IEAlwaysOnPduSessionRequested : InformationElement1
{
EAlwaysOnPduSessionRequested value{};
IEAlwaysOnPduSessionRequested() = default;
explicit IEAlwaysOnPduSessionRequested(EAlwaysOnPduSessionRequested value);
static IEAlwaysOnPduSessionRequested Decode(int val);
static int Encode(const IEAlwaysOnPduSessionRequested &ie);
};
struct IEConfigurationUpdateIndication : InformationElement1
{
EAcknowledgement ack{};
ERegistrationRequested red{};
IEConfigurationUpdateIndication() = default;
IEConfigurationUpdateIndication(EAcknowledgement ack, ERegistrationRequested red);
static IEConfigurationUpdateIndication Decode(int val);
static int Encode(const IEConfigurationUpdateIndication &ie);
};
struct IEDeRegistrationType : InformationElement1
{
EDeRegistrationAccessType accessType{};
EReRegistrationRequired reRegistrationRequired{}; // This bit is spare in UE to Network direction
ESwitchOff switchOff{};
IEDeRegistrationType() = default;
IEDeRegistrationType(EDeRegistrationAccessType accessType, EReRegistrationRequired reRegistrationRequired,
ESwitchOff switchOff);
static IEDeRegistrationType Decode(int val);
static int Encode(const IEDeRegistrationType &ie);
};
struct IEImeiSvRequest : InformationElement1
{
EImeiSvRequest imeiSvRequest{};
IEImeiSvRequest() = default;
explicit IEImeiSvRequest(EImeiSvRequest imeiSvRequest);
static IEImeiSvRequest Decode(int val);
static int Encode(const IEImeiSvRequest &ie);
};
struct IEMicoIndication : InformationElement1
{
ERegistrationAreaAllocationIndication raai{};
IEMicoIndication() = default;
explicit IEMicoIndication(ERegistrationAreaAllocationIndication raai);
static IEMicoIndication Decode(int val);
static int Encode(const IEMicoIndication &ie);
};
struct IENasKeySetIdentifier : InformationElement1
{
static constexpr const int NOT_AVAILABLE_OR_RESERVED = 0b111;
ETypeOfSecurityContext tsc{};
int ksi = NOT_AVAILABLE_OR_RESERVED;
IENasKeySetIdentifier() = default;
IENasKeySetIdentifier(ETypeOfSecurityContext tsc, int ksi);
static IENasKeySetIdentifier Decode(int val);
static int Encode(const IENasKeySetIdentifier &ie);
};
struct IENetworkSlicingIndication : InformationElement1
{
ENetworkSlicingSubscriptionChangeIndication nssci{}; // This is spare if dir is UE->NW
EDefaultConfiguredNssaiIndication dcni{}; // This is spare if dir is NW->UE
IENetworkSlicingIndication() = default;
IENetworkSlicingIndication(ENetworkSlicingSubscriptionChangeIndication nssci,
EDefaultConfiguredNssaiIndication dcni);
static IENetworkSlicingIndication Decode(int val);
static int Encode(const IENetworkSlicingIndication &ie);
};
struct IENssaiInclusionMode : InformationElement1
{
ENssaiInclusionMode nssaiInclusionMode{};
IENssaiInclusionMode() = default;
explicit IENssaiInclusionMode(ENssaiInclusionMode nssaiInclusionMode);
static IENssaiInclusionMode Decode(int val);
static int Encode(const IENssaiInclusionMode &ie);
};
struct IEPayloadContainerType : InformationElement1
{
EPayloadContainerType payloadContainerType{};
IEPayloadContainerType() = default;
explicit IEPayloadContainerType(EPayloadContainerType payloadContainerType);
static IEPayloadContainerType Decode(int val);
static int Encode(const IEPayloadContainerType &ie);
};
struct IEPduSessionType : InformationElement1
{
EPduSessionType pduSessionType{};
IEPduSessionType() = default;
explicit IEPduSessionType(EPduSessionType pduSessionType);
static IEPduSessionType Decode(int val);
static int Encode(const IEPduSessionType &ie);
};
struct IERequestType : InformationElement1
{
ERequestType requestType{};
IERequestType() = default;
explicit IERequestType(ERequestType requestType);
static IERequestType Decode(int val);
static int Encode(const IERequestType &ie);
};
struct IEServiceType : InformationElement1
{
EServiceType serviceType{};
IEServiceType() = default;
explicit IEServiceType(EServiceType serviceType);
static IEServiceType Decode(int val);
static int Encode(const IEServiceType &ie);
};
struct IESmsIndication : InformationElement1
{
ESmsAvailabilityIndication sai{};
IESmsIndication() = default;
explicit IESmsIndication(ESmsAvailabilityIndication sai);
static IESmsIndication Decode(int val);
static int Encode(const IESmsIndication &ie);
};
struct IESscMode : InformationElement1
{
ESscMode sscMode{};
IESscMode() = default;
explicit IESscMode(ESscMode sscMode);
static IESscMode Decode(int val);
static int Encode(const IESscMode &ie);
};
} // namespace nas | 28.053942 | 110 | 0.764976 | aligungr |
21a5c6417add5f5d863eb9c0712ad1dcdeeb3127 | 348 | cpp | C++ | common/source/string.cpp | xrEngine512/interop | c80711fbbe08f350ad5d8058163770f57ed20b0c | [
"MIT"
] | null | null | null | common/source/string.cpp | xrEngine512/interop | c80711fbbe08f350ad5d8058163770f57ed20b0c | [
"MIT"
] | 4 | 2017-05-31T12:34:10.000Z | 2018-10-13T18:53:03.000Z | common/source/string.cpp | xrEngine512/MosaicFramework | c80711fbbe08f350ad5d8058163770f57ed20b0c | [
"MIT"
] | 1 | 2020-04-23T14:09:11.000Z | 2020-04-23T14:09:11.000Z | #include "utils/string.h"
#include <boost/algorithm/string/regex.hpp>
using namespace std;
namespace interop {
namespace utils {
vector<string> split_rx(const string & str, const string & del)
{
vector<string> res;
boost::algorithm::split_regex(res, str, boost::regex(del));
return res;
}
} // namespace utils
} // namespace interop
| 20.470588 | 63 | 0.70977 | xrEngine512 |
21a7643c6dea6f0ff48c691aec2051bcd2d40c32 | 6,681 | cpp | C++ | src/binding.cpp | oprypin/crystal-imgui-sfml | 0e9662bf5e2b4373d32048b07df0daf53180274e | [
"MIT"
] | 11 | 2020-10-02T15:36:21.000Z | 2021-11-16T03:17:40.000Z | src/binding.cpp | oprypin/crystal-imgui-sfml | 0e9662bf5e2b4373d32048b07df0daf53180274e | [
"MIT"
] | 2 | 2021-02-12T15:04:38.000Z | 2021-02-22T22:59:06.000Z | src/binding.cpp | oprypin/crystal-imgui-sfml | 0e9662bf5e2b4373d32048b07df0daf53180274e | [
"MIT"
] | 1 | 2021-03-20T19:59:02.000Z | 2021-03-20T19:59:02.000Z | #include <imgui-SFML.h>
#include <SFML/Graphics/Color.hpp>
#include <SFML/Graphics/Rect.hpp>
#include <SFML/Graphics/RenderTexture.hpp>
#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/Graphics/Sprite.hpp>
#include <SFML/Graphics/Texture.hpp>
#include <SFML/System/Time.hpp>
#include <SFML/System/Vector2.hpp>
#include <SFML/Window/Event.hpp>
#include <SFML/Window/Joystick.hpp>
#include <SFML/Window/Window.hpp>
extern "C" {
void ImGui_SFML_InitW(sf::RenderWindow* window, bool loadDefaultFont) {
ImGui::SFML::Init(*window, loadDefaultFont);
}
void ImGui_SFML_InitWT(sf::Window* window, sf::RenderTexture* target, bool loadDefaultFont) {
ImGui::SFML::Init(*window, *target, loadDefaultFont);
}
void ImGui_SFML_InitWW(sf::Window* window, sf::RenderWindow* target, bool loadDefaultFont) {
ImGui::SFML::Init(*window, *target, loadDefaultFont);
}
void ImGui_SFML_InitWV(sf::Window* window, const sf::Vector2f* displaySize, bool loadDefaultFont) {
ImGui::SFML::Init(*window, *displaySize, loadDefaultFont);
}
void ImGui_SFML_ProcessEvent(const sf::Event* event) {
ImGui::SFML::ProcessEvent(*event);
}
void ImGui_SFML_UpdateW(sf::RenderWindow* window, const sf::Time* dt) {
ImGui::SFML::Update(*window, *dt);
}
void ImGui_SFML_UpdateWT(sf::Window* window, sf::RenderTexture* target, const sf::Time* dt) {
ImGui::SFML::Update(*window, *target, *dt);
}
void ImGui_SFML_UpdateWW(sf::Window* window, sf::RenderWindow* target, const sf::Time* dt) {
ImGui::SFML::Update(*window, *target, *dt);
}
void ImGui_SFML_UpdateVV(const sf::Vector2i* mousePos, const sf::Vector2f* displaySize, const sf::Time* dt) {
ImGui::SFML::Update(*mousePos, *displaySize, *dt);
}
void ImGui_SFML_RenderT(sf::RenderTexture* target) {
ImGui::SFML::Render(*target);
}
void ImGui_SFML_RenderW(sf::RenderWindow* target) {
ImGui::SFML::Render(*target);
}
void ImGui_SFML_Render() {
ImGui::SFML::Render();
}
void ImGui_SFML_Shutdown() {
ImGui::SFML::Shutdown();
}
void ImGui_SFML_UpdateFontTexture() {
ImGui::SFML::UpdateFontTexture();
}
sf::Texture* ImGui_SFML_GetFontTexture() {
return &ImGui::SFML::GetFontTexture();
}
void ImGui_SFML_SetActiveJoystickId(unsigned int joystickId) {
ImGui::SFML::SetActiveJoystickId(joystickId);
}
void ImGui_SFML_SetJoytickDPadThreshold(float threshold) {
ImGui::SFML::SetJoytickDPadThreshold(threshold);
}
void ImGui_SFML_SetJoytickLStickThreshold(float threshold) {
ImGui::SFML::SetJoytickLStickThreshold(threshold);
}
void ImGui_SFML_SetJoystickMapping(int action, unsigned int joystickButton) {
ImGui::SFML::SetJoystickMapping(action, joystickButton);
}
void ImGui_SFML_SetDPadXAxis(sf::Joystick::Axis dPadXAxis, bool inverted) {
ImGui::SFML::SetDPadXAxis(dPadXAxis, inverted);
}
void ImGui_SFML_SetDPadYAxis(sf::Joystick::Axis dPadYAxis, bool inverted) {
ImGui::SFML::SetDPadYAxis(dPadYAxis, inverted);
}
void ImGui_SFML_SetLStickXAxis(sf::Joystick::Axis lStickXAxis, bool inverted) {
ImGui::SFML::SetLStickXAxis(lStickXAxis, inverted);
}
void ImGui_SFML_SetLStickYAxis(sf::Joystick::Axis lStickYAxis, bool inverted) {
ImGui::SFML::SetLStickYAxis(lStickYAxis, inverted);
}
void ImGui_ImageTCC(const sf::Texture* texture, const sf::Color* tintColor, const sf::Color* borderColor) {
ImGui::Image(*texture, *tintColor, *borderColor);
}
void ImGui_ImageTVCC(const sf::Texture* texture, const sf::Vector2f* size, const sf::Color* tintColor, const sf::Color* borderColor) {
ImGui::Image(*texture, *size, *tintColor, *borderColor);
}
void ImGui_ImageRCC(const sf::RenderTexture* texture, const sf::Color* tintColor, const sf::Color* borderColor) {
ImGui::Image(*texture, *tintColor, *borderColor);
}
void ImGui_ImageRVCC(const sf::RenderTexture* texture, const sf::Vector2f* size, const sf::Color* tintColor, const sf::Color* borderColor) {
ImGui::Image(*texture, *size, *tintColor, *borderColor);
}
void ImGui_ImageSCC(const sf::Sprite* sprite, const sf::Color* tintColor, const sf::Color* borderColor) {
ImGui::Image(*sprite, *tintColor, *borderColor);
}
void ImGui_ImageSVCC(const sf::Sprite* sprite, const sf::Vector2f* size, const sf::Color* tintColor, const sf::Color* borderColor) {
ImGui::Image(*sprite, *size, *tintColor, *borderColor);
}
bool ImGui_ImageButtonTICC(const sf::Texture* texture, const int framePadding, const sf::Color* bgColor, const sf::Color* tintColor) {
return ImGui::ImageButton(*texture, framePadding, *bgColor, *tintColor);
}
bool ImGui_ImageButtonTVICC(const sf::Texture* texture, const sf::Vector2f* size, const int framePadding, const sf::Color* bgColor, const sf::Color* tintColor) {
return ImGui::ImageButton(*texture, *size, framePadding, *bgColor, *tintColor);
}
bool ImGui_ImageButtonRICC(const sf::RenderTexture* texture, const int framePadding, const sf::Color* bgColor, const sf::Color* tintColor) {
return ImGui::ImageButton(*texture, framePadding, *bgColor, *tintColor);
}
bool ImGui_ImageButtonRVICC(const sf::RenderTexture* texture, const sf::Vector2f* size, const int framePadding, const sf::Color* bgColor, const sf::Color* tintColor) {
return ImGui::ImageButton(*texture, *size, framePadding, *bgColor, *tintColor);
}
bool ImGui_ImageButtonSICC(const sf::Sprite* sprite, const int framePadding, const sf::Color* bgColor, const sf::Color* tintColor) {
return ImGui::ImageButton(*sprite, framePadding, *bgColor, *tintColor);
}
bool ImGui_ImageButtonSVICC(const sf::Sprite* sprite, const sf::Vector2f* size, const int framePadding, const sf::Color* bgColor, const sf::Color* tintColor) {
return ImGui::ImageButton(*sprite, *size, framePadding, *bgColor, *tintColor);
}
void ImGui_DrawLine(const sf::Vector2f* a, const sf::Vector2f* b, const sf::Color* col, float thickness) {
ImGui::DrawLine(*a, *b, *col, thickness);
}
void ImGui_DrawRect(const sf::FloatRect* rect, const sf::Color* color, float rounding, int rounding_corners, float thickness) {
ImGui::DrawRect(*rect, *color, rounding, rounding_corners, thickness);
}
void ImGui_DrawRectFilled(const sf::FloatRect* rect, const sf::Color* color, float rounding, int rounding_corners) {
ImGui::DrawRectFilled(*rect, *color, rounding, rounding_corners);
}
}
| 46.395833 | 171 | 0.695405 | oprypin |
21aa1147898f0a2c1be931be70ca0be7a351365b | 6,299 | inl | C++ | arrays/Deque.Iterator.inl | FinIsOro/array | 23489b305b3e728281f0eec99c7cb5fe941e1953 | [
"MIT"
] | null | null | null | arrays/Deque.Iterator.inl | FinIsOro/array | 23489b305b3e728281f0eec99c7cb5fe941e1953 | [
"MIT"
] | null | null | null | arrays/Deque.Iterator.inl | FinIsOro/array | 23489b305b3e728281f0eec99c7cb5fe941e1953 | [
"MIT"
] | null | null | null | namespace arrays
{
template<class T, size_t block>
Deque<T, block>::Iterator::Iterator(Deque::Block *start, Deque::Offset offset, size_t index) :
index(index),
current(start),
offset(offset)
{ }
template<class T, size_t block>
Deque<T, block>::Iterator::Iterator(Deque::Block *start, Deque::Offset offset) :
index(offset.left + 1),
current(start),
offset(offset)
{ }
template<class T, size_t block>
Deque<T, block>::Iterator::Iterator(const Deque::Iterator &iterator) :
index(iterator.index),
current(iterator.current),
offset(iterator.offset)
{ }
template<class T, size_t block>
void Deque<T, block>::Iterator::next(bool right)
{
if (current->right != nullptr)
{
current = current->right;
reset(right);
}
else
index = offset.right;
}
template<class T, size_t block>
void Deque<T, block>::Iterator::prev(bool right)
{
if (current->left != nullptr)
{
current = current->left;
reset(right);
}
else
index = offset.left;
}
template<class T, size_t block>
size_t Deque<T, block>::Iterator::rest(bool right)
{
if (right)
{
if (current->right == nullptr)
return offset.right - index;
return block - index;
}
if (current->left == nullptr)
return index + 1 - offset.left;
return index + 1;
}
template<class T, size_t block>
void Deque<T, block>::Iterator::reset(bool right)
{
if (right)
if (current->right == nullptr)
index = offset.right - 1;
else
index = block - 1;
else if (current->left == nullptr)
index = offset.left + 1;
else
index = 0;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator::pointer Deque<T, block>::Iterator::address()
{
return current->cache + index;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator::reference Deque<T, block>::Iterator::operator*()
{
return *(current->cache + index);
}
template<class T, size_t block>
typename Deque<T, block>::Iterator::pointer Deque<T, block>::Iterator::operator->()
{
return current->cache + index;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator &Deque<T, block>::Iterator::operator++()
{
if (current->right != nullptr || current->right == nullptr && index < offset.right)
index++;
if (index >= block && current->right != nullptr)
{
index = 0;
current = current->right;
}
return *this;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator Deque<T, block>::Iterator::operator++(int)
{
Iterator temp = *this;
++(*this);
return temp;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator &Deque<T, block>::Iterator::operator+=(int offset)
{
size_t length;
if (offset > 0)
while ((length = rest()) != 0 && offset > 0)
{
offset -= length;
if (length != block)
index += length;
if (offset < 0)
index += offset;
else
next();
}
else
while ((length = rest(false)) != 0 && offset < 0)
{
offset += length;
if (length != block)
index -= length;
if (offset > 0)
index += offset;
else
prev();
}
return *this;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator Deque<T, block>::Iterator::operator+(int offset)
{
Iterator result = *this;
result += offset;
return result;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator &Deque<T, block>::Iterator::operator--()
{
if (current->left != nullptr || current->left == nullptr && index > offset.left)
index--;
if (index == SIZE_MAX && current->left != nullptr)
{
index = block - 1;
current = current->left;
}
return *this;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator Deque<T, block>::Iterator::operator--(int)
{
Iterator temp = *this;
--(*this);
return temp;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator &Deque<T, block>::Iterator::operator-=(int offset)
{
size_t length;
if (offset > 0)
while ((length = rest(false)) != 0 && offset > 0)
{
offset -= length;
if (length != block)
index -= length;
if (offset < 0)
index -= offset;
else
prev();
}
else
while ((length = rest()) != 0 && offset < 0)
{
offset += length;
if (length != block)
index += length;
if (offset > 0)
index -= offset;
else
next();
}
return *this;
}
template<class T, size_t block>
typename Deque<T, block>::Iterator Deque<T, block>::Iterator::operator-(int offset)
{
Iterator result = *this;
result -= offset;
return result;
}
template<class T, size_t block>
bool Deque<T, block>::Iterator::operator==(const Deque::Iterator &another) const
{
return current == another.current && index == another.index;
}
template<class T, size_t block>
bool Deque<T, block>::Iterator::operator!=(const Deque::Iterator &another) const
{
return current != another.current || index != another.index;
}
} | 24.897233 | 98 | 0.493888 | FinIsOro |
21ad3b2e82a27c5dcf1b0cac668b977673e8c5c0 | 950 | cpp | C++ | Source/RTS/Plugins/RTSPlugin/Source/RTSPlugin/Private/RTSCharacter.cpp | ajbetteridge/ue4-rts | d7923fa694f6b6a04d8301a65019f85512fcb359 | [
"MIT"
] | 3 | 2020-08-24T03:36:07.000Z | 2021-12-28T03:40:02.000Z | Source/RTS/Plugins/RTSPlugin/Source/RTSPlugin/Private/RTSCharacter.cpp | ajbetteridge/ue4-rts | d7923fa694f6b6a04d8301a65019f85512fcb359 | [
"MIT"
] | null | null | null | Source/RTS/Plugins/RTSPlugin/Source/RTSPlugin/Private/RTSCharacter.cpp | ajbetteridge/ue4-rts | d7923fa694f6b6a04d8301a65019f85512fcb359 | [
"MIT"
] | 1 | 2021-12-28T03:40:04.000Z | 2021-12-28T03:40:04.000Z | #include "RTSPluginPCH.h"
#include "RTSCharacter.h"
#include "WorldCollision.h"
#include "Components/CapsuleComponent.h"
#include "Components/DecalComponent.h"
#include "GameFramework/Controller.h"
#include "Kismet/GameplayStatics.h"
#include "Net/UnrealNetwork.h"
#include "RTSAttackData.h"
#include "RTSGameMode.h"
#include "RTSHealthComponent.h"
#include "RTSSelectableComponent.h"
ARTSCharacter::ARTSCharacter()
{
// Enable replication.
bReplicates = true;
}
float ARTSCharacter::TakeDamage(float Damage, struct FDamageEvent const& DamageEvent, AController* EventInstigator, AActor* DamageCauser)
{
float ActualDamage = Super::TakeDamage(Damage, DamageEvent, EventInstigator, DamageCauser);
// Adjust health.
URTSHealthComponent* HealthComponent = FindComponentByClass<URTSHealthComponent>();
if (!HealthComponent)
{
return 0.0f;
}
return HealthComponent->TakeDamage(ActualDamage, DamageEvent, EventInstigator, DamageCauser);
}
| 26.388889 | 137 | 0.790526 | ajbetteridge |
21b4b5f0afb26ecdff69b6d9588a1460c0eca3ca | 7,550 | hpp | C++ | source/modules/solver/sampler/HMC/helpers/hamiltonian_riemannian_const_diag.hpp | JonathanLehner/korali | 90f97d8e2fed2311f988f39cfe014f23ba7dd6cf | [
"MIT"
] | 43 | 2018-07-26T07:20:42.000Z | 2022-03-02T10:23:12.000Z | source/modules/solver/sampler/HMC/helpers/hamiltonian_riemannian_const_diag.hpp | JonathanLehner/korali | 90f97d8e2fed2311f988f39cfe014f23ba7dd6cf | [
"MIT"
] | 212 | 2018-09-21T10:44:07.000Z | 2022-03-22T14:33:05.000Z | source/modules/solver/sampler/HMC/helpers/hamiltonian_riemannian_const_diag.hpp | JonathanLehner/korali | 90f97d8e2fed2311f988f39cfe014f23ba7dd6cf | [
"MIT"
] | 16 | 2018-07-25T15:00:36.000Z | 2022-03-22T14:19:46.000Z | #ifndef HAMILTONIAN_RIEMANNIAN_CONST_DIAG_H
#define HAMILTONIAN_RIEMANNIAN_CONST_DIAG_H
#include "hamiltonian_riemannian_base.hpp"
#include "modules/distribution/univariate/normal/normal.hpp"
namespace korali
{
namespace solver
{
namespace sampler
{
/**
* \class HamiltonianRiemannianConstDiag
* @brief Used for diagonal Riemannian metric.
*/
class HamiltonianRiemannianConstDiag : public HamiltonianRiemannian
{
public:
/**
* @brief Constructor with State Space Dim.
* @param stateSpaceDim Dimension of State Space.
* @param normalGenerator Generator needed for momentum sampling.
* @param inverseRegularizationParam Inverse regularization parameter of SoftAbs metric that controls hardness of approximation: For large values inverseMetric is closer to analytical formula (and therefore closer to degeneracy in certain cases).
* @param k Pointer to Korali object.
*/
HamiltonianRiemannianConstDiag(const size_t stateSpaceDim, korali::distribution::univariate::Normal *normalGenerator, const double inverseRegularizationParam, korali::Experiment *k) : HamiltonianRiemannian{stateSpaceDim, k}
{
_normalGenerator = normalGenerator;
_inverseRegularizationParam = inverseRegularizationParam;
}
/**
* @brief Destructor of derived class.
*/
~HamiltonianRiemannianConstDiag() = default;
/**
* @brief Total energy function used for Hamiltonian Dynamics.
* @param momentum Current momentum.
* @param inverseMetric Inverse of current metric.
* @return Total energy.
*/
double H(const std::vector<double> &momentum, const std::vector<double> &inverseMetric) override
{
return K(momentum, inverseMetric) + U();
}
/**
* @brief Kinetic energy function.
* @param momentum Current momentum.
* @param inverseMetric Inverse of current metric.
* @return Kinetic energy.
*/
double K(const std::vector<double> &momentum, const std::vector<double> &inverseMetric) override
{
double result = tau(momentum, inverseMetric) + 0.5 * _logDetMetric;
return result;
}
/**
* @brief Gradient of kintetic energy function
* @param momentum Current momentum.
* @param inverseMetric Current inverseMetric.
* @return Gradient of kinetic energy wrt. current momentum.
*/
std::vector<double> dK(const std::vector<double> &momentum, const std::vector<double> &inverseMetric) override
{
std::vector<double> gradient(_stateSpaceDim, 0.0);
for (size_t i = 0; i < _stateSpaceDim; ++i)
{
gradient[i] = inverseMetric[i] * momentum[i];
}
return gradient;
}
/**
* @brief Calculates tau(q, p) = 0.5 * momentum^T * inverseMetric(q) * momentum.
* @param momentum Current momentum.
* @param inverseMetric Current inverseMetric.
* @return Gradient of Kinetic energy with current momentum.
*/
double tau(const std::vector<double> &momentum, const std::vector<double> &inverseMetric) override
{
double energy = 0.0;
for (size_t i = 0; i < _stateSpaceDim; ++i)
{
energy += momentum[i] * inverseMetric[i] * momentum[i];
}
return 0.5 * energy;
}
/**
* @brief Calculates gradient of tau(q, p) wrt. position.
* @param momentum Current momentum.
* @param inverseMetric Current inverseMetric.
* @return Gradient of Kinetic energy with current momentum.
*/
std::vector<double> dtau_dq(const std::vector<double> &momentum, const std::vector<double> &inverseMetric) override
{
std::vector<double> result(_stateSpaceDim, 0.0);
return result;
}
/**
* @brief Calculates gradient of tau(q, p) wrt. momentum.
* @param momentum Current momentum.
* @param inverseMetric Current inverseMetric.
* @return Gradient of Kinetic energy with current momentum.
*/
std::vector<double> dtau_dp(const std::vector<double> &momentum, const std::vector<double> &inverseMetric) override
{
return dK(momentum, inverseMetric);
}
/**
* @brief Calculates gradient of kinetic energy.
* @return Gradient of kinetic energy.
*/
double phi() override
{
return U() + 0.5 * _logDetMetric;
}
/**
* @brief Calculates gradient of kinetic energy.
* @return Gradient of kinetic energy.
*/
std::vector<double> dphi_dq() override
{
return dU();
}
/**
* @brief Updates current position of hamiltonian.
* @param position Current position.
* @param metric Current metric.
* @param inverseMetric Inverse of current metric.
*/
void updateHamiltonian(const std::vector<double> &position, std::vector<double> &metric, std::vector<double> &inverseMetric) override
{
auto sample = korali::Sample();
sample["Sample Id"] = _modelEvaluationCount;
sample["Module"] = "Problem";
sample["Operation"] = "Evaluate";
sample["Parameters"] = position;
KORALI_START(sample);
KORALI_WAIT(sample);
_modelEvaluationCount++;
_currentEvaluation = KORALI_GET(double, sample, "logP(x)");
if (samplingProblemPtr != nullptr)
{
samplingProblemPtr->evaluateGradient(sample);
samplingProblemPtr->evaluateHessian(sample);
}
else
{
bayesianProblemPtr->evaluateGradient(sample);
bayesianProblemPtr->evaluateHessian(sample);
}
_currentGradient = sample["grad(logP(x))"].get<std::vector<double>>();
_currentHessian = sample["H(logP(x))"].get<std::vector<double>>();
}
/**
* @brief Generates sample of momentum.
* @param metric Current metric.
* @return Momentum sampled from normal distribution with metric as covariance matrix.
*/
std::vector<double> sampleMomentum(const std::vector<double> &metric) const override
{
std::vector<double> result(_stateSpaceDim);
for (size_t i = 0; i < _stateSpaceDim; ++i)
{
result[i] = std::sqrt(metric[i]) * _normalGenerator->getRandomNumber();
}
return result;
}
/**
* @brief Calculates inner product induces by inverse metric.
* @param momentumLeft Left vector of inner product.
* @param momentumRight Right vector of inner product.
* @param inverseMetric Inverse of curret metric.
* @return inner product
*/
double innerProduct(const std::vector<double> &momentumLeft, const std::vector<double> &momentumRight, const std::vector<double> &inverseMetric) const override
{
double result = 0.0;
for (size_t i = 0; i < _stateSpaceDim; ++i)
{
result += momentumLeft[i] * inverseMetric[i] * momentumRight[i];
}
return result;
}
/**
* @brief Updates Metric and Inverse Metric by using hessian.
* @param metric Current metric.
* @param inverseMetric Inverse of current metric.
* @return Error code to indicate if update was successful.
*/
int updateMetricMatricesRiemannian(std::vector<double> &metric, std::vector<double> &inverseMetric) override
{
auto hessian = _currentHessian;
// constant for condition number of metric
double detMetric = 1.0;
for (size_t i = 0; i < _stateSpaceDim; ++i)
{
metric[i] = softAbsFunc(hessian[i + i * _stateSpaceDim], _inverseRegularizationParam);
inverseMetric[i] = 1.0 / metric[i];
detMetric *= metric[i];
}
_logDetMetric = std::log(detMetric);
return 0;
}
/**
* @brief Inverse regularization parameter of SoftAbs metric that controls hardness of approximation
*/
double _inverseRegularizationParam;
private:
/**
* @brief One dimensional normal generator needed for sampling of momentum from diagonal metric.
*/
korali::distribution::univariate::Normal *_normalGenerator;
};
} // namespace sampler
} // namespace solver
} // namespace korali
#endif
| 30.2 | 248 | 0.701987 | JonathanLehner |
21bb10cec2eaa928a93fe9ccd8d06abb83be7939 | 339 | hpp | C++ | core/include/system/EntityGenerator.hpp | Floriantoine/MyHunter_Sfml | 8744e1b03d9d5fb621f9cba7619d9d5dd943e428 | [
"MIT"
] | null | null | null | core/include/system/EntityGenerator.hpp | Floriantoine/MyHunter_Sfml | 8744e1b03d9d5fb621f9cba7619d9d5dd943e428 | [
"MIT"
] | null | null | null | core/include/system/EntityGenerator.hpp | Floriantoine/MyHunter_Sfml | 8744e1b03d9d5fb621f9cba7619d9d5dd943e428 | [
"MIT"
] | null | null | null | #pragma once
#include "ASystem.hpp"
#include "observer/Observer.hpp"
namespace systems {
class EntityGenerator : public fa::ASystem {
public:
Observer _observer;
std::vector<std::string> _pathList;
EntityGenerator();
~EntityGenerator() = default;
void update(long elapsedTime) override;
};
} // namespace systems | 18.833333 | 44 | 0.707965 | Floriantoine |
21bcd831908283b1e66a92530c319a107047d919 | 37 | cpp | C++ | examples/tvm/boo.cpp | Costallat/hunter | dc0d79cb37b30cad6d6472d7143fe27be67e26d5 | [
"BSD-2-Clause"
] | 2,146 | 2015-01-10T07:26:58.000Z | 2022-03-21T02:28:01.000Z | examples/tvm/boo.cpp | koinos/hunter | fc17bc391210bf139c55df7f947670c5dff59c57 | [
"BSD-2-Clause"
] | 1,778 | 2015-01-03T11:50:30.000Z | 2019-12-26T05:31:20.000Z | examples/tvm/boo.cpp | koinos/hunter | fc17bc391210bf139c55df7f947670c5dff59c57 | [
"BSD-2-Clause"
] | 734 | 2015-03-05T19:52:34.000Z | 2022-02-22T23:18:54.000Z | #include <nnvm/op.h>
int main() {
}
| 7.4 | 20 | 0.567568 | Costallat |
21c66edf4ac622df28ca3145f6157a4b490e160d | 16,198 | hpp | C++ | Public/Ava/Private/Containers/HashTable.hpp | vasama/Ava | c1e6fb87a493dc46ce870220c632069f00875d2c | [
"MIT"
] | null | null | null | Public/Ava/Private/Containers/HashTable.hpp | vasama/Ava | c1e6fb87a493dc46ce870220c632069f00875d2c | [
"MIT"
] | null | null | null | Public/Ava/Private/Containers/HashTable.hpp | vasama/Ava | c1e6fb87a493dc46ce870220c632069f00875d2c | [
"MIT"
] | null | null | null | #pragma once
#include "Ava/Containers/StoragePolicy.hpp"
#include "Ava/Math/Math.hpp"
#include "Ava/Memory/NoInit.hpp"
#include "Ava/Memory/Storage.hpp"
#include "Ava/Meta/Constant.hpp"
#include "Ava/Meta/Identity.hpp"
#include "Ava/Meta/TypeTraits.hpp"
#include "Ava/Misc.hpp"
#include "Ava/Private/Ebo.hpp"
#include "Ava/Types.hpp"
#include "Ava/Utility/Hash.hpp"
namespace Ava::Private::Containers_HashTable {
enum class Ctrl : byte
{
Null = 0b00000000,
Last = 0b01111111,
Flag = 0b10000000,
Mask = 0b01111111,
};
constexpr Ava_FORCEINLINE Ctrl operator|(Ctrl lhs, Ctrl rhs)
{
return (Ctrl)((byte)lhs | (byte)rhs);
}
constexpr Ava_FORCEINLINE Ctrl operator&(Ctrl lhs, Ctrl rhs)
{
return (Ctrl)((byte)lhs & (byte)rhs);
}
extern const uword JumpOffsets[];
template<typename T>
struct Block
{
//TODO: calculate optimal size
static constexpr iword Size = 8;
Ctrl m_ctrl[Size];
Storage<T> m_data[Size];
};
constexpr iword MaxBlockSize = 16;
extern const Ctrl EmptyBlock[];
template<typename T>
void Clean(Block<T>* blocks, iword blockCount)
{
if constexpr (!IsTriviallyDestructible<T>)
{
for (Block<T>* f = blocks, *l = f + blockCount; f != l; ++f)
for (iword index = 0; index < Block<T>::Size; ++index)
if (f->m_ctrl[index] != Ctrl::Null)
f->m_data[index].Destroy();
}
else Ava_UNUSED(blocks, blockCount);
}
template<typename T>
struct IteratorBase
{
typedef T ElementType;
typedef Block<T> BlockType;
ElementType* m_element;
BlockType* m_block;
};
template<typename T>
class BasicIterator : IteratorBase<RemoveConst<T>>
{
typedef IteratorBase<RemoveConst<T>> Base;
public:
Ava_FORCEINLINE BasicIterator(decltype(NoInit))
{
}
Ava_FORCEINLINE T& operator*() const
{
return *Base::m_element;
}
Ava_FORCEINLINE T* operator->() const
{
return Base::m_element;
}
Ava_FORCEINLINE BasicIterator& operator++()
{
IncrementInternal();
return *this;
}
Ava_FORCEINLINE BasicIterator operator++(int)
{
BasicIterator result = *this;
IncrementInternal();
return result;
}
private:
void IncrementInternal()
{
typename Base::ElementType* element = Base::m_element;
typename Base::BlockType* block = Base::m_block;
while (true)
{
Ctrl* first = block->m_ctrl + (element - &block->m_data);
Ctrl* last = block->m_ctrl + Base::BlockType::Size;
for (Ctrl* ctrl = first; ++ctrl != last;)
if (*ctrl == Ctrl::Null)
{
Base::m_element = element + (ctrl - first);
Base::m_block = block;
return;
}
element = &++block->m_data;
}
}
friend Ava_FORCEINLINE bool operator==(
const BasicIterator<T>& lhs, const BasicIterator<T>& rhs)
{
return lhs.m_element == rhs.m_element && lhs.m_block == rhs.m_block;
}
friend Ava_FORCEINLINE bool operator!=(
const BasicIterator<T>& lhs, const BasicIterator<T>& rhs)
{
return lhs.m_element != rhs.m_element || lhs.m_block != rhs.m_block;
}
};
template<typename T, typename THasher, typename TStoragePolicy>
class StorageLayer
{
static_assert(Identity<False, T>::Value, "Unsupported storage policy");
};
template<typename TBase, typename THasher>
struct HasherLayer : Ava_EBO(TBase, THasher)
{
template<typename TInHasher>
Ava_FORCEINLINE HasherLayer(TInHasher&& hasher)
: THasher(Forward<TInHasher>(hasher))
{
}
};
/* Remote storage policy */
template<typename TBlock>
struct Remote_Base
{
TBlock* m_blocks;
u32 m_size;
u32 m_capacity;
};
template<typename TBlock, typename THasher, typename TAllocator>
class StorageLayer<TBlock, THasher, StoragePolicy::Remote<TAllocator>>
: Ava_EBOX(public, HasherLayer<Remote_Base<TBlock>, THasher>, TAllocator)
{
typedef Remote_Base<TBlock> Base;
typedef HasherLayer<Base, THasher> HasherLayer;
public:
typedef TAllocator AllocatorType;
static constexpr bool CanGrow = true;
Ava_CLANG_WARNING(push)
Ava_CLANG_WARNING(ignored "-Wreorder")
template<typename TInHasher>
Ava_FORCEINLINE StorageLayer(const AllocatorType& alloc, TInHasher&& hasher)
: HasherLayer(Forward<TInHasher>(hasher)), TAllocator(alloc)
{
Base::m_blocks = (TBlock*)EmptyBlock;
Base::m_size = 0;
Base::m_capacity = 0;
}
Ava_CLANG_WARNING(pop)
Ava_FORCEINLINE ~StorageLayer()
{
if (iword capacity = Base::m_capacity)
{
TBlock* blocks = Base::m_blocks;
iword blockCount = capacity / TBlock::Size;
Clean(blocks, blockCount);
Deallocate(blocks, blockCount);
}
}
Ava_FORCEINLINE iword GetSize() const
{
return (iword)Base::m_size;
}
Ava_FORCEINLINE void SetSize(iword size)
{
Base::m_size = (u32)size;
}
Ava_FORCEINLINE iword GetCapacity() const
{
return (iword)Base::m_capacity;
}
Ava_FORCEINLINE TBlock* GetBlocks() const
{
return Base::m_blocks;
}
//TODO: try to improve the internal grow interface
Ava_FORCEINLINE TBlock* SwapBlocks(iword blockCount)
{
TBlock* blocks = Allocate(blockCount);
Base::m_blocks = blocks;
Base::m_capacity = (u32)(blockCount * TBlock::Size);
return blocks;
}
Ava_FORCEINLINE void FreeBlocks(TBlock* blocks, iword blockCount)
{
Deallocate(blocks, blockCount);
}
Ava_FORCEINLINE void SetDefaultBlocks()
{
Base::m_blocks = (TBlock*)EmptyBlock;
Base::m_capacity = 0;
}
private:
Ava_FORCEINLINE TBlock* Allocate(iword blockCount)
{
return (TBlock*)static_cast<const TAllocator*>(this)
->Allocate(sizeof(TBlock) * blockCount);
}
Ava_FORCEINLINE void Deallocate(TBlock* blocks, iword blockCount)
{
static_cast<const TAllocator*>(this)
->Deallocate(blocks, sizeof(TBlock) * blockCount);
}
};
Ava_FORCEINLINE iword GetMaxSize(iword capacity)
{
// ~ capacity * 15/16
return capacity - (capacity / 16);
}
Ava_FORCEINLINE uword GetIndexMask(iword capacity)
{
return (uword)(capacity > 1 ? capacity - 1 : 1);
}
Ava_FORCEINLINE uword GetIndexShift(uword mask)
{
return Math::Lzcnt(mask);
}
template<uword = sizeof(uword)> struct Phi;
template<> struct Phi<4> { static constexpr u32 Value = 2654435769u; };
template<> struct Phi<8> { static constexpr u64 Value = 11400714819323198485u; };
Ava_FORCEINLINE iword HashToIndex(uword hash, uword shift)
{
return (iword)((hash * Phi<>::Value) >> shift);
}
Ava_FORCEINLINE iword Jump(iword index, Ctrl jump, uword mask)
{
return (iword)(((uword)index + JumpOffsets[(iword)jump]) & mask);
}
template<typename T, typename TTraits, typename THasher, typename TStoragePolicy>
class Table : public StorageLayer<Block<T>, THasher, TStoragePolicy>
{
typedef Block<T> BlockType;
typedef StorageLayer<BlockType, THasher, TStoragePolicy> Base;
typedef typename TTraits::template SelectKeyType<T> KeyType;
public:
typedef typename Base::AllocatorType AllocatorType;
typedef BasicIterator< T> Iterator;
typedef BasicIterator<const T> ConstIterator;
struct InsertResult
{
T* Element;
bool Inserted;
};
template<typename TInHasher>
Ava_FORCEINLINE Table(const AllocatorType& alloc, TInHasher&& hasher)
: Base(alloc, Forward<TInHasher>(hasher))
{
}
template<typename TInKey>
Ava_FORCEINLINE T* Find(const TInKey& key) const
{
uword hash = THasher::Hash(key);
return FindInternal<const TInKey&>(hash, key);
}
template<typename TInKey>
Ava_FORCEINLINE InsertResult Insert(const TInKey& key)
{
uword hash = THasher::Hash(key);
return InsertInternal<const TInKey&>(hash, key);
}
template<typename TInKey>
Ava_FORCEINLINE bool Remove(const TInKey& key)
{
uword hash = THasher::Hash(key);
return RemoveInternal<const TInKey&>(hash, key);
}
void Reserve(iword minCapacity)
{
if constexpr (Base::CanGrow)
{
iword capacity = Base::GetCapacity();
iword maxSize = GetMaxSize(capacity);
if (minCapacity > maxSize)
Rehash(Math::Max(capacity * 2, Math::Max(BlockType::Size,
(iword)Math::RoundUpToPowerOfTwo((uword)minCapacity))));
}
else Ava_Assert(minCapacity < Base::GetCapacity());
}
void Clear(bool deallocate)
{
if (iword capacity = Base::GetCapacity())
{
BlockType* blocks = Base::GetBlocks();
iword blockCount = capacity / BlockType::Size;
Clean(blocks, blockCount);
if constexpr (Base::CanGrow)
{
if (deallocate)
Base::FreeBlocks(blocks, blockCount);
Base::SetDefaultBlocks();
}
else Ava_UNUSED(deallocate);
Base::SetSize(0);
}
}
private:
struct Slot
{
Ctrl* m_ctrl;
T* m_data;
};
template<typename TInKey>
T* FindInternal(uword hash, TInKey key) const
{
BlockType* const blocks = Base::GetBlocks();
const iword capacity = Base::GetCapacity();
const uword mask = GetIndexMask(capacity);
const uword shift = GetIndexShift(mask);
const auto GetSlot = [&](iword index) -> Slot
{
iword blockIndex = index / BlockType::Size;
iword valueIndex = index % BlockType::Size;
BlockType* block = blocks + blockIndex;
return Slot{
&block->m_ctrl[valueIndex],
&block->m_data[valueIndex]
};
};
iword index = HashToIndex(hash, shift);
Slot slot = GetSlot(index);
Ctrl ctrl = *slot.m_ctrl;
// No value with this hash
if ((byte)(ctrl & Ctrl::Flag) == 0)
return nullptr;
ctrl = ctrl & Ctrl::Mask;
while (true) // Search the chain
{
if (key == TTraits::SelectKey(*slot.m_data))
return slot.m_data;
if (Ava_LIKELY(ctrl == Ctrl::Last))
return nullptr;
index = Jump(index, ctrl, mask);
slot = GetSlot(index);
ctrl = *slot.m_ctrl;
}
}
template<typename TInKey>
InsertResult InsertInternal(uword hash, TInKey key)
{
reset:
iword capacity = Base::GetCapacity();
if constexpr (Base::CanGrow)
if (Ava_UNLIKELY(capacity == 0))
{
Rehash(BlockType::Size);
capacity = BlockType::Size;
}
BlockType* blocks = Base::GetBlocks();
const uword mask = GetIndexMask(capacity);
const uword shift = GetIndexShift(mask);
const auto GetSlot = [&](iword index) -> Slot
{
iword blockIndex = index / BlockType::Size;
iword valueIndex = index % BlockType::Size;
BlockType* block = blocks + blockIndex;
return Slot{
&block->m_ctrl[valueIndex],
&block->m_data[valueIndex]
};
};
struct TryInsertResult
{
Ctrl Jump;
Slot Slot;
};
const auto TryInsert = [&](iword index) -> TryInsertResult
{
//TODO: optimize first 16
for (iword i = 1; i < 126; ++i)
{
Ctrl jump = (Ctrl)i;
iword next = Jump(index, jump, mask);
Slot slot = GetSlot(next);
if (*slot.m_ctrl == Ctrl::Null)
return { jump, slot };
}
Ava_CLANG_WARNING(push);
Ava_CLANG_WARNING(ignored "-Wmissing-field-initializers");
return { Ctrl::Null };
Ava_CLANG_WARNING(pop);
};
iword index = HashToIndex(hash, shift);
Slot slot = GetSlot(index);
Ctrl ctrl = *slot.m_ctrl;
if ((byte)(ctrl & Ctrl::Flag) == 0)
{
iword size = Base::GetSize();
if constexpr (Base::CanGrow)
{
if (size == GetMaxSize(capacity))
goto rehash;
}
else Ava_Assert(size < capacity);
// if slot is part of another chain
if (ctrl != Ctrl::Null)
{
iword parentIndex;
Slot parentSlot;
Ctrl parentCtrl;
{
// find parent in other chain
uword parentHash = THasher::Hash(
TTraits::SelectKey(*slot.m_data));
parentIndex = HashToIndex(parentHash, shift);
while (true)
{
parentSlot = GetSlot(parentIndex);
parentCtrl = *parentSlot.m_ctrl;
iword next = Jump(parentIndex,
parentCtrl & Ctrl::Mask, mask);
if (next == index)
break;
parentIndex = next;
}
}
iword srcIndex = index;
Slot srcSlot = slot;
Ctrl srcCtrl = ctrl;
while (true)
{
auto[jump, nextSlot] = TryInsert(parentIndex);
// if can't insert
if (jump == Ctrl::Null)
{
//TODO: make sure this is correct
// map must be in valid state when rehashing
// ska map uses a reserved ctrl value
// be sure to leave an explanation
if (srcIndex != index)
*slot.m_ctrl = Ctrl::Null;
goto rehash;
}
*parentSlot.m_ctrl = (parentCtrl & Ctrl::Flag) | jump;
// mark next as last in chain
*nextSlot.m_ctrl = Ctrl::Last;
// mark source as empty
if (srcIndex != index)
*srcSlot.m_ctrl = Ctrl::Null;
Relocate<T>(nextSlot.m_data, srcSlot.m_data);
if (srcCtrl == Ctrl::Last)
break;
parentIndex = Jump(parentIndex, jump, mask);
parentSlot = nextSlot;
parentCtrl = jump;
iword nextSrcIndex = Jump(srcIndex, srcCtrl, mask);
Slot nextSrcSlot = GetSlot(nextSrcIndex);
srcIndex = nextSrcIndex;
srcSlot = nextSrcSlot;
srcCtrl = *nextSrcSlot.m_ctrl;
}
}
*slot.m_ctrl = Ctrl::Flag | Ctrl::Last;
Base::SetSize(size + 1);
return InsertResult{ slot.m_data, true };
}
while (true)
{
if (key == TTraits::SelectKey(*slot.m_data))
return InsertResult{ slot.m_data, false };
Ctrl jump = ctrl & Ctrl::Mask;
if (Ava_LIKELY(jump == Ctrl::Last))
{
iword size = Base::GetSize();
if constexpr (Base::CanGrow)
{
if (size == GetMaxSize(capacity))
goto rehash;
}
else Ava_Assert(size < capacity);
auto[nextJump, nextSlot] = TryInsert(index);
if (nextJump == Ctrl::Null) goto rehash;
*slot.m_ctrl = (ctrl & Ctrl::Flag) | nextJump;
*nextSlot.m_ctrl = Ctrl::Last;
Base::SetSize(size + 1);
return InsertResult{ nextSlot.m_data, true };
}
index = Jump(index, jump, mask);
slot = GetSlot(index);
ctrl = *slot.m_ctrl;
}
rehash:
if constexpr (Base::CanGrow)
{
Rehash(capacity * 2);
goto reset;
}
}
template<typename TInKey>
bool RemoveInternal(uword hash, TInKey key)
{
BlockType* const blocks = Base::GetBlocks();
const iword capacity = Base::GetCapacity();
uword mask = GetIndexMask(capacity);
uword shift = GetIndexShift(mask);
const auto GetSlot = [&](iword index) -> Slot
{
iword blockIndex = index / BlockType::Size;
iword valueIndex = index % BlockType::Size;
BlockType* block = blocks + blockIndex;
return Slot{
&block->m_ctrl[valueIndex],
&block->m_data[valueIndex]
};
};
iword index = HashToIndex(hash, shift);
Slot slot = GetSlot(index);
// No value with this hash
if ((byte)(*slot.m_ctrl & Ctrl::Flag) == 0)
return false;
Ctrl* prev = nullptr;
while (true)
{
Ctrl ctrl = *slot.m_ctrl;
Ctrl jump = ctrl & Ctrl::Mask;
if (key == TTraits::SelectKey(*slot.m_data))
{
Destroy<T>(slot.m_data);
Base::SetSize(Base::GetSize() - 1);
if (Ava_LIKELY(jump == Ctrl::Last))
{
*slot.m_ctrl = Ctrl::Null;
if (prev != nullptr)
*prev = (*prev & Ctrl::Flag) | Ctrl::Last;
}
else
{
T* elem = slot.m_data;
while (true)
{
prev = slot.m_ctrl;
index = Jump(index, jump, mask);
slot = GetSlot(index);
ctrl = *slot.m_ctrl;
if (Ava_LIKELY(ctrl == Ctrl::Last))
break;
jump = ctrl & Ctrl::Mask;
}
Relocate<T>(elem, slot.m_data);
*prev = (*prev & Ctrl::Flag) | Ctrl::Last;
*slot.m_ctrl = Ctrl::Null;
}
return true;
}
if (Ava_LIKELY(jump == Ctrl::Last))
return false;
prev = slot.m_ctrl;
index = Jump(index, jump, mask);
slot = GetSlot(index);
}
}
Ava_FORCENOINLINE void Rehash(iword newCapacity)
{
Ava_Assert(newCapacity >= BlockType::Size);
iword capacity = Base::GetCapacity();
BlockType* oldBlocks = Base::GetBlocks();
iword newBlockCount = newCapacity / BlockType::Size;
BlockType* newBlocks = Base::SwapBlocks(newBlockCount);
for (BlockType* f = newBlocks, *l = f + newBlockCount; f != l; ++f)
for (iword index = 0; index < BlockType::Size; ++index)
f->m_ctrl[index] = Ctrl::Null;
if (capacity != 0)
{
Base::SetSize(0);
iword oldBlockCount = capacity / BlockType::Size;
for (BlockType* f = oldBlocks, *l = f + oldBlockCount; f != l; ++f)
for (iword index = 0; index < BlockType::Size; ++index)
if (f->m_ctrl[index] != Ctrl::Null)
{
const KeyType& key = TTraits::SelectKey(*f->m_data[index]);
auto[slot, inserted] = InsertInternal<const KeyType&>(THasher::Hash(key), key);
Ava_Assert(inserted);
Relocate<T>(slot, &f->m_data[index]);
}
Base::FreeBlocks(oldBlocks, oldBlockCount);
}
}
};
} // namespace Ava::Private::Containers_HashTable
| 21.830189 | 85 | 0.664959 | vasama |
21c70d5698e2a0dcbf53601fa17bed3bd947ae1c | 3,435 | hpp | C++ | include/memoria/containers/multimap/multimap_output_values.hpp | victor-smirnov/memoria | c36a957c63532176b042b411b1646c536e71a658 | [
"BSL-1.0",
"Apache-2.0",
"OLDAP-2.8",
"BSD-3-Clause"
] | 2 | 2021-07-30T16:54:24.000Z | 2021-09-08T15:48:17.000Z | include/memoria/containers/multimap/multimap_output_values.hpp | victor-smirnov/memoria | c36a957c63532176b042b411b1646c536e71a658 | [
"BSL-1.0",
"Apache-2.0",
"OLDAP-2.8",
"BSD-3-Clause"
] | null | null | null | include/memoria/containers/multimap/multimap_output_values.hpp | victor-smirnov/memoria | c36a957c63532176b042b411b1646c536e71a658 | [
"BSL-1.0",
"Apache-2.0",
"OLDAP-2.8",
"BSD-3-Clause"
] | 2 | 2020-03-14T15:15:25.000Z | 2020-06-15T11:26:56.000Z |
// Copyright 2019 Victor Smirnov
//
// 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.
#pragma once
#include <memoria/api/multimap/multimap_output.hpp>
namespace memoria {
namespace multimap {
template <typename Types, typename Profile, typename IteratorPtr>
class ValuesIteratorImpl: public IValuesScanner<Types, Profile> {
using Base = IValuesScanner<Types, Profile>;
using typename Base::ValueView;
using typename Base::ValuesIOVSubstreamAdapter;
using Base::values_;
using Base::size_;
using Base::run_is_finished_;
using Base::values_buffer_;
size_t values_start_{};
core::StaticVector<uint64_t, 2> offsets_;
DefaultBTFLRunParser<2> parser_;
IteratorPtr iter_;
uint64_t iteration_num_{};
public:
ValuesIteratorImpl(IteratorPtr iter):
parser_(iter->iter_local_pos()),
iter_(iter)
{
parse_first();
}
virtual bool is_end() const {
return iter_->iter_is_end();
}
virtual bool next_block()
{
auto has_next = iter_->iter_next_leaf();
if (has_next)
{
offsets_.clear();
build_index();
}
else {
auto leaf_sizes = iter_->iter_leaf_sizes();
iter_->iter_local_pos() = leaf_sizes.sum();
run_is_finished_ = true;
}
return run_is_finished_;
}
virtual void fill_suffix_buffer()
{
while (!is_end())
{
fill_buffer(values_start_, values_.size());
auto has_next = next_block();
if (has_next) {
break;
}
}
}
virtual void dump_iterator() const
{
iter_->dump();
}
private:
void fill_buffer(size_t start, size_t end)
{
const io::IOVector& buffer = iter_->iovector_view();
values_buffer_.template append<ValuesIOVSubstreamAdapter>(buffer.substream(1), 0, start, end);
}
void parse_first()
{
iter_->refresh_iovector_view();
auto& ss = iter_->iovector_view().symbol_sequence();
int32_t idx = parser_.start_idx();
ss.rank_to(idx, offsets_.values());
build_index();
}
void build_index()
{
const io::IOVector& buffer = iter_->iovector_view();
auto& ss = buffer.symbol_sequence();
parser_.parse(ss);
if (MMA_LIKELY((!parser_.is_empty()) || ss.size() > 0))
{
size_t run_size = (!parser_.is_empty()) ? parser_.run_size() : 0;
values_start_ = offsets_[1];
values_.clear();
ValuesIOVSubstreamAdapter::read_to(buffer.substream(1), 0, values_start_, run_size, values_.array());
run_is_finished_ = parser_.is_finished();
size_ = run_size;
}
else {
// empty block requires nothing
}
offsets_.clear();
iteration_num_++;
}
};
}}
| 24.190141 | 113 | 0.613683 | victor-smirnov |
21d11bbb1ae9b200f36d80d6009a02652e6c6246 | 4,636 | cc | C++ | src/communication/msg.cc | ooibc88/incubator-singa | 50deedd496182daa0c178dd2581af43d173b6506 | [
"Apache-2.0"
] | 3 | 2016-10-29T09:40:46.000Z | 2021-11-17T11:03:31.000Z | src/communication/msg.cc | ooibc88/incubator-singa | 50deedd496182daa0c178dd2581af43d173b6506 | [
"Apache-2.0"
] | null | null | null | src/communication/msg.cc | ooibc88/incubator-singa | 50deedd496182daa0c178dd2581af43d173b6506 | [
"Apache-2.0"
] | null | null | null | #include "communication/msg.h"
#include <glog/logging.h>
namespace singa {
#ifdef USE_ZMQ
Msg::~Msg() {
if (msg_ != nullptr)
zmsg_destroy(&msg_);
frame_ = nullptr;
}
Msg::Msg() {
msg_ = zmsg_new();
}
Msg::Msg(const Msg& msg) {
src_ = msg.src_;
dst_ = msg.dst_;
type_ = msg.type_;
trgt_val_ = msg.trgt_val_;
trgt_version_ = msg.trgt_version_;
msg_ = zmsg_dup(msg.msg_);
}
Msg::Msg(int src, int dst) {
src_ = src;
dst_ = dst;
msg_ = zmsg_new();
}
void Msg::SwapAddr() {
std::swap(src_, dst_);
}
int Msg::size() const {
return zmsg_content_size(msg_);
}
void Msg::AddFrame(const void* addr, int nBytes) {
zmsg_addmem(msg_, addr, nBytes);
}
int Msg::FrameSize() {
return zframe_size(frame_);
}
void* Msg::FrameData() {
return zframe_data(frame_);
}
char* Msg::FrameStr() {
return zframe_strdup(frame_);
}
bool Msg::NextFrame() {
frame_ = zmsg_next(msg_);
return frame_ != nullptr;
}
void Msg::FirstFrame() {
frame_ = zmsg_first(msg_);
}
void Msg::LastFrame() {
frame_ = zmsg_last(msg_);
}
void Msg::ParseFromZmsg(zmsg_t* msg) {
char* tmp = zmsg_popstr(msg);
sscanf(tmp, "%d %d %d %d %d",
&src_, &dst_, &type_, &trgt_val_, &trgt_version_);
frame_ = zmsg_first(msg);
msg_ = msg;
}
zmsg_t* Msg::DumpToZmsg() {
zmsg_pushstrf(msg_, "%d %d %d %d %d",
src_, dst_, type_, trgt_val_, trgt_version_);
zmsg_t *tmp = msg_;
msg_ = nullptr;
return tmp;
}
// frame marker indicating this frame is serialize like printf
#define FMARKER "*singa*"
#define kMaxFrameLen 2048
int Msg::AddFormatFrame(const char *format, ...) {
va_list argptr;
va_start(argptr, format);
int size = strlen(FMARKER);
char dst[kMaxFrameLen];
memcpy(dst, FMARKER, size);
dst[size++] = 0;
while (*format) {
if (*format == 'i') {
int x = va_arg(argptr, int);
dst[size++] = 'i';
memcpy(dst + size, &x, sizeof(x));
size += sizeof(x);
} else if (*format == 'f') {
float x = static_cast<float> (va_arg(argptr, double));
dst[size++] = 'f';
memcpy(dst + size, &x, sizeof(x));
size += sizeof(x);
} else if (*format == '1') {
uint8_t x = va_arg(argptr, int);
memcpy(dst + size, &x, sizeof(x));
size += sizeof(x);
} else if (*format == '2') {
uint16_t x = va_arg(argptr, int);
memcpy(dst + size, &x, sizeof(x));
size += sizeof(x);
} else if (*format == '4') {
uint32_t x = va_arg(argptr, uint32_t);
memcpy(dst + size, &x, sizeof(x));
size += sizeof(x);
} else if (*format == 's') {
char* x = va_arg(argptr, char *);
dst[size++] = 's';
memcpy(dst + size, x, strlen(x));
size += strlen(x);
dst[size++] = 0;
} else if (*format == 'p') {
void* x = va_arg(argptr, void *);
dst[size++] = 'p';
memcpy(dst + size, &x, sizeof(x));
size += sizeof(x);
} else {
LOG(ERROR) << "Unknown format " << *format;
}
format++;
CHECK_LE(size, kMaxFrameLen);
}
va_end(argptr);
zmsg_addmem(msg_, dst, size);
return size;
}
int Msg::ParseFormatFrame(const char *format, ...) {
va_list argptr;
va_start(argptr, format);
char* src = zframe_strdup(frame_);
CHECK_STREQ(FMARKER, src);
int size = strlen(FMARKER) + 1;
while (*format) {
if (*format == 'i') {
int *x = va_arg(argptr, int *);
CHECK_EQ(src[size++], 'i');
memcpy(x, src + size, sizeof(*x));
size += sizeof(*x);
} else if (*format == 'f') {
float *x = va_arg(argptr, float *);
CHECK_EQ(src[size++], 'f');
memcpy(x, src + size, sizeof(*x));
size += sizeof(*x);
} else if (*format == '1') {
uint8_t *x = va_arg(argptr, uint8_t *);
memcpy(x, src + size, sizeof(*x));
size += sizeof(*x);
} else if (*format == '2') {
uint16_t *x = va_arg(argptr, uint16_t *);
memcpy(x, src + size, sizeof(*x));
size += sizeof(*x);
} else if (*format == '4') {
uint32_t *x = va_arg(argptr, uint32_t *);
memcpy(x, src + size, sizeof(*x));
size += sizeof(*x);
} else if (*format == 's') {
char* x = va_arg(argptr, char *);
CHECK_EQ(src[size++], 's');
int len = strlen(src + size);
memcpy(x, src + size, len);
x[len] = 0;
size += len + 1;
} else if (*format == 'p') {
void** x = va_arg(argptr, void **);
CHECK_EQ(src[size++], 'p');
memcpy(x, src + size, sizeof(*x));
size += sizeof(*x);
} else {
LOG(ERROR) << "Unknown format type " << *format;
}
format++;
}
va_end(argptr);
delete src;
return size;
}
#endif
} // namespace singa
| 23.774359 | 62 | 0.556946 | ooibc88 |
21d375bb3860ad5f87eaf3a8222e0cd6c6f1b91b | 2,854 | hh | C++ | src/DataBase/CompositeFieldListPolicy.hh | jmikeowen/Spheral | 3e1082a7aefd6b328bd3ae24ca1a477108cfc3c4 | [
"BSD-Source-Code",
"BSD-3-Clause-LBNL",
"FSFAP"
] | 22 | 2018-07-31T21:38:22.000Z | 2020-06-29T08:58:33.000Z | src/DataBase/CompositeFieldListPolicy.hh | markguozhiming/spheral | bbb982102e61edb8a1d00cf780bfa571835e1b61 | [
"BSD-Source-Code",
"BSD-3-Clause-LBNL",
"FSFAP"
] | 41 | 2020-09-28T23:14:27.000Z | 2022-03-28T17:01:33.000Z | src/DataBase/CompositeFieldListPolicy.hh | markguozhiming/spheral | bbb982102e61edb8a1d00cf780bfa571835e1b61 | [
"BSD-Source-Code",
"BSD-3-Clause-LBNL",
"FSFAP"
] | 7 | 2019-12-01T07:00:06.000Z | 2020-09-15T21:12:39.000Z | //---------------------------------Spheral++----------------------------------//
// CompositeFieldListPolicy -- An implementation of UpdatePolicyBase which
// consists of a collection of individual Field policies that should match
// the Fields in a FieldList.
//
// Created by JMO, Sun Nov 3 14:11:32 PST 2013
//----------------------------------------------------------------------------//
#ifndef __Spheral_CompositeFieldListPolicy_hh__
#define __Spheral_CompositeFieldListPolicy_hh__
#include "FieldListUpdatePolicyBase.hh"
#include <vector>
#include <memory> // unique_ptr/shared_ptr
namespace Spheral {
// Forward declarations.
template<typename Dimension> class StateDerivatives;
template<typename Dimension, typename ValueType>
class CompositeFieldListPolicy: public FieldListUpdatePolicyBase<Dimension, ValueType> {
public:
//--------------------------- Public Interface ---------------------------//
// Useful typedefs
typedef typename std::shared_ptr<UpdatePolicyBase<Dimension> > PolicyPointer;
typedef typename FieldListUpdatePolicyBase<Dimension, ValueType>::KeyType KeyType;
// Constructors, destructor.
CompositeFieldListPolicy();
virtual ~CompositeFieldListPolicy();
// Overload the methods describing how to update Fields.
virtual void update(const KeyType& key,
State<Dimension>& state,
StateDerivatives<Dimension>& derivs,
const double multiplier,
const double t,
const double dt);
// An alternate method to be called when you want to specify that the derivative information
// should be assumed to not necessarily be properly time-centered, and therefore you should
// only use time advancement ideas, no "replace" or more sophisticated approaches.
// Default to just calling the generic method.
virtual void updateAsIncrement(const KeyType& key,
State<Dimension>& state,
StateDerivatives<Dimension>& derivs,
const double multiplier,
const double t,
const double dt);
// Equivalence.
virtual bool operator==(const UpdatePolicyBase<Dimension>& rhs) const;
// Add new UpdatePolicies to this thing.
void push_back(UpdatePolicyBase<Dimension>* policyPtr);
private:
//--------------------------- Private Interface ---------------------------//
std::vector<std::unique_ptr<UpdatePolicyBase<Dimension>>> mPolicyPtrs;
CompositeFieldListPolicy(const CompositeFieldListPolicy& rhs);
CompositeFieldListPolicy& operator=(const CompositeFieldListPolicy& rhs);
};
}
#else
// Forward declaration.
namespace Spheral {
template<typename Dimension, typename ValueType> class CompositeFieldListPolicy;
}
#endif
| 37.552632 | 94 | 0.640505 | jmikeowen |
21d83db77fc892ded98fa45d60f659e3ca1f2cbb | 959 | hpp | C++ | player/playerlib/Render.hpp | zhenfei2016/FFL-v2 | 376c79a0611af580d4767a4bbb05822f1a4fd454 | [
"MIT"
] | null | null | null | player/playerlib/Render.hpp | zhenfei2016/FFL-v2 | 376c79a0611af580d4767a4bbb05822f1a4fd454 | [
"MIT"
] | null | null | null | player/playerlib/Render.hpp | zhenfei2016/FFL-v2 | 376c79a0611af580d4767a4bbb05822f1a4fd454 | [
"MIT"
] | null | null | null | /*
* This file is part of FFL project.
*
* The MIT License (MIT)
* Copyright (C) 2017-2018 zhufeifei All rights reserved.
*
* Render.hpp
* Created by zhufeifei([email protected]) on 2018/03/10
*
* 渲染基类
*
*/
#pragma once
#include "NodeBase.hpp"
namespace player {
class Render : public NodeBase{
public:
Render();
~Render();
virtual void pause();
virtual void resume();
//
// 获取这个节点处理的延迟
//
int64_t getDelayUs() { return 0; }
//
// 获取，设置渲染速度
//
void setSpeed(uint32_t speed);
uint32_t getSpeed();
//
// 获取渲染时钟，可以改变时钟速度
//
virtual FFL::sp<FFL::Clock> getRenderClock()=0;
protected:
//
// 更新当前绘制tm时间戳的帧
//
void updateRenderTimestamp(int64_t tm,int32_t streamId);
protected:
//
// 外部setDataInput时候调用此函数，创建对应conn
//
virtual FFL::sp<FFL::PipelineConnector > onCreateConnector(const OutputInterface& output,
const InputInterface& input,void* userdata)=0;
private:
uint32_t mSpeed;
};
}
| 17.759259 | 91 | 0.661105 | zhenfei2016 |
21d8d4ff95b58be3a09e674ebc76fdc2a317ec8c | 498 | cpp | C++ | Engine/UI/Private/UIWindow.cpp | heretique/Atlas | 0981e7941b570ecfda1febf71b4669338ab81921 | [
"MIT"
] | 6 | 2016-11-09T08:40:10.000Z | 2021-10-06T09:47:05.000Z | Engine/UI/Private/UIWindow.cpp | heretique/Atlas | 0981e7941b570ecfda1febf71b4669338ab81921 | [
"MIT"
] | null | null | null | Engine/UI/Private/UIWindow.cpp | heretique/Atlas | 0981e7941b570ecfda1febf71b4669338ab81921 | [
"MIT"
] | 3 | 2016-11-09T08:38:59.000Z | 2021-12-24T16:03:59.000Z | #include "UI/UIWindow.h"
namespace atlas
{
UIWindow::UIWindow(const std::string& name, ImGuiWindowFlags flags)
: _name(name)
, _flags(flags)
, _hash(hq::StringHash(_name))
{
}
UIWindow::~UIWindow() { }
hq::StringHash UIWindow::windowId() const
{
return _hash;
}
bool UIWindow::update(float deltaTime)
{
namespace ui = ImGui;
if(ui::Begin(_name.c_str(), &_isOpen, _flags))
{
onGUI(deltaTime);
}
ui::End();
return _isOpen;
}
} // atlas namespace
| 16.064516 | 67 | 0.63253 | heretique |
21d9a9071e647d2bc72ab433d13467a0fdf45614 | 114 | hpp | C++ | book/cpp_templates/tmplbook/variant/variantstorageastuple.hpp | houruixiang/day_day_learning | 208f70a4f0a85dd99191087835903d279452fd54 | [
"MIT"
] | null | null | null | book/cpp_templates/tmplbook/variant/variantstorageastuple.hpp | houruixiang/day_day_learning | 208f70a4f0a85dd99191087835903d279452fd54 | [
"MIT"
] | null | null | null | book/cpp_templates/tmplbook/variant/variantstorageastuple.hpp | houruixiang/day_day_learning | 208f70a4f0a85dd99191087835903d279452fd54 | [
"MIT"
] | null | null | null | template<typename... Types>
class Variant {
public:
Tuple<Types...> storage;
unsigned char discriminator;
};
| 16.285714 | 30 | 0.710526 | houruixiang |
21ddf3f0edc24981eb74dc9bee215d459bdd3370 | 1,116 | cc | C++ | lib/tests/fixtures/dmi_fixtures.cc | GabrielNagy/libwhereami | 8061b056b38ad2508b735465eae4bd9817091183 | [
"Apache-2.0"
] | 16 | 2017-07-12T05:58:59.000Z | 2022-03-11T01:07:10.000Z | lib/tests/fixtures/dmi_fixtures.cc | GabrielNagy/libwhereami | 8061b056b38ad2508b735465eae4bd9817091183 | [
"Apache-2.0"
] | 41 | 2017-07-07T16:44:57.000Z | 2019-08-27T13:05:38.000Z | lib/tests/fixtures/dmi_fixtures.cc | GabrielNagy/libwhereami | 8061b056b38ad2508b735465eae4bd9817091183 | [
"Apache-2.0"
] | 16 | 2017-07-05T15:23:40.000Z | 2022-03-17T21:11:20.000Z | #include "./dmi_fixtures.hpp"
using namespace whereami::testing;
using namespace whereami::sources;
using namespace std;
namespace whereami { namespace testing { namespace dmi {
std::string dmi_fixture::sys_path(std::string const& filename) const
{
return fixture_root + sys_fixture_path_ + filename;
}
smbios_data const* dmi_fixture::data()
{
if (!data_) {
string dmidecode_output;
load_fixture(dmidecode_fixture_path_, dmidecode_output);
collect_data_from_dmidecode(dmidecode_output);
if (data_ == nullptr) {
if (!collect_data_from_sys()) {
data_.reset(new smbios_data);
}
}
}
return data_.get();
}
dmi_fixture_values::dmi_fixture_values(sources::smbios_data&& data)
{
data_.reset(new smbios_data(move(data)));
}
smbios_data const* dmi_fixture_empty::data()
{
if (!data_) {
data_.reset(new smbios_data);
}
return data_.get();
}
}}} // namespace whereami::testing::dmi
| 24.8 | 72 | 0.598566 | GabrielNagy |
21e6b97aa501c5410b492e0dffac55243f72a19f | 2,761 | cpp | C++ | MC/MC/mcTransportRectangleTrap.cpp | x2v0/MC | 2c5667cf3f12de573f969e371bbe0af30fa52023 | [
"MIT"
] | null | null | null | MC/MC/mcTransportRectangleTrap.cpp | x2v0/MC | 2c5667cf3f12de573f969e371bbe0af30fa52023 | [
"MIT"
] | null | null | null | MC/MC/mcTransportRectangleTrap.cpp | x2v0/MC | 2c5667cf3f12de573f969e371bbe0af30fa52023 | [
"MIT"
] | null | null | null | #include "mcTransportRectangleTrap.h"
mcTransportRectangleTrap::mcTransportRectangleTrap(const geomVector3D& orgn, const geomVector3D& z,
const geomVector3D& x) : mcTransport(orgn, z, x), fsx1_(0), fsx2_(0),
fsy1_(0), fsy2_(0) {}
mcTransportRectangleTrap::~mcTransportRectangleTrap(void) {}
void mcTransportRectangleTrap::beginTransport(mcParticle& p)
{
if (p.u.z() <= 0)
return; // Доталкиваем частицу до плоскости
geomVector3D pp = p.p * mwtot_;
geomVector3D uu = (p.p + p.u) * mwtot_;
uu = uu - pp;
double f = -pp.z() / uu.z();
double x = pp.x() + uu.x() * f;
if (x < fsx1_ || x > fsx2_)
return;
double y = pp.y() + uu.y() * f;
if (y < fsy1_ || y > fsy2_)
return;
if (nextTransport_ != nullptr)
nextTransport_->beginTransport(p);
}
void mcTransportRectangleTrap::SetFieldSize(double x1, double x2, double y1, double y2)
{
fsx1_ = x1;
fsx2_ = x2;
fsy1_ = y1;
fsy2_ = y2;
}
void mcTransportRectangleTrap::dumpVRML(ostream& os) const
{
int i = 0;
double r = 15; // размера бокса
geomVector3D p[8];
p[i++] = geomVector3D(-r, -r, 0) * mttow_;
p[i++] = geomVector3D(-r, r, 0) * mttow_;
p[i++] = geomVector3D(r, r, 0) * mttow_;
p[i++] = geomVector3D(r, -r, 0) * mttow_;
p[i++] = geomVector3D(fsx1_, fsy1_, 0) * mttow_;
p[i++] = geomVector3D(fsx1_, fsy2_, 0) * mttow_;
p[i++] = geomVector3D(fsx2_, fsy2_, 0) * mttow_;
p[i++] = geomVector3D(fsx2_, fsy1_, 0) * mttow_;
os << " Transform {" << endl;
os << " children Shape {" << endl;
os << " appearance Appearance {" << endl;
os << " material Material {" << endl;
os << " diffuseColor " << red_ << ' ' << green_ << ' ' << blue_ << endl;
os << " transparency " << transparancy_ << endl;
os << " }" << endl;
os << " }" << endl;
os << " geometry IndexedFaceSet {" << endl;
os << " coord Coordinate {" << endl;
os << " point [" << endl;
for (i = 0; i < 8; i++) {
os << " " << p[i].x() << ' ' << p[i].y() << ' ' << p[i].z();
if (i < 7)
os << ", ";
os << endl;
}
os << " ]" << endl;
os << " }" << endl;
os << " coordIndex [" << endl;
os << " 0, 1, 5, 4, -1," << endl;
os << " 1, 2, 6, 5, -1," << endl;
os << " 2, 3, 7, 6, -1," << endl;
os << " 3, 0, 4, 7, -1" << endl;
os << " ]" << endl;
os << " }" << endl;
os << " }" << endl;
os << " }" << endl;
}
| 33.670732 | 120 | 0.456356 | x2v0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.