blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
201
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 7
100
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 260
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 11.4k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 17
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 80
values | src_encoding
stringclasses 28
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 8
9.86M
| extension
stringclasses 52
values | content
stringlengths 8
9.86M
| authors
sequencelengths 1
1
| author
stringlengths 0
119
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
e33b9e3c5a7d986473acaa35057d337d5a0c5fde | e763b855be527d69fb2e824dfb693d09e59cdacb | /aws-cpp-sdk-apigateway/include/aws/apigateway/model/EndpointConfiguration.h | b8fb5ac08afd37e129a45ddd6530fbe378d4fba4 | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | 34234344543255455465/aws-sdk-cpp | 47de2d7bde504273a43c99188b544e497f743850 | 1d04ff6389a0ca24361523c58671ad0b2cde56f5 | refs/heads/master | 2023-06-10T16:15:54.618966 | 2018-05-07T23:32:08 | 2018-05-07T23:32:08 | 132,632,360 | 1 | 0 | Apache-2.0 | 2023-06-01T23:20:47 | 2018-05-08T15:56:35 | C++ | UTF-8 | C++ | false | false | 4,884 | h | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file 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 <aws/apigateway/APIGateway_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/apigateway/model/EndpointType.h>
#include <utility>
namespace Aws
{
namespace Utils
{
namespace Json
{
class JsonValue;
} // namespace Json
} // namespace Utils
namespace APIGateway
{
namespace Model
{
/**
* <p>The endpoint configuration to indicate the types of endpoints an API
* (<a>RestApi</a>) or its custom domain name (<a>DomainName</a>) has.
* </p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/apigateway-2015-07-09/EndpointConfiguration">AWS
* API Reference</a></p>
*/
class AWS_APIGATEWAY_API EndpointConfiguration
{
public:
EndpointConfiguration();
EndpointConfiguration(const Aws::Utils::Json::JsonValue& jsonValue);
EndpointConfiguration& operator=(const Aws::Utils::Json::JsonValue& jsonValue);
Aws::Utils::Json::JsonValue Jsonize() const;
/**
* <p>A list of endpoint types of an API (<a>RestApi</a>) or its custom domain name
* (<a>DomainName</a>). For an edge-optimized API and its custom domain name, the
* endpoint type is <code>"EDGE"</code>. For a regional API and its custom domain
* name, the endpoint type is <code>REGIONAL</code>.</p>
*/
inline const Aws::Vector<EndpointType>& GetTypes() const{ return m_types; }
/**
* <p>A list of endpoint types of an API (<a>RestApi</a>) or its custom domain name
* (<a>DomainName</a>). For an edge-optimized API and its custom domain name, the
* endpoint type is <code>"EDGE"</code>. For a regional API and its custom domain
* name, the endpoint type is <code>REGIONAL</code>.</p>
*/
inline void SetTypes(const Aws::Vector<EndpointType>& value) { m_typesHasBeenSet = true; m_types = value; }
/**
* <p>A list of endpoint types of an API (<a>RestApi</a>) or its custom domain name
* (<a>DomainName</a>). For an edge-optimized API and its custom domain name, the
* endpoint type is <code>"EDGE"</code>. For a regional API and its custom domain
* name, the endpoint type is <code>REGIONAL</code>.</p>
*/
inline void SetTypes(Aws::Vector<EndpointType>&& value) { m_typesHasBeenSet = true; m_types = std::move(value); }
/**
* <p>A list of endpoint types of an API (<a>RestApi</a>) or its custom domain name
* (<a>DomainName</a>). For an edge-optimized API and its custom domain name, the
* endpoint type is <code>"EDGE"</code>. For a regional API and its custom domain
* name, the endpoint type is <code>REGIONAL</code>.</p>
*/
inline EndpointConfiguration& WithTypes(const Aws::Vector<EndpointType>& value) { SetTypes(value); return *this;}
/**
* <p>A list of endpoint types of an API (<a>RestApi</a>) or its custom domain name
* (<a>DomainName</a>). For an edge-optimized API and its custom domain name, the
* endpoint type is <code>"EDGE"</code>. For a regional API and its custom domain
* name, the endpoint type is <code>REGIONAL</code>.</p>
*/
inline EndpointConfiguration& WithTypes(Aws::Vector<EndpointType>&& value) { SetTypes(std::move(value)); return *this;}
/**
* <p>A list of endpoint types of an API (<a>RestApi</a>) or its custom domain name
* (<a>DomainName</a>). For an edge-optimized API and its custom domain name, the
* endpoint type is <code>"EDGE"</code>. For a regional API and its custom domain
* name, the endpoint type is <code>REGIONAL</code>.</p>
*/
inline EndpointConfiguration& AddTypes(const EndpointType& value) { m_typesHasBeenSet = true; m_types.push_back(value); return *this; }
/**
* <p>A list of endpoint types of an API (<a>RestApi</a>) or its custom domain name
* (<a>DomainName</a>). For an edge-optimized API and its custom domain name, the
* endpoint type is <code>"EDGE"</code>. For a regional API and its custom domain
* name, the endpoint type is <code>REGIONAL</code>.</p>
*/
inline EndpointConfiguration& AddTypes(EndpointType&& value) { m_typesHasBeenSet = true; m_types.push_back(std::move(value)); return *this; }
private:
Aws::Vector<EndpointType> m_types;
bool m_typesHasBeenSet;
};
} // namespace Model
} // namespace APIGateway
} // namespace Aws
| [
"[email protected]"
] | |
3fc808abd8c806f82b37f160f6561cdc0e8b0ff3 | 1918829b482d834c3014c59f4e8003dc9863ee9a | /CPP07/ex00/main.cpp | ed306b3608a645dec443fca07c151c4609124a8c | [] | no_license | hollyhox-21/CPP_moduls | 655ef38c6d1d4781e68593453d1cad6a34e2d80a | eef9efd1eb3db10191ba8574eba740abdf9ee662 | refs/heads/master | 2023-04-16T07:38:56.514404 | 2021-05-04T16:14:36 | 2021-05-04T16:14:36 | 352,750,599 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,616 | cpp | //
// Created by Retro Joella on 4/29/21.
//
#include <string>
#include <iostream>
#include "whatever.hpp"
int main() {
int a = 2;
int b = 3;
my::ft_swap(a, b);
std::cout << "SWAP: " << a << "---" << b << std::endl;
std::cout << "MIN: " << my::ft_min(a, b) << std::endl;
std::cout << "MAX: " << my::ft_max(a, b) << std::endl << std::endl;
double c = 2.23;
double d = 3.434;
my::ft_swap(c, d);
std::cout << "SWAP: " << c << "---" << d << std::endl;
std::cout << "MIN: " << my::ft_min(c, d) << std::endl;
std::cout << "MAX: " << my::ft_max(c, d) << std::endl << std::endl;
char e = 'z';
char f = 'x';
my::ft_swap(e, f);
std::cout << "SWAP: " << e << "---" << f << std::endl;
std::cout << "MIN: " << my::ft_min(e, f) << std::endl;
std::cout << "MAX: " << my::ft_max(e, f) << std::endl << std::endl;
std::string g = "Hello";
std::string h = "World";
my::ft_swap(g, h);
std::cout << "SWAP: " << g << "---" << h << std::endl;
std::cout << "MIN: " << my::ft_min(g, h) << std::endl;
std::cout << "MAX: " << my::ft_max(g, h) << std::endl;
// int a = 2;
// int b = 3;
// my::ft_swap( a, b );
// std::cout << "a = " << a << ", b = " << b << std::endl;
// std::cout << "min( a, b ) = " << my::ft_min( a, b ) << std::endl;
// std::cout << "max( a, b ) = " << my::ft_max( a, b ) << std::endl;
// std::string c = "chaine1";
// std::string d = "chaine2";
// my::ft_swap(c, d);
// std::cout << "c = " << c << ", d = " << d << std::endl;
// std::cout << "min( c, d ) = " << my::ft_min( c, d ) << std::endl;
// std::cout << "max( c, d ) = " << my::ft_max( c, d ) << std::endl;
return 0;
}
| [
"[email protected]"
] | |
0aa619b147eef2e59ba50b27b258d3063cf79a07 | 8129f72a503e8d6e72f9986ccdc663411f49da04 | /3.15/src/libCom/test/epicsAtomicTest.cpp | 78cfa5b95b35a2f7af5ede69447cd41aaadbccaf | [
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-warranty-disclaimer",
"EPICS"
] | permissive | A2-Collaboration/epics | ec884bed2f0e3c60c274d08469bdb43939c355cb | 00b1c27f721ec53f1b2c7d581bc21ac16c607fc2 | refs/heads/master | 2022-12-12T00:08:35.528265 | 2022-12-02T11:33:07 | 2022-12-02T11:33:07 | 23,732,617 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,607 | cpp |
#include <stdlib.h>
#include <assert.h>
#include "epicsAtomic.h"
#include "epicsTime.h"
#include "epicsThread.h"
#include "epicsUnitTest.h"
#include "testMain.h"
using namespace epics;
using namespace atomic;
template < class T >
struct TestDataIncrDecr {
T m_testValue;
size_t m_testIterations;
};
template < class T >
struct TestDataAddSub {
T m_testValue;
size_t m_testIterations;
static const T delta = 17;
};
template < class T >
static void incr ( void *arg )
{
TestDataIncrDecr < T > * const pTestData =
reinterpret_cast < TestDataIncrDecr < T > * > ( arg );
increment ( pTestData->m_testValue );
increment ( pTestData->m_testIterations );
}
template < class T >
static void decr ( void *arg )
{
TestDataIncrDecr < T > * const pTestData =
reinterpret_cast < TestDataIncrDecr < T > * > ( arg );
decrement ( pTestData->m_testValue );
increment ( pTestData->m_testIterations );
}
template < class T >
static void add ( void *arg )
{
TestDataAddSub < T > * const pTestData =
reinterpret_cast < TestDataAddSub < T > * > ( arg );
add ( pTestData->m_testValue, TestDataAddSub < T > :: delta );
increment ( pTestData->m_testIterations );
}
template < class T >
static void sub ( void *arg )
{
TestDataAddSub < T > * const pTestData =
reinterpret_cast < TestDataAddSub < T > * > ( arg );
subtract ( pTestData->m_testValue, TestDataAddSub < T > :: delta );
increment ( pTestData->m_testIterations );
}
template < class T >
struct TestDataCAS {
T m_testValue;
size_t m_testIterationsSet;
size_t m_testIterationsNotSet;
};
int isModulo ( size_t N, size_t n )
{
return ( n % N ) == 0u;
}
template < class T >
static T trueValue ();
template < class T >
static T falseValue ();
// int
template <>
inline int trueValue < int > () { return 1; }
template <>
inline int falseValue < int > () { return 0; }
// size_t
template <>
inline size_t trueValue < size_t > () { return 1u; }
template <>
inline size_t falseValue < size_t > () { return 0u; }
// EpicsAtomicPtrT
template <>
inline EpicsAtomicPtrT trueValue < EpicsAtomicPtrT > ()
{ static char c; return & c; }
template <>
inline EpicsAtomicPtrT falseValue < EpicsAtomicPtrT > ()
{ return 0u; }
template < class T >
static void cas ( void *arg )
{
TestDataCAS < T > * const pTestData =
reinterpret_cast < TestDataCAS < T > * > ( arg );
/*
* intentionally waste cpu and maximize
* contention for the shared data
*/
increment ( pTestData->m_testIterationsNotSet );
while ( ! compareAndSwap ( pTestData->m_testValue,
falseValue < T > (),
trueValue < T > () ) ) {
}
decrement ( pTestData->m_testIterationsNotSet );
set ( pTestData->m_testValue, falseValue < T > () );
increment ( pTestData->m_testIterationsSet );
}
template < class T >
void testIncrDecr ()
{
static const size_t N = 100;
static const T NT = static_cast < T > ( N );
const unsigned int stackSize =
epicsThreadGetStackSize ( epicsThreadStackSmall );
TestDataIncrDecr < T > testData = { 0, N };
set ( testData.m_testValue, NT );
testOk ( get ( testData.m_testValue ) == NT,
"get returns initial incr/decr test data value that was set" );
set ( testData.m_testIterations, 0u );
testOk ( get ( testData.m_testIterations ) == 0u,
"get returns initial incr/decr test thread iterations value that was set" );
for ( size_t i = 0u; i < N; i++ ) {
epicsThreadCreate ( "incr",
50, stackSize, incr < T >, & testData );
epicsThreadCreate ( "decr",
50, stackSize, decr < T >, & testData );
}
while ( testData.m_testIterations < 2 * N ) {
epicsThreadSleep ( 0.01 );
}
testOk ( get ( testData.m_testIterations ) == 2 * N,
"proper number of incr/decr test thread iterations" );
testOk ( get ( testData.m_testValue ) == NT,
"proper final incr/decr test value" );
}
template < class T >
void testAddSub ()
{
static const size_t N = 100;
static const T NDT = TestDataAddSub < T > :: delta *
static_cast < T > ( N );
const unsigned int stackSize =
epicsThreadGetStackSize ( epicsThreadStackSmall );
TestDataIncrDecr < T > testData = { 0, N };
set ( testData.m_testValue, NDT );
testOk ( get ( testData.m_testValue ) == NDT,
"get returns initial add/sub test data value that was set" );
set ( testData.m_testIterations, 0u );
testOk ( get ( testData.m_testIterations ) == 0u,
"get returns initial incr/decr test thread iterations value that was set" );
for ( size_t i = 0u; i < N; i++ ) {
epicsThreadCreate ( "add",
50, stackSize, add < T >, & testData );
epicsThreadCreate ( "sub",
50, stackSize, sub < T >, & testData );
}
while ( testData.m_testIterations < 2 * N ) {
epicsThreadSleep ( 0.01 );
}
testOk ( get ( testData.m_testIterations ) == 2 * N,
"proper number of add/sub test thread iterations" );
testOk ( get ( testData.m_testValue ) == NDT,
"proper final add/sub test value" );
}
template < class T >
void testCAS ()
{
static const size_t N = 10;
const unsigned int stackSize =
epicsThreadGetStackSize ( epicsThreadStackSmall );
TestDataCAS < T > testData = { 0, N, N };
set ( testData.m_testIterationsSet, 0 );
testOk ( get ( testData.m_testIterationsSet ) == 0u,
"get returns initial CAS test thread "
"iterations set value" );
set ( testData.m_testIterationsNotSet, 0 );
testOk ( get ( testData.m_testIterationsNotSet ) == 0u,
"get returns initial CAS test thread "
"iterations not set value" );
set ( testData.m_testValue, trueValue < T > () );
testOk ( get ( testData.m_testValue ) == trueValue < T > (),
"set/get a true value" );
for ( size_t i = 0u; i < N; i++ ) {
epicsThreadCreate ( "tns",
50, stackSize, cas < T >, & testData );
}
set ( testData.m_testValue, falseValue < T > () );
while ( testData.m_testIterationsSet < N ) {
epicsThreadSleep ( 0.01 );
}
testOk ( get ( testData.m_testIterationsSet ) == N,
"proper number of CAS test thread set iterations" );
testOk ( get ( testData.m_testIterationsNotSet ) == 0u,
"proper number of CAS test thread not set iterations" );
}
// template instances, needed for vxWorks 5.5.2
#ifdef _MSC_VER
# pragma warning ( push )
# pragma warning ( disable:4660 )
#endif
template void incr < int > (void *);
template void decr < int > (void *);
template void incr < size_t > (void *);
template void decr < size_t > (void *);
template void add < int > (void *);
template void sub < int > (void *);
template void add < size_t > (void *);
template void sub < size_t > (void *);
template void cas < int > (void *);
template void cas < size_t > (void *);
template void cas < EpicsAtomicPtrT > (void *);
template void testIncrDecr < int > (void);
template void testIncrDecr < size_t > (void);
template void testAddSub < int > (void);
template void testAddSub < size_t > (void);
template void testCAS < int > (void);
template void testCAS < size_t > (void);
template void testCAS < EpicsAtomicPtrT > (void);
#ifdef _MSC_VER
# pragma warning ( pop )
#endif
MAIN ( epicsAtomicTest )
{
testPlan ( 31 );
testIncrDecr < int > ();
testIncrDecr < size_t > ();
testAddSub < int > ();
testAddSub < size_t > ();
testCAS < int > ();
testCAS < size_t > ();
testCAS < EpicsAtomicPtrT > ();
return testDone ();
}
| [
"[email protected]"
] | |
af3d8b271fb409bd2c8cc68794f68fe9e6430891 | 6c7d4c1462cb0d8d57ab6f11a4c67163a73de2ba | /user_defined_literals/uncooked_01.cpp | 804ef1e04467d888ebe1f493ba67d0314d9e25a3 | [] | no_license | yucelalbar/cpp-kursu-kodlar | 2bd4d78fa903f48a294d9d05bafecebcacaf2737 | ecc559c6adea33e3d8b6f6067b2bb410d2bf4e51 | refs/heads/main | 2023-01-01T15:07:27.395448 | 2020-10-23T13:54:08 | 2020-10-23T13:54:08 | 307,342,679 | 3 | 0 | null | 2020-10-26T10:57:05 | 2020-10-26T10:57:04 | null | UTF-8 | C++ | false | false | 579 | cpp | #include <iostream>
using namespace std;
unsigned int operator"" _b(const char* p)
{
unsigned uval = 0;
while (*p) {
char digit = *p;
if (digit != '1' && digit != '0') {
throw std::runtime_error("0 ya da 1 olmayan karakter\n");
}
uval = uval * 2 + (digit - '0');
++p;
}
return uval;
}
int main() try
{
unsigned uval1 = 101_b;
std::cout << "uval1 = " << uval1 << '\n';
unsigned uval2 = 124_b; //exception gonderecek
std::cout << "uval2 = " << uval1 << '\n';
}
catch (const std::exception& e)
{
std::cerr << "hata yakalandi: " << e.what() << "\n";
}
| [
"[email protected]"
] | |
13318408a52815bc4f2510bc72a6e8940c24fd20 | 2ba94892764a44d9c07f0f549f79f9f9dc272151 | /Engine/Source/Editor/DataTableEditor/Private/DataTableEditor.h | 4ee7f0e0a02ff54d54fbde08204efa326fa0e72b | [
"BSD-2-Clause",
"LicenseRef-scancode-proprietary-license"
] | permissive | PopCap/GameIdea | 934769eeb91f9637f5bf205d88b13ff1fc9ae8fd | 201e1df50b2bc99afc079ce326aa0a44b178a391 | refs/heads/master | 2021-01-25T00:11:38.709772 | 2018-09-11T03:38:56 | 2018-09-11T03:38:56 | 37,818,708 | 0 | 0 | BSD-2-Clause | 2018-09-11T03:39:05 | 2015-06-21T17:36:44 | null | UTF-8 | C++ | false | false | 6,074 | h | // Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "IDataTableEditor.h"
#include "Toolkits/AssetEditorToolkit.h"
#include "EditorUndoClient.h"
#include "Kismet2/StructureEditorUtils.h"
#include "DataTableEditorUtils.h"
class UDataTable;
class FJsonObject;
DECLARE_DELEGATE_OneParam(FOnRowHighlighted, FName /*Row name*/);
/** Viewer/editor for a DataTable */
class FDataTableEditor : public IDataTableEditor
, public FEditorUndoClient
, public FStructureEditorUtils::INotifyOnStructChanged
, public FDataTableEditorUtils::INotifyOnDataTableChanged
{
friend class SDataTableListViewRow;
public:
virtual void RegisterTabSpawners(const TSharedRef<class FTabManager>& TabManager) override;
virtual void UnregisterTabSpawners(const TSharedRef<class FTabManager>& TabManager) override;
/**
* Edits the specified table
*
* @param Mode Asset editing mode for this editor (standalone or world-centric)
* @param InitToolkitHost When Mode is WorldCentric, this is the level editor instance to spawn this editor within
* @param Table The table to edit
*/
void InitDataTableEditor( const EToolkitMode::Type Mode, const TSharedPtr< class IToolkitHost >& InitToolkitHost, UDataTable* Table );
/** Constructor */
FDataTableEditor();
/** Destructor */
virtual ~FDataTableEditor();
/** IToolkit interface */
virtual FName GetToolkitFName() const override;
virtual FText GetBaseToolkitName() const override;
virtual FString GetWorldCentricTabPrefix() const override;
virtual FLinearColor GetWorldCentricTabColorScale() const override;
// FEditorUndoClient
virtual void PostUndo(bool bSuccess) override;
virtual void PostRedo(bool bSuccess) override;
void HandleUndoRedo();
// INotifyOnStructChanged
virtual void PreChange(const class UUserDefinedStruct* Struct, FStructureEditorUtils::EStructureEditorChangeInfo Info) override;
virtual void PostChange(const class UUserDefinedStruct* Struct, FStructureEditorUtils::EStructureEditorChangeInfo Info) override;
// INotifyOnDataTableChanged
virtual void PreChange(const UDataTable* Changed, FDataTableEditorUtils::EDataTableChangeInfo Info) override;
virtual void PostChange(const UDataTable* Changed, FDataTableEditorUtils::EDataTableChangeInfo Info) override;
/** Get the data table being edited */
const UDataTable* GetDataTable() const;
void HandlePostChange();
void SetHighlightedRow(FName Name);
private:
void RefreshCachedDataTable();
void UpdateVisibleRows();
void RestoreCachedSelection(const FName InCachedSelection, const bool bUpdateEvenIfValid = false);
FText GetFilterText() const;
void OnFilterTextChanged(const FText& InFilterText);
FSlateColor GetRowTextColor(FName RowName) const;
TSharedRef<SVerticalBox> CreateContentBox();
TSharedRef<SWidget> CreateRowEditorBox();
/** Spawns the tab with the data table inside */
TSharedRef<SDockTab> SpawnTab_DataTable( const FSpawnTabArgs& Args );
/** Spawns the tab with the Row Editor inside */
TSharedRef<SDockTab> SpawnTab_RowEditor(const FSpawnTabArgs& Args);
FOptionalSize GetRowNameColumnWidth() const;
float GetColumnWidth(const int32 ColumnIndex) const;
void OnColumnResized(const float NewWidth, const int32 ColumnIndex);
void LoadLayoutData();
void SaveLayoutData();
/** Make the widget for a row name entry in the data table row list view */
TSharedRef<ITableRow> MakeRowNameWidget(FDataTableEditorRowListViewDataPtr InRowDataPtr, const TSharedRef<STableViewBase>& OwnerTable);
/** Make the widget for a row entry in the data table row list view */
TSharedRef<ITableRow> MakeRowWidget(FDataTableEditorRowListViewDataPtr InRowDataPtr, const TSharedRef<STableViewBase>& OwnerTable);
/** Make the widget for a cell entry in the data table row list view */
TSharedRef<SWidget> MakeCellWidget(FDataTableEditorRowListViewDataPtr InRowDataPtr, const int32 InRowIndex, const FName& InColumnId);
void OnRowNamesListViewScrolled(double InScrollOffset);
void OnCellsListViewScrolled(double InScrollOffset);
void OnRowSelectionChanged(FDataTableEditorRowListViewDataPtr InNewSelection, ESelectInfo::Type InSelectInfo);
private:
/** Struct holding information about the current column widths */
struct FColumnWidth
{
FColumnWidth()
: bIsAutoSized(true)
, CurrentWidth(0.0f)
{
}
/** True if this column is being auto-sized rather than sized by the user */
bool bIsAutoSized;
/** The width of the column, either sized by the user, or auto-sized */
float CurrentWidth;
};
/** Array of the columns that are available for editing */
TArray<FDataTableEditorColumnHeaderDataPtr> AvailableColumns;
/** Array of the rows that are available for editing */
TArray<FDataTableEditorRowListViewDataPtr> AvailableRows;
/** Array of the rows that match the active filter(s) */
TArray<FDataTableEditorRowListViewDataPtr> VisibleRows;
/** Header row containing entries for each column in AvailableColumns */
TSharedPtr<SHeaderRow> ColumnNamesHeaderRow;
/** List view responsible for showing the row names column */
TSharedPtr<SListView<FDataTableEditorRowListViewDataPtr>> RowNamesListView;
/** List view responsible for showing the rows in VisibleRows for each entry in AvailableColumns */
TSharedPtr<SListView<FDataTableEditorRowListViewDataPtr>> CellsListView;
/** Width of the row name column */
float RowNameColumnWidth;
/** Widths of data table cell columns */
TArray<FColumnWidth> ColumnWidths;
/** The layout data for the currently loaded data table */
TSharedPtr<FJsonObject> LayoutData;
/** The name of the currently selected row */
FName HighlightedRowName;
/** The current filter text applied to the data table */
FText ActiveFilterText;
FOnRowHighlighted CallbackOnRowHighlighted;
FSimpleDelegate CallbackOnDataTableUndoRedo;
/** The tab id for the data table tab */
static const FName DataTableTabId;
/** The tab id for the row editor tab */
static const FName RowEditorTabId;
/** The column id for the row name list view column */
static const FName RowNameColumnId;
};
| [
"[email protected]"
] | |
431b23be120ecb560c20e0e62de5b376ae13a47a | 7c08dedb85374fd497f207eab8dccab3cdd60af0 | /libmiemu/datapath/hazard_detection.cpp | c2a1d5881d3508e51d000dffac4ade3941192e58 | [] | no_license | thirtythreeforty/mipssion-impossible | a8054ada7afb56a516474d962bca862be3b578e1 | 10f244d799d384e1c12aae02386049c3c84abac8 | refs/heads/master | 2021-01-19T23:05:55.620733 | 2016-04-27T19:05:18 | 2016-04-27T19:05:18 | 54,495,085 | 6 | 3 | null | 2016-04-25T23:40:28 | 2016-03-22T17:26:44 | C++ | UTF-8 | C++ | false | false | 296 | cpp | #include "hazard_detection.h"
#include "signals.h"
void HDU::signals_in(const IFID& ifid, const IDEX& idex, const EXMEM& exmem, const MEMWB& memwb) {
}
void HDU::tick() {
}
void HDU::tock() {
}
bool HDU::signals_out() const {
//needs to return 1 to stall, 0 for normal op
return 0;
}
| [
"[email protected]"
] | |
f9a7b02c7f6eab8504a8f136c01c34cad902f212 | 1cf83a6a2c58fb8449124ebd62559dd5dacccf8a | /GlobalIllumination/src/FileManager.cpp | 1e8e7efc4ea9f9fa549828cf32d2426178020609 | [
"MIT"
] | permissive | raptoravis/voxelbasedgi | 8c7ead3b2e510e735f809279ae99686d3a21f62f | aaf2b02929edfaf72528c2f029696728c5f1d30f | refs/heads/master | 2022-10-16T19:09:20.111719 | 2020-06-07T12:25:54 | 2020-06-07T12:25:54 | 269,060,129 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,894 | cpp | #include <stdafx.h>
#include <FileManager.h>
void FileManager::AddDirectory(const char *directory)
{
if (!directory)
return;
for (unsigned int i = 0; i < directories.GetSize(); i++)
{
if (strcmp(directories[i], directory) == 0)
return;
}
char newDirectory[DEMO_MAX_STRING];
strcpy(newDirectory, directory);
directories.AddElement(&newDirectory);
}
void FileManager::RemoveDirectories()
{
directories.Clear();
}
bool FileManager::FilePathExists(const char *filePath) const
{
if (!filePath)
return false;
return (GetFileAttributes(filePath) != 0xFFFFFFFF);
}
bool FileManager::SetWorkDirectory(const char *workDirectory) const
{
if (!workDirectory)
return false;
return (_chdir(workDirectory) == 0);
}
bool FileManager::GetExeDirectory(char *exeDirectory) const
{
if (!exeDirectory)
return false;
if (GetModuleFileName(NULL, exeDirectory, DEMO_MAX_FILEPATH) == 0)
return false;
std::string directory = exeDirectory;
directory = directory.substr(0, directory.find_last_of('\\'));
strcpy(exeDirectory, directory.c_str());
return true;
}
bool FileManager::GetFilePath(const char *fileName, char *filePath) const
{
if ((!fileName) || (!filePath))
return false;
for (unsigned int i = 0; i < directories.GetSize(); i++)
{
strcpy(filePath, directories[i]);
strcat(filePath, fileName);
if (FilePathExists(filePath))
return true;
}
return false;
}
bool FileManager::GetFileName(const char *filePath, char *fileName) const
{
if ((!filePath) || (!fileName))
return false;
std::string filename = filePath;
int indexA = filename.find_last_of("/");
int indexB = filename.find_last_of("\\");
int index = (indexA > indexB) ? indexA : indexB;
if (index > -1)
filename.erase(0, index + 1);
index = filename.find_last_of(".");
if (index > -1)
filename.erase(index, filename.length() - index);
strcpy(fileName, filename.c_str());
return true;
} | [
"[email protected]"
] | |
32b2ac199d61b09390310b9b9f599a5abe042132 | fca68c5fec6df6f999408571315c2b8e7c4b8ce9 | /service/old_programs_home/findbug_svhits/src/TrackFitter/Instantiate/T_LatticeElectronSVZHit.cc | eefd439d1fee7b1805d6837eb5904b3c16a198ab | [] | no_license | jpivarski-talks/1999-2006_gradschool-3 | 8b2ea0b6babef104b0281c069994fc9894a05b14 | 57e80d601c0519f9e01a07ecb53d367846e8306e | refs/heads/master | 2022-11-19T12:01:42.959599 | 2020-07-25T01:19:59 | 2020-07-25T01:19:59 | 282,235,559 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,102 | cc | // -*- C++ -*-
//
// Package: TrackFitter
// Module: T_LatticeElectronSVZHit
//
// Description: Instantiate Lattice
//
// Implementation:
//
// Author: Michael Marsh
// Created: Tue Dec 15 10:06 EST 1998
#include "Experiment/Experiment.h"
#include "Experiment/types.h"
#if defined(AMBIGUOUS_STRING_FUNCTIONS_BUG)
#include <string>
#endif /* AMBIGUOUS_STRING_FUNCTIONS_BUG */
#if defined(STL_TEMPLATE_DEFAULT_PARAMS_FIRST_BUG)
#include <vector>
////#include <list>
#include <map>
#endif /* STL_TEMPLATE_DEFAULT_PARAMS_FIRST_BUG */
#include "TrackRoot/TRHelixCandidateFit.h"
#include "TrackFitter/TrackFitSVZHitLink.h"
typedef TRHelixCandidateFit< DBCandidate::kElectron > _left_lattice_type_;
typedef CalibratedSVZHit _right_lattice_type_;
typedef TrackFitSVZHitLink _linkdata_type_;
#define INSTANTIATE_LATTICE_VECTOR_LINK
//#define INSTANTIATE_LATTICE_VECTOR_LEFTID
//#define INSTANTIATE_LATTICE_VECTOR_RIGHTID
#define INSTANTIATE_LATTICE_VECTOR_LEFTNODE
#define INSTANTIATE_LATTICE_VECTOR_RIGHTNODE
//#define INSTANTIATE_LATTICE_FIND
#include "Lattice/instantiate_Lattice.h"
| [
"[email protected]"
] | |
7f66a579e6c190c6ff3b70e794e13bf6adcf3a17 | 7e79503f4bc7f67ffe8dcba8ba6f4e22614d2e09 | /test/TestDeltaNotchReporterLimi.hpp | 5a7e34a39787ec1d373c3224c03562ff50a0ab3a | [] | no_license | acry-sta/MT5599 | 26259bfdbf45555af7e64de9536ab8b3c2d40456 | 72fca0ae4a21e263e5621acd04cc84fce4dda505 | refs/heads/master | 2023-04-10T01:24:55.736040 | 2021-04-22T16:58:35 | 2021-04-22T16:58:35 | 325,792,381 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,099 | hpp | /*
Copyright (c) 2005-2019, University of Oxford.
All rights reserved.
University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.
This file is part of Chaste.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the University of Oxford nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
*
* Chaste tutorial - this page gets automatically changed to a wiki page
* DO NOT remove the comments below, and if the code has to be changed in
* order to run, please check the comments are still accurate
*
*
*/
#ifndef TESTDELTANOTCHREPORTERLIMI_HPP_
#define TESTDELTANOTCHREPORTERLIMI_HPP_
/*
* = An example showing how to run Delta/Notch simulations =
*
* EMPTYLINE
*
* == Introduction ==
*
* EMPTYLINE
*
* In this tutorial we show how Chaste can be used to simulate a growing cell monolayer culture
* into which a model of Delta/Notch/Reporter signalling with mutual inactivation is incorporated.
* This model was developed by Sprinzak et al. (Sprinzak D, Lakhanpal A, LeBon L, Garcia-Ojalvo J, Elowitz MB (2011)
* "Mutual Inactivation of Notch Receptors and Ligands Facilitates Developmental Patterning".
* PLoS Comput Biol 7(6): e1002069. https://doi.org/10.1371/journal.pcbi.1002069)
* This comprises three ODEs to describe the evolution in concentrations of Delta, Notch, and a
* Reporter of Notch Intracellular Domain in each cell. The ODEs
* for Notch and Delta include a reaction term that depends on the mean Delta and mean Notch
* concentration among neighbouring cells. Thus in this simulation each cell needs to be able to
* access information about its neighbours. We use the {{{CellData}}} class to facilitate this, and introduce a subclass
* of {{{OffLatticeSimulation}}} called {{{DeltaNotchOffLatticeSimulation}}} to handle the updating
* of {{{CellData}}} at each time step as cell neighbours change.
*
* EMPTYLINE
*
* == The test ==
*
* EMPTYLINE
*
* As in previous tutorials, we begin by including the necessary header files. We have
* encountered these files already. Recall that often, either {{{CheckpointArchiveTypes.hpp}}}
* or {{{CellBasedSimulationArchiver.hpp}}} must be included the first Chaste header.
*/
#include <cxxtest/TestSuite.h>
#include "CheckpointArchiveTypes.hpp"
#include "AbstractCellBasedTestSuite.hpp"
#include "HoneycombMeshGenerator.hpp"
#include "HoneycombVertexMeshGenerator.hpp"
#include "CylindricalHoneycombVertexMeshGenerator.hpp"
#include "NodeBasedCellPopulation.hpp"
#include "OffLatticeSimulation.hpp"
#include "VertexBasedCellPopulation.hpp"
#include "NagaiHondaForce.hpp"
#include "SimpleTargetAreaModifier.hpp"
#include "GeneralisedLinearSpringForce.hpp"
#include "DifferentiatedCellProliferativeType.hpp"
#include "WildTypeCellMutationState.hpp"
#include "CellAgesWriter.hpp"
#include "CellIdWriter.hpp"
#include "CellProliferativePhasesWriter.hpp"
#include "CellVolumesWriter.hpp"
#include "CellMutationStatesCountWriter.hpp"
#include "CellProliferativePhasesCountWriter.hpp"
#include "CellProliferativeTypesCountWriter.hpp"
#include "SmartPointers.hpp"
#include "PetscSetupAndFinalize.hpp"
#include "UniformG1GenerationalCellCycleModel.hpp"
/*
* The next header file defines a simple subcellular reaction network model that includes the functionality
* for solving each cell's Delta/Notch signalling ODE system at each time step, using information about neighbouring
* cells through the {{{CellData}}} class.
*/
#include "DeltaNotchReporterSrnModelLimi.hpp"
/*
* The next header defines the simulation class modifier corresponding to the Delta-Notch-Reporter SRN model.
* This modifier leads to the {{{CellData}}} cell property being updated at each timestep to deal with Delta-Notch signalling.
*/
#include "DeltaNotchReporterTrackingModifier.hpp"
/* Having included all the necessary header files, we proceed by defining the test class.
*/
class TestDeltaNotchReporterLimi : public AbstractCellBasedTestSuite
{
public:
void TestVertexBasedMonolayerWithDeltaNotch()
{
/* We include the next line because Vertex simulations cannot be run in parallel */
EXIT_IF_PARALLEL;
/* First we create a regular vertex mesh. */
HoneycombVertexMeshGenerator generator(12, 12);
MutableVertexMesh<2,2>* p_mesh = generator.GetMesh();
/* Option to create cylindrical vertex mesh for periodicity in the horizontal direction. */
// CylindricalHoneycombVertexMeshGenerator generator(12, 12);
// Cylindrical2dVertexMesh* p_mesh = generator.GetCylindricalMesh();
/* We then create some cells, each with a cell-cycle model, {{{UniformG1GenerationalCellCycleModel}}} and a subcellular reaction network model
* {{{DeltaNotchReporterSrnModelLimi}}}, which incorporates a Delta/Notch/Reporter ODE system with mutual inactivation,
* as developed by Sprinzak et al (2011)
* We choose to initialise the concentrations of Notch and Delta to random levels in [0, 1]
* in each cell. Similarly the concentration of Reporter in each cell is randomly initialized, but
* to a very low value.
* In this example we choose to make each cell differentiated,
* so that no cell division occurs. */
std::vector<CellPtr> cells;
MAKE_PTR(WildTypeCellMutationState, p_state);
MAKE_PTR(DifferentiatedCellProliferativeType, p_diff_type);
for (unsigned elem_index=0; elem_index<p_mesh->GetNumElements(); elem_index++)
{
UniformG1GenerationalCellCycleModel* p_cc_model = new UniformG1GenerationalCellCycleModel();
p_cc_model->SetDimension(2);
/* We choose to initialise the concentrations to random levels in each cell. */
std::vector<double> initial_conditions;
initial_conditions.push_back(RandomNumberGenerator::Instance()->ranf());
initial_conditions.push_back(RandomNumberGenerator::Instance()->ranf());
initial_conditions.push_back(RandomNumberGenerator::Instance()->ranf());
DeltaNotchReporterSrnModelLimi* p_srn_model = new DeltaNotchReporterSrnModelLimi();
p_srn_model->SetInitialConditions(initial_conditions);
CellPtr p_cell(new Cell(p_state, p_cc_model, p_srn_model));
p_cell->SetCellProliferativeType(p_diff_type);
double birth_time = -RandomNumberGenerator::Instance()->ranf()*12.0;
p_cell->SetBirthTime(birth_time);
cells.push_back(p_cell);
}
/* Using the vertex mesh and cells, we create a cell-based population object, and specify which results to
* output to file. */
VertexBasedCellPopulation<2> cell_population(*p_mesh, cells);
cell_population.AddCellPopulationCountWriter<CellMutationStatesCountWriter>();
cell_population.AddCellPopulationCountWriter<CellProliferativeTypesCountWriter>();
cell_population.AddCellPopulationCountWriter<CellProliferativePhasesCountWriter>();
cell_population.AddCellWriter<CellProliferativePhasesWriter>();
cell_population.AddCellWriter<CellAgesWriter>();
cell_population.AddCellWriter<CellVolumesWriter>();
/* We are now in a position to create and configure the cell-based simulation object, pass a force law to it,
* and run the simulation. We can make the simulation run for longer to see more patterning by increasing the end time. */
OffLatticeSimulation<2> simulator(cell_population);
simulator.SetOutputDirectory("TestVertex12x12PeriodicLimi");
simulator.SetSamplingTimestepMultiple(10);
simulator.SetEndTime(20.0);
/* Then, we define the modifier class, which automatically updates the values of Delta and Notch within the cells in {{{CellData}}} and passes it to the simulation.*/
MAKE_PTR(DeltaNotchReporterTrackingModifier<2>, p_modifier);
simulator.AddSimulationModifier(p_modifier);
MAKE_PTR(NagaiHondaForce<2>, p_force);
simulator.AddForce(p_force);
/* This modifier assigns target areas to each cell, which are required by the {{{NagaiHondaForce}}}.
*/
MAKE_PTR(SimpleTargetAreaModifier<2>, p_growth_modifier);
simulator.AddSimulationModifier(p_growth_modifier);
simulator.Solve();
}
/*
* EMPTYLINE
*
* To visualize the results, use Paraview. See the UserTutorials/VisualizingWithParaview tutorial for more information.
*
* Load the file {{{/tmp/$USER/testoutput/TestVertexBasedMonolayerWithDeltaNotch/results_from_time_0/results.pvd}}}.
*
* EMPTYLINE
*
*/
};
#endif /*TESTDELTANOTCHREPORTERLIMI_HPP_*/
| [
"[email protected]"
] | |
2fa1de5d69cd0d718c38ffe95404cb4c1208fe73 | e8c371da76a332c735eb27023eedd968481274d8 | /method_lib/old/ChiSquareArmitage.h | 3f16ab43cdcb9e65d43dfb4da1b8660c47ad1c28 | [] | no_license | RitchieLab/PLATO | 74001472ab53fc0f3e5bea3fe77f6d6772471c55 | 5f718945498f7e926ce95919a3bbeb82e0e54700 | refs/heads/master | 2021-06-15T01:28:08.849694 | 2018-07-20T21:25:28 | 2018-07-20T21:25:28 | 90,042,326 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 268 | h | #ifndef CHISQUAREARMITAGE_H
#define CHISQUAREARMITAGE_H
#include <vector>
#include <math.h>
#include <iostream>
using namespace std;
namespace Methods{
class ChiSquareArmitage{
public:
static double armitage(vector<vector<int> > & chiTotals);
};
};
#endif
| [
"[email protected]@9e62ecf6-770d-0410-a9d7-e62a33e3d092"
] | [email protected]@9e62ecf6-770d-0410-a9d7-e62a33e3d092 |
35d5ef4b1ec16a9930985550bce5da63cb116cfd | b718239567a33950e436ad77e4045af68675d51d | /main.cpp | aa33027a7d7c104ba0cb85acf610a66d9154e4ae | [] | no_license | hphpx/option-pricing-with-binomial-tree-method | 5f395fce105ab1c483370a376a3dbc5ff8ac7f51 | 7c3fde94bb2f25f44d8c1b1562db80fa4702042b | refs/heads/master | 2021-04-27T12:11:41.774200 | 2018-02-23T04:56:01 | 2018-02-23T04:56:01 | 122,575,153 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 446 | cpp | #include"binomial.h"
#include<iostream>
//this is a program pricing American/European option without dividend
using namespace std;
int main()
{
Binomial option;
option.Num=200;
option.time=6.0/252;
option.strike=160;
option.r=0.04;
option.sigma=0.25;
option.type='A';
option.setspace();
double p;
for(p=155;p<=160;p+=2.5)
{
option.startp=p;
option.calprice();
option.showprice();
}
return 0;
}
| [
"[email protected]"
] | |
0f39848b846759b84d8a7e614e49755eebfa747a | 0f2b08b31fab269c77d4b14240b8746a3ba17d5e | /onnxruntime/core/providers/cpu/sequence/sequence_ops.h | 9466d3f0fd108bfb33ac8d8cef253410893e613f | [
"MIT"
] | permissive | microsoft/onnxruntime | f75aa499496f4d0a07ab68ffa589d06f83b7db1d | 5e747071be882efd6b54d7a7421042e68dcd6aff | refs/heads/main | 2023-09-04T03:14:50.888927 | 2023-09-02T07:16:28 | 2023-09-02T07:16:28 | 156,939,672 | 9,912 | 2,451 | MIT | 2023-09-14T21:22:46 | 2018-11-10T02:22:53 | C++ | UTF-8 | C++ | false | false | 2,180 | h | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#pragma once
#include "core/common/common.h"
#include "core/framework/op_kernel.h"
namespace onnxruntime {
class SequenceLength final : public OpKernel {
public:
SequenceLength(const OpKernelInfo& info) : OpKernel(info) {
}
Status Compute(OpKernelContext* context) const override;
};
class SequenceAt final : public OpKernel {
public:
SequenceAt(const OpKernelInfo& info) : OpKernel(info) {
}
Status Compute(OpKernelContext* context) const override;
};
class SequenceEmpty final : public OpKernel {
public:
SequenceEmpty(const OpKernelInfo& info);
Status Compute(OpKernelContext* context) const override;
private:
int64_t dtype_{};
};
class SequenceInsert final : public OpKernel {
public:
SequenceInsert(const OpKernelInfo& info) : OpKernel(info) {
}
Status Compute(OpKernelContext* context) const override;
};
class SequenceErase final : public OpKernel {
public:
SequenceErase(const OpKernelInfo& info) : OpKernel(info) {
}
Status Compute(OpKernelContext* context) const override;
};
class SequenceConstruct final : public OpKernel {
public:
SequenceConstruct(const OpKernelInfo& info) : OpKernel(info) {
}
Status Compute(OpKernelContext* context) const override;
};
class SplitToSequence final : public OpKernel {
public:
SplitToSequence(const OpKernelInfo& info);
Status Compute(OpKernelContext* context) const override;
private:
template <typename T>
Status ComputeImpl(OpKernelContext& context, const Tensor& input, const Tensor* p_split_input) const;
Status PrepareForCompute(const TensorShape& input_shape, int64_t split_scalar, bool is_split_input_scalar,
int64_t& num_outputs, int64_t& axis, int& before_dims,
int& after_dims_including_split_axis, int& after_dims_excluding_split,
bool& is_uneven_split, int& num_remaining_splits,
std::vector<int64_t>& split_sizes) const;
int64_t axis_{};
int64_t keepdims_{1};
const int64_t DEFAULT_LENGTH_EACH_OUTPUT_ = 1;
};
} // namespace onnxruntime
| [
"[email protected]"
] | |
16fc3c728747698b84e3efc44ad05cf2628c39da | 3aba6c00a626ca7c79ead99db2cccfb9570e1abc | /src/Gate.cc | 051d20eb4fc65e0f31e520ac8b3783eae76347d9 | [] | no_license | erostamas/gate | c84afb913b5ff22a763be861b0a93b46a3b4154a | 9c68ee10030eeb2eb67b0d9f620405c6a6fa73ac | refs/heads/master | 2022-12-23T10:06:05.286945 | 2020-09-25T17:51:09 | 2020-09-25T17:51:09 | 283,486,589 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,084 | cc | #define _GLIBCXX_USE_NANOSLEEP
#include <algorithm>
#include <thread>
#include <iostream>
#include <tgmath.h>
#include <fstream>
#include <iomanip>
#include <wiringPi.h>
#include "Gate.h"
#include "Utils.h"
#include "erostamas/Logging.h"
#include "StringCommandAdapter.h"
#include "erostamas/UdpMessageReceiver.h"
Gate::Gate() {
std::unique_ptr<StringCommandAdapter> adapter(new StringCommandAdapter());
LOG_INFO << "ok 1" << std::endl;
std::unique_ptr<UdpMessageReceiver> receiver(new UdpMessageReceiver(50001));
LOG_INFO << "ok 2" << std::endl;
adapter->registerMessageReceiver(std::move(receiver));
LOG_INFO << "ok 3" << std::endl;
_commandProcessor.registerCommandAdapter(std::move(adapter));
LOG_INFO << "ok 4" << std::endl;
_commandProcessor.processCommands();
}
Gate::~Gate() {
}
void Gate::run() {
wiringPiSetup();
pinMode (25, OUTPUT);
while (true) {
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
_commandProcessor.processCommands();
}
LOG_DEBUG << "Stopping gate" << std::endl;
}
| [
"[email protected]"
] | |
add5647fe8cc1c30c1c5995cb360cfbc7b9ead08 | 36477326de3554bc91a958e0a7f832541b9a9ca7 | /examples/ros/RosTest1.cpp | f1cf773b60801d5ecaab1b457b7b22b007be44df | [
"Apache-2.0"
] | permissive | RicoPauli/eeros | 17849f0b3f67a7da92a4b164a3334e528fe85eb3 | 3cc2802253c764b16c6368ad7bdaef1e3c683367 | refs/heads/master | 2020-04-04T19:25:50.428984 | 2018-10-23T07:22:02 | 2018-10-23T07:22:02 | 156,205,299 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,846 | cpp | #include <eeros/core/Executor.hpp>
#include <eeros/control/Constant.hpp>
#include <eeros/control/TimeDomain.hpp>
#include <eeros/safety/SafetySystem.hpp>
#include <eeros/logger/Logger.hpp>
#include <eeros/logger/StreamLogWriter.hpp>
#include <eeros/control/ros/RosPublisherDoubleArray.hpp>
#include <eeros/control/ros/RosPublisherDouble.hpp>
#include <eeros/control/ros/RosSubscriberDoubleArray.hpp>
#include <eeros/control/ros/RosSubscriberDouble.hpp>
#include <ros/ros.h>
#include <signal.h>
using namespace eeros;
using namespace eeros::control;
using namespace eeros::safety;
using namespace eeros::math;
using namespace eeros::logger;
using namespace eeros::hal;
class MyControlSystem {
public:
MyControlSystem(double dt):
c1({2.4, 0, 4.443, 23.6, -11.2, 1.3, 0.003}),
c2(0.5),
vectorOut("/test1/vector"),
doubleOut("/test1/val"),
vectorIn("/rosNodeTalker/vector"),
doubleIn("/rosNodeTalker/val"),
timedomain("Main time domain", dt, true)
{
vectorOut.getIn().connect(c1.getOut());
doubleOut.getIn().connect(c2.getOut());
timedomain.addBlock(c1);
timedomain.addBlock(c2);
timedomain.addBlock(vectorOut);
timedomain.addBlock(doubleOut);
timedomain.addBlock(vectorIn);
timedomain.addBlock(doubleIn);
eeros::Executor::instance().add(timedomain);
}
virtual ~MyControlSystem() { }
typedef eeros::math::Matrix<7, 1, double> Vector7;
Constant<Vector7> c1;
Constant<> c2;
RosPublisherDoubleArray<Vector7> vectorOut;
RosPublisherDouble doubleOut;
RosSubscriberDoubleArray<Vector2> vectorIn;
RosSubscriberDouble doubleIn;
TimeDomain timedomain;
};
class MySafetyProperties : public SafetyProperties {
public:
MySafetyProperties(MyControlSystem& cs) : slOff("off") {
addLevel(slOff);
setEntryLevel(slOff);
slOff.setLevelAction([&](SafetyContext* privateContext) {
cs.c1.setValue(cs.c1.getValue() + diff);
cs.c2.setValue(cs.c2.getValue() - diff);
if ((slOff.getNofActivations() % 10) == 0) {
log.info() << cs.doubleIn.getOut().getSignal();
log.info() << cs.vectorIn.getOut().getSignal();
}
if ((slOff.getNofActivations() % 50) == 0) {
diff = -diff;
}
});
}
SafetyLevel slOff;
Logger log;
double diff = 0.1;
};
void signalHandler(int signum) {
Executor::stop();
}
int main(int argc, char **argv) {
double dt = 0.1;
StreamLogWriter w(std::cout);
Logger::setDefaultWriter(&w);
Logger log;
w.show();
log.info() << "ROS Test1 started";
rosTools::initNode("rosTest1");
log.trace() << "ROS node initialized.";
MyControlSystem controlSystem(dt);
MySafetyProperties safetyProperties(controlSystem);
eeros::safety::SafetySystem safetySystem(safetyProperties, dt);
signal(SIGINT, signalHandler);
auto &executor = Executor::instance();
executor.setMainTask(safetySystem);
executor.run();
log.info() << "ROS Test1 end";
return 0;
}
| [
"[email protected]"
] | |
479f6d59006cc390c01c73fe0a65be32453cdc72 | 363c96ce0af9ea74cf99ec0fcac88fbcdfa87fa7 | /app/src/main/cpp/Person.cpp | 88156d74e7fa609f7be634f7e38b33f1431b9cb5 | [] | no_license | monkey-jz/v8demo | ef4ff1453763bc701242ee3d60b0a61b56b48371 | b5af6ac268639b7e16a631b007bac2c3f6ac1d21 | refs/heads/master | 2020-03-19T09:04:50.214330 | 2018-06-07T01:42:55 | 2018-06-07T01:42:55 | 136,258,536 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 396 | cpp | //
// Created by JerryZhu on 2018/5/31.
//
#include "Person.h"
Person::Person(const std::string &name, int age) : name(name), age(age) {}
void Person::setName(std::string name)
{
this -> name = name;
}
std::string Person::getName()
{
return this -> name;
}
void Person::setAge(int age)
{
this ->age = age;
}
int Person::getAge()
{
return this -> age;
}
Person::~Person() {
}
| [
"[email protected]"
] | |
e7dbd92d8a8ec015980839b677f8ff0a772d5a4e | 74186f3769fc3728ebec1110aa12aef7bc3caa2a | /Matrix.h | 8ebf1ce4e012644ef925ad80c6ceeed7a8d0eb6e | [] | no_license | IsaacdmDunn/DirectX-11-Project | 4a47a872f77ba2219326735d2cb3e7787725886a | e30b8cf886e4439e05c097daa9157c099dfe8075 | refs/heads/main | 2023-01-30T22:43:17.724793 | 2020-12-17T20:08:08 | 2020-12-17T20:08:08 | 302,014,915 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,568 | h | #ifndef __MATRIX_H
#define __MATRIX_H
#include <vector> //Uses STL vector class
template <typename T> class Matrix {
private:
std::vector<std::vector<T> > mat; // vector of vectors = N cols of M rows
unsigned rows;
unsigned cols;
public:
Matrix(unsigned _rows, unsigned _cols, const T& _initial); //any size
Matrix(const Matrix<T>& rhs);
virtual ~Matrix();
// Operator overloading, for "standard" mathematical matrix operations
Matrix<T>& operator=(const Matrix<T>& rhs);
// Matrix mathematical operations
Matrix<T> operator+(const Matrix<T>& rhs);
Matrix<T>& operator+=(const Matrix<T>& rhs);
Matrix<T> operator-(const Matrix<T>& rhs);
Matrix<T>& operator-=(const Matrix<T>& rhs);
Matrix<T> operator*(const Matrix<T>& rhs);
Matrix<T>& operator*=(const Matrix<T>& rhs);
Matrix<T> transpose();
// Matrix/scalar operations
Matrix<T> operator+(const T& rhs);
Matrix<T> operator-(const T& rhs);
Matrix<T> operator*(const T& rhs);
Matrix<T> operator/(const T& rhs);
// Matrix/vector operations
std::vector<T> operator*(const std::vector<T>& rhs);
std::vector<T> diag_vec();
// Access the individual elements
T& operator()(const unsigned& row, const unsigned& col);
const T& operator()(const unsigned& row, const unsigned& col) const;
// Access the row and column sizes
unsigned get_rows() const;
unsigned get_cols() const;
};
#include "matrix.cpp" //included to allow Template to refer to implementation
#endif
| [
"[email protected]"
] | |
67fd59cb2270af848fa59d90ff62add1dd9b1ff7 | 85c52d4f6bd49d91d4bfbddcfa74f0bc8ddbfd19 | /house/.svn/text-base/House.h.svn-base | 9ccb0106f98e931e6a9235adf6256f9c69c73605 | [] | no_license | rohitgirdhar/3DWorld | 0b9f1d3a1a123bcba46ee7b7850a315c4f517818 | fdb5fc934aa70ba016ed5c6d813a392b7c3b0779 | refs/heads/master | 2020-02-26T13:54:28.760604 | 2013-09-28T13:42:35 | 2013-09-28T13:42:35 | 13,173,508 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 409 | /*
* File: Car.h
* Author: rohit
*
* Created on January 22, 2012, 1:34 AM
*/
#ifndef HOUSE_H
#define HOUSE_H
#include <GL/glut.h>
#include "../car/glm/glm.h"
class House {
public:
float posX;
float posZ;
GLMmodel *hmodel;
float scalef;
GLuint _displayListHouse;
House(char*,float, float, float);
void makeHouseDispList();
void draw();
};
#endif /* HOUSE_H */
| [
"rohit@iiith"
] | rohit@iiith |
|
5d2fd781c9c635c2dd55ed4695e5c3ae8dffed6b | b819c29719ecb14440dab9d5cbc49d9901fc2d04 | /Client/Header/CountUpC.h | 95bdb8285b5ef9718ef5594e6b90062949a05ba4 | [] | no_license | Underdog-113/3D_portfolio | d338f49d518702b191e590dc22166c9f28c08b14 | 6b877ff5272bea2e6d2a2bd53e63b6ee4728cd9c | refs/heads/develop | 2023-07-07T20:30:00.759582 | 2021-07-27T06:01:52 | 2021-07-27T06:01:52 | 371,051,333 | 0 | 1 | null | 2021-06-13T14:30:32 | 2021-05-26T13:52:07 | C++ | UTF-8 | C++ | false | false | 742 | h | #ifndef COUNTUPCOMPONENT_H
#define COUNTUPCOMPONENT_H
#include "Component.h"
class CCountUpC final : public Engine::CComponent
{
public:
explicit CCountUpC();
~CCountUpC();
SP(Engine::CComponent) MakeClone(Engine::CObject *pObject) override;
void Awake() override;
void Start(SP(Engine::CComponent) spThis) override;
void FixedUpdate(SP(Engine::CComponent) spThis) override;
void Update(SP(Engine::CComponent) spThis) override;
void LateUpdate(SP(Engine::CComponent) spThis) override;
void OnDestroy() override;
void OnEnable() override;
void OnDisable() override;
public:
static const EComponentID m_s_componentID = EComponentID::TargetPosition;
private:
GETTOR_SETTOR(_int, m_count, 0, Count);
_float m_value;
};
#endif
| [
"[email protected]"
] | |
95dc951ce14f7a3bb997ac5ec1df2b6ca8b8350b | 1ab2d85cd3063bef59836449671b16aba8b09951 | /SmartCity/Osgearth280/include/osgEarthUtil/GeodeticGraticule | c24ced4120ec3920241914bf6444a17bc5e99b5a | [] | no_license | MySgeoffrey/EarthSDK | 2588c6d45153bf26e21669fc4d3259d3ad831de2 | 5acb504a07ab8a19618d3f06b6808290397514ab | refs/heads/master | 2020-03-28T15:11:16.397916 | 2019-12-02T17:03:54 | 2019-12-02T17:03:54 | 148,564,936 | 5 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 5,893 | /* -*-c++-*- */
/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
* Copyright 2016 Pelican Mapping
* http://osgearth.org
*
* osgEarth is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
*/
#ifndef OSGEARTHUTIL_GEODETIC_GRATICLE
#define OSGEARTHUTIL_GEODETIC_GRATICLE
#include <osgEarthUtil/Common>
#include <osgEarth/MapNode>
#include <osgEarth/MapNodeObserver>
#include <osgEarthSymbology/Style>
#include <osgEarthFeatures/Feature>
#include <vector>
namespace osgEarth { namespace Util
{
using namespace osgEarth;
using namespace osgEarth::Features;
using namespace osgEarth::Symbology;
/**
* Configuration options for the geodetic graticule.
*/
class OSGEARTHUTIL_EXPORT GeodeticGraticuleOptions : public ConfigOptions
{
public:
GeodeticGraticuleOptions( const Config& conf =Config() );
/** dtor */
virtual ~GeodeticGraticuleOptions() { }
public:
struct Level
{
float _minRange, _maxRange;
unsigned _subdivisionFactor;
optional<Style> _lineStyle;
optional<Style> _textStyle;
};
/** Default style for grid lines */
optional<Style>& lineStyle() { return _defaultLineStyle; }
const optional<Style>& lineStyle() const { return _defaultLineStyle; }
/** Default style for text labels */
optional<Style>& textStyle() { return _defaultTextStyle; }
const optional<Style>& textStyle() const { return _defaultTextStyle; }
/** Subdivision levels */
const std::vector<Level>& levels() const { return _levels; }
/** Clear out all the levels */
void clearLevels();
/**
* Adds a new level of detail. You should only add levels in descending order of
* maxRange (farthest to closest).
*
* @param maxRange
* Maximum camera range for this level.
* @param minRange
* (optional) Minimum camera range for this level. Though you can set this at any level,
* it typically only makes sense to set this at the deepest level in order to
* disable the graticule when you zoom closer in.
* @param subdivisionFactor
* (optional) Number of times to subdivide each tile
* @param lineStyle
* (optional) Style to apply to the grid lines at this level
* @param textStyle
* (optional) Style to apply to text labels at this level
*/
void addLevel(
float maxRange,
float minRange =0.0f,
unsigned subdivisionFactor =2u,
const Style& lineStyle =Style(),
const Style& textStyle =Style() );
public:
Config getConfig() const;
protected:
optional<Style> _defaultLineStyle;
optional<Style> _defaultTextStyle;
std::vector<Level> _levels;
void mergeConfig( const Config& conf );
};
/**
* Implements a map graticule.
*
* NOTE: So far, this only works for geocentric maps.
* TODO: Add projected support; add text label support
*/
class OSGEARTHUTIL_EXPORT GeodeticGraticule : public osg::Group, public MapNodeObserver
{
public:
/**
* Constructs a new graticule for use with the specified map. The graticule
* is created with several default levels. If you call addLevel(), the
* default levels are deleted.
*
* @param map
* Map with which you will use this graticule
* @param options
* Optional "options" that configure the graticule. Defaults will be used
* if you don't specify this.
*/
GeodeticGraticule( MapNode* mapNode );
GeodeticGraticule( MapNode* mapNode, const GeodeticGraticuleOptions& options);
/** dtor */
virtual ~GeodeticGraticule() { }
/**
* Applies a new set of options. The graticule will be rebuilt if necessary.
*/
void setOptions( const GeodeticGraticuleOptions& options );
/**
* Gets the options with which the graticule was built.
*/
const GeodeticGraticuleOptions& getOptions() const { return _options.value(); }
public: // osg::Node
virtual void traverse(osg::NodeVisitor& nv);
public: // MapNodeObserver
virtual void setMapNode( MapNode* mapNode );
virtual MapNode* getMapNode() { return _mapNode.get(); }
private:
osg::ref_ptr<const Profile> _profile;
osg::ref_ptr<const FeatureProfile> _featureProfile;
unsigned int _id;
osg::observer_ptr<MapNode> _mapNode;
osg::Group* _root;
optional<GeodeticGraticuleOptions> _options;
private:
unsigned int getID() const { return _id; }
void init();
void rebuild();
osg::Node* buildTile( const TileKey& key, Map* map ) const;
osg::Node* buildChildren( unsigned level, unsigned x, unsigned y ) const;
friend class GeodeticGraticuleFactory;
};
} } // namespace osgEarth::Util
#endif // OSGEARTHUTIL_GEODETIC_GRATICLE
| [
"[email protected]"
] | ||
7b60b7b7485204b83786c6ea64aac8960d2f63c3 | 3a05fdc30f3966ffc87f015322d0b69191c691ca | /b68.cpp | 32b41b91b42d933e60ae6f2e2a88c43e28621c55 | [] | no_license | GibOreh/CPP | 1c9cecc1776560de4b2bdf30641ed94cb214877f | d81ca1288331f19ef316ee13c8c1589d20622e0d | refs/heads/master | 2023-06-15T00:11:41.793119 | 2021-07-11T21:04:58 | 2021-07-11T21:04:58 | 385,046,608 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 597 | cpp | #include<iostream>
#include<math.h>
using namespace std;
//bool check(long long n){
// if(n<=1){
// return false;
// } else{
// for(long long i= 2; i<= sqrt(n); i++){
// if(n%i==0){
// return false;
// }
// }
// }
// return true;
//}
int main(){
int t;
cin>>t;
while(t--){
long long n;
cin>>n;
cout<<1<<" ";
for(long long i=2; i<=n; i++){
bool ok= true;
for(long long j=2;j<=sqrt(i);j++){
if (i%j == 0) {
cout<<j<<" ";
ok= false;
break;
}
}
if(ok){
cout<<i<<" ";
}
}
cout<<endl;
}
}
| [
"[email protected]"
] | |
732fbd7523f4c8011528874131302fc4c36a7392 | 5c8a5c6f3597e29f838647367fe05c6bb13fea5e | /vendor/bundle/ruby/2.2.0/gems/passenger-5.0.23/src/agent/UstRouter/OptionParser.h | a2138055f3bdeddc7920eafa188ee5cfdccd3039 | [
"MIT"
] | permissive | prakyath/wavez-rails | dede7ea742753db11718093a231109bba24665a3 | fdf0d08990dd764e06d4444401c5b973079d809c | refs/heads/master | 2021-01-10T04:38:27.163654 | 2016-03-09T09:13:59 | 2016-03-09T09:13:59 | 49,645,824 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,634 | h | /*
* Phusion Passenger - https://www.phusionpassenger.com/
* Copyright (c) 2010-2015 Phusion Holding B.V.
*
* "Passenger", "Phusion Passenger" and "Union Station" are registered
* trademarks of Phusion Holding B.V.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef _PASSENGER_UST_ROUTER_OPTION_PARSER_H_
#define _PASSENGER_UST_ROUTER_OPTION_PARSER_H_
#include <cstdio>
#include <cstdlib>
#include <Constants.h>
#include <Utils.h>
#include <Utils/VariantMap.h>
#include <Utils/OptionParsing.h>
#include <Utils/StrIntUtils.h>
namespace Passenger {
using namespace std;
inline void
ustRouterUsage() {
printf("Usage: " AGENT_EXE " ust-router <OPTIONS...>\n");
printf("Runs the " PROGRAM_NAME " UstRouter.\n");
printf("\n");
printf("Required options:\n");
printf(" --passenger-root PATH The location to the " PROGRAM_NAME " source\n");
printf(" directory\n");
printf(" --password-file PATH Protect the UstRouter controller with the password in\n");
printf(" this file\n");
printf("\n");
printf("Socket options (optional):\n");
printf(" -l, --listen ADDRESS Listen on the given address. The address must be\n");
printf(" formatted as tcp://IP:PORT for TCP sockets, or\n");
printf(" unix:PATH for Unix domain sockets.\n");
printf(" " DEFAULT_UST_ROUTER_LISTEN_ADDRESS "\n");
printf("\n");
printf(" --api-listen ADDRESS Listen on the given address for API commands.\n");
printf(" The address must be in the same format as that\n");
printf(" of --listen\n");
printf(" --authorize [LEVEL]:USERNAME:PASSWORDFILE\n");
printf(" Enables authentication on the API server,\n");
printf(" through the given API account. LEVEL indicates\n");
printf(" the privilege level (see below). PASSWORDFILE must\n");
printf(" point to a file containing the password\n");
printf("\n");
printf("Operational options (optional):\n");
printf(" --dev-mode Enable development mode: dump data to a directory\n");
printf(" instead of sending them to the Union Station gateway\n");
printf(" --dump-dir PATH Directory to dump to\n");
printf("\n");
printf("Other options (optional):\n");
printf(" --user USERNAME Lower privilege to the given user. Only has\n");
printf(" effect when started as root\n");
printf(" --group GROUPNAME Lower privilege to the given group. Only has\n");
printf(" effect when started as root. Default: primary\n");
printf(" group of the username given by '--user'\n");
printf("\n");
printf(" --log-file PATH Log to the given file.\n");
printf(" --log-level LEVEL Logging level. Default: %d\n", DEFAULT_LOG_LEVEL);
printf("\n");
printf(" -h, --help Show this help\n");
printf("\n");
printf("API account privilege levels (ordered from most to least privileges):\n");
printf(" readonly Read-only access\n");
printf(" full Full access (default)\n");
}
inline bool
parseUstRouterOption(int argc, const char *argv[], int &i, VariantMap &options) {
OptionParser p(ustRouterUsage);
if (p.isValueFlag(argc, i, argv[i], '\0', "--passenger-root")) {
options.set("passenger_root", argv[i + 1]);
i += 2;
} else if (p.isValueFlag(argc, i, argv[i], '\0', "--password-file")) {
options.set("ust_router_password_file", argv[i + 1]);
i += 2;
} else if (p.isValueFlag(argc, i, argv[i], 'l', "--listen")) {
if (getSocketAddressType(argv[i + 1]) != SAT_UNKNOWN) {
options.set("ust_router_address", argv[i + 1]);
i += 2;
} else {
fprintf(stderr, "ERROR: invalid address format for --listen. The address "
"must be formatted as tcp://IP:PORT for TCP sockets, or unix:PATH "
"for Unix domain sockets.\n");
exit(1);
}
} else if (p.isValueFlag(argc, i, argv[i], '\0', "--api-listen")) {
if (getSocketAddressType(argv[i + 1]) != SAT_UNKNOWN) {
vector<string> addresses = options.getStrSet("ust_router_api_addresses",
false);
if (addresses.size() == SERVER_KIT_MAX_SERVER_ENDPOINTS) {
fprintf(stderr, "ERROR: you may specify up to %u --api-listen addresses.\n",
SERVER_KIT_MAX_SERVER_ENDPOINTS);
exit(1);
}
addresses.push_back(argv[i + 1]);
options.setStrSet("ust_router_api_addresses", addresses);
i += 2;
} else {
fprintf(stderr, "ERROR: invalid address format for --api-listen. The address "
"must be formatted as tcp://IP:PORT for TCP sockets, or unix:PATH "
"for Unix domain sockets.\n");
exit(1);
}
} else if (p.isValueFlag(argc, i, argv[i], '\0', "--authorize")) {
vector<string> args;
vector<string> authorizations = options.getStrSet("ust_router_authorizations",
false);
split(argv[i + 1], ':', args);
if (args.size() < 2 || args.size() > 3) {
fprintf(stderr, "ERROR: invalid format for --authorize. The syntax "
"is \"[LEVEL:]USERNAME:PASSWORDFILE\".\n");
exit(1);
}
authorizations.push_back(argv[i + 1]);
options.setStrSet("ust_router_authorizations", authorizations);
i += 2;
} else if (p.isFlag(argv[i], '\0', "--dev-mode")) {
options.setBool("ust_router_dev_mode", true);
i++;
} else if (p.isValueFlag(argc, i, argv[i], '\0', "--dump-dir")) {
options.set("ust_router_dump_dir", argv[i + 1]);
i += 2;
} else if (p.isValueFlag(argc, i, argv[i], '\0', "--user")) {
options.set("analytics_log_user", argv[i + 1]);
i += 2;
} else if (p.isValueFlag(argc, i, argv[i], '\0', "--group")) {
options.set("analytics_log_group", argv[i + 1]);
i += 2;
} else if (p.isValueFlag(argc, i, argv[i], '\0', "--log-level")) {
// We do not set log_level because, when this function is called from
// the Watchdog, we don't want to affect the Watchdog's own log level.
options.setInt("ust_router_log_level", atoi(argv[i + 1]));
i += 2;
} else if (p.isValueFlag(argc, i, argv[i], '\0', "--log-file")) {
// We do not set debug_log_file because, when this function is called from
// the Watchdog, we don't want to affect the Watchdog's own log file.
options.set("ust_router_log_file", argv[i + 1]);
i += 2;
} else {
return false;
}
return true;
}
} // namespace Passenger
#endif /* _PASSENGER_UST_ROUTER_OPTION_PARSER_H_ */
| [
"[email protected]"
] | |
c96f2c1ac99b2455cda323c1e16f002f1e516b9f | 82dc3cc4c97c05e384812cc9aa07938e2dbfe24b | /development/src/elements/craig_enhanced_strain_loc/SSEnhLocLinearT.h | ede680d60af12b919b859e5a93afcae0146e7edb | [
"BSD-3-Clause"
] | permissive | samanseifi/Tahoe | ab40da0f8d952491943924034fa73ee5ecb2fecd | 542de50ba43645f19ce4b106ac8118c4333a3f25 | refs/heads/master | 2020-04-05T20:24:36.487197 | 2017-12-02T17:09:11 | 2017-12-02T17:24:23 | 38,074,546 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,899 | h |
#ifndef _SMALL_STRAIN_ENH_LOC_LINEAR_T_H_
#define _SMALL_STRAIN_ENH_LOC_LINEAR_T_H_
/* base class */
#include "SmallStrainT.h"
#include "SolidElementT.h"
#include "LinearBandT.h"
#include "HookeanMatT.h"
#include "MapT.h"
#include "ofstreamT.h"
namespace Tahoe {
/* forward declarations */
class SSMatSupportT;
/** Interface for linear strain deformation and field gradients */
class SSEnhLocLinearT: public SmallStrainT //, public HookeanMatT
{
public:
friend class LinearBandT;
/** constructor */
SSEnhLocLinearT(const ElementSupportT& support);
/** destructor */
//~SSEnhLocLinearT(void);
enum BVPTypeT {kNonhomogeneous = 0,
kHomogeneous,
kPreFailed,
kNumBVPTypes};
/** \name total strain */
/*@{*/
// const dSymMatrixT& LinearStrain(void) const;
// const dSymMatrixT& LinearStrain(int ip) const;
/*@}*/
/** total strain from the end of the previous time step */
/*@{*/
// const dSymMatrixT& LinearStrain_last(void) const;
// const dSymMatrixT& LinearStrain_last(int ip) const;
/*@}*/
/** \name implementation of the ParameterInterfaceT interface */
/** describe the parameters needed by the interface */
virtual void DefineParameters(ParameterListT& list) const;
/** information about subordinate parameter lists */
virtual void DefineSubs(SubListT& sub_list) const;
/** accept parameter list */
virtual void TakeParameterList(const ParameterListT& list);
/*@}*/
protected:
int fFirstElementToLocalize; // -1 if loading is nonhomogeneous, element number otherwise
virtual MaterialSupportT* NewMaterialSupport(MaterialSupportT* p = NULL) const;
/** return a pointer to a new material list. Recipient is
* responsible for freeing the pointer.
* \param name list identifier \param size length of the list */
virtual MaterialListT* NewMaterialList(const StringT& name, int size);
/** calculate the internal force contribution ("-k*d") */
virtual void FormKd(double constK);
/** form the element stiffness matrix */
virtual void FormStiffness(double constK);
/** form shape functions and derivatives */
virtual void SetGlobalShape(void);
virtual bool LocalizationHasBegun(void) {return
fLocalizationHasBegun;};
virtual void PreFailElements();
private:
/** compute mean shape function gradient, Hughes (4.5.23) */
//void SetMeanGradient(dArray2DT& mean_gradient) const;
MapT<int, LinearBandT*> fTracedElements;
/*elements with one edge on band of traced elements
* with that coordinate of the end of band*/
iAutoArrayT fEdgeOfBandElements;
AutoArrayT<dArrayT> fEdgeOfBandCoords;
static bool fLocalizationHasBegun;
static bool fSeedElementsSet;
static double fDetAMin;
static int fLeastDetEle;
ofstreamT jump_out;
protected:
//BVPTypeT fBVPType;
int fBVPType;
dArrayT fPreFailedNormal;
dArrayT fPreFailedSlipDir;
LinearBandT *fBand;
double fH_delta_0;
bool fMultiBand;
bool fNoBandDilation;
double fLocalizedFrictionCoeff;
MapT<int, LinearBandT*>* TracedElements()
{return &fTracedElements;}
/** driver for calculating output values */
/* Used to check localization - is there a more appropriate fn? */
virtual void ComputeOutput(const iArrayT& n_codes, dArray2DT& n_values,
const iArrayT& e_codes, dArray2DT& e_values);
#if 0
virtual void GenerateOutputLabels(const iArrayT& n_codes, ArrayT<StringT>& n_labels,
const iArrayT& e_codes, ArrayT<StringT>& e_labels) const;
virtual void SetNodalOutputCodes(IOBaseT::OutputModeT mode, const iArrayT& flags,
iArrayT& counts) const;
#endif
public:
virtual void CloseStep(void);
protected:
virtual void GetElement(int elementNumber);
virtual double CalculateJumpIncrement(int bandIP);
virtual bool IsBandActive(dArrayT workingTraction, int bandIP);
virtual void LoadBand(int elementNumber);
virtual LinearBandT* FormNewBand(dArrayT normal, dArrayT slipDir,
dArrayT perpSlipDir, dArrayT coords, double area);
virtual void AddNewEdgeElements(int elementNumber);
virtual dArrayT InterceptCoords(dArrayT& localizedEleCoord, dArrayT& nodalCoord1, dArrayT& nodalCoord2);
//move to surface mat model?
dSymMatrixT FormdGdSigma(int ndof);
dSymMatrixT FormGradActiveTensorFlowDir(int ndof, int ip);
dSymMatrixT FormGradActiveTensorFlowDirAtBandIP(int ndof, int bandIP);
bool IsElementTraced();
bool IsElementTraced(int elementNumber);
bool IsElementLocalized();
bool TraceElement();
virtual void ChooseNormals(AutoArrayT <dArrayT> &normals, AutoArrayT <dArrayT> &slipDirs);
dArrayT Centroid();
virtual dSymMatrixT ConformingStrainAtCoord(dArrayT coord);
virtual dSymMatrixT ConformingStrainIncrAtCoord(dArrayT coord);
virtual double F_hAtBulkIP(int ip);
virtual dMatrixT B_at_surfaceIP(int bandIP);
virtual double JumpIncrAtBulkIP(int ip);
virtual double QuadContraction(dMatrixT c_ijkl,
dArrayT vector1, dArrayT vector2, dArrayT vector3, dArrayT vector4);
};
/* These are conforming strains. Change to regular strains? */
/* inlines */
#if 0
inline const dSymMatrixT& SSEnhLocLinearT::LinearStrain(void) const
{
#if 0
//__option(extended_errorcheck)
/* check need */
int mat_num = CurrentElement().MaterialNumber();
const ArrayT<bool>& needs = fMaterialNeeds[mat_num];
if (!needs[fNeedsOffset + kstrain])
ExceptionT::GeneralFail("SSEnhLocLinearT::LinearStrain",
"material %d did not specify this need",
mat_num + 1);
#endif
return fStrain_List[CurrIP()];
}
inline const dSymMatrixT& SSEnhLocLinearT::LinearStrain(int ip) const
{
#if 0
//__option(extended_errorcheck)
/* check need */
int mat_num = CurrentElement().MaterialNumber();
const ArrayT<bool>& needs = fMaterialNeeds[mat_num];
if (!needs[fNeedsOffset + kstrain])
ExceptionT::GeneralFail("SSEnhLocLinearT::LinearStrain",
"material %d did not specify this need",
mat_num + 1);
#endif
return fStrain_List[ip];
}
inline const dSymMatrixT& SSEnhLocLinearT::LinearStrain_last(void) const
{
#if 0
//__option(extended_errorcheck)
/* check need */
int mat_num = CurrentElement().MaterialNumber();
const ArrayT<bool>& needs = fMaterialNeeds[mat_num];
if (!needs[fNeedsOffset + kstrain_last])
ExceptionT::GeneralFail("SSEnhLocLinearT::LinearStrain_last",
"material %d did not specify this need",
mat_num + 1);
#endif
return fStrain_last_List[CurrIP()];
}
inline const dSymMatrixT& SSEnhLocLinearT::LinearStrain_last(int ip) const
{
#if 0
//__option(extended_errorcheck)
/* check need */
int mat_num = CurrentElement().MaterialNumber();
const ArrayT<bool>& needs = fMaterialNeeds[mat_num];
if (!needs[fNeedsOffset + kstrain_last])
ExceptionT::GeneralFail("SSEnhLocLinearT::LinearStrain_last",
"material %d did not specify this need",
mat_num + 1);
#endif
return fStrain_last_List[ip];
}
#endif
} // namespace Tahoe
#endif /* _SMALLSTRAIN_ENHLOC_LINEAR_T_H_ */
| [
"saman@bu.(none)"
] | saman@bu.(none) |
fbd688060b3153f6e7582c4c5560c3605b60a0f1 | baf0fb063b0460de68e1ddc8a81598c7c8b1369b | /libnd4j/include/ops/declarable/platform/mkldnn/maxpooling2d_bp.cpp | 686bdc7fb694c19f7f6c6437f5dd66a63ad6563c | [
"Apache-2.0",
"MIT",
"BSD-3-Clause"
] | permissive | jacektracz/deeplearning4j | 108008459a7b1535de640075cacba84d3731f659 | 7a203241058451098c7d0c631fa2689f27b6fb58 | refs/heads/master | 2020-12-27T12:07:14.708284 | 2020-01-28T04:44:27 | 2020-01-28T04:44:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,477 | cpp | /*******************************************************************************
* Copyright (c) 2015-2018 Skymind, Inc.
*
* This program and the accompanying materials are made available under the
* terms of the Apache License, Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0.
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
* SPDX-License-Identifier: Apache-2.0
******************************************************************************/
//
// @author saudet
// @author [email protected]
//
#include <ops/declarable/PlatformHelper.h>
#include <ops/declarable/OpRegistrator.h>
#include <platform_boilerplate.h>
#include <helpers/MKLDNNStream.h>
#include "mkldnnUtils.h"
#include <ops/declarable/helpers/convolutions.h>
using namespace dnnl;
namespace nd4j {
namespace ops {
namespace platforms {
PLATFORM_IMPL(maxpool2d_bp, ENGINE_CPU) {
auto input = INPUT_VARIABLE(
0); // [bS, iH, iW, iC] (NHWC) or [bS, iC, iH, iW] (NCHW)
auto gradO = INPUT_VARIABLE(
1); // [bS, oH, oW, oC] (NHWC) or [bS, oC, oH, oW] (NCHW), epsilon_next
auto gradI = OUTPUT_VARIABLE(
0); // [bS, iH, iW, iC] (NHWC) or [bS, iC, iH, iW] (NCHW), epsilon
int kH = INT_ARG(0); // filter(kernel) height
int kW = INT_ARG(1); // filter(kernel) width
int sH = INT_ARG(2); // strides height
int sW = INT_ARG(3); // strides width
int pH = INT_ARG(4); // paddings height
int pW = INT_ARG(5); // paddings width
int dH = INT_ARG(6); // dilations height
int dW = INT_ARG(7); // dilations width
int isSameMode = INT_ARG(8); // 0-VALID, 1-SAME
int extraParam0 = INT_ARG(9);
int isNCHW =
block.getIArguments()->size() > 10 ? !INT_ARG(10) : 1; // INT_ARG(10): 0-NCHW, 1-NHWC
REQUIRE_TRUE(input->rankOf() == 4, 0,
"AVGPOOL2D_BP op: input should have rank of 4, but got %i instead", input->rankOf());
REQUIRE_TRUE(dH != 0 && dW != 0, 0,
"AVGPOOL2D_BP op: dilation must not be zero, but got instead {%i, %i}", dH, dW);
int bS, iC, iH, iW, oC, oH, oW; // batch size, input channels, input height/width, output channels, output height/width;
int indIOioC, indIiH, indWoC, indWiC, indWkH, indOoH; // corresponding indexes
ConvolutionUtils::getSizesAndIndexesConv2d(isNCHW, *input, *gradO, bS, iC, iH, iW, oC, oH, oW, indIOioC,
indIiH, indWiC, indWoC, indWkH, indOoH);
std::string expectedGradOShape = ShapeUtils::shapeAsString(
ShapeUtils::composeShapeUsingDimsAndIdx({bS, iC, oH, oW, 0, indIOioC, indIiH, indIiH + 1}));
std::string expectedGradIShape = ShapeUtils::shapeAsString(
ShapeUtils::composeShapeUsingDimsAndIdx({bS, iC, iH, iW, 0, indIOioC, indIiH, indIiH + 1}));
REQUIRE_TRUE(expectedGradOShape == ShapeUtils::shapeAsString(gradO), 0,
"AVGPOOL2D_BP op: wrong shape of output's gradients array (next epsilon), expected is %s, but got %s instead !",
expectedGradOShape.c_str(), ShapeUtils::shapeAsString(gradO).c_str());
REQUIRE_TRUE(expectedGradIShape == ShapeUtils::shapeAsString(gradI), 0,
"AVGPOOL2D_BP op: wrong shape of input's gradients array (epsilon), expected is %s, but got %s instead !",
expectedGradIShape.c_str(), ShapeUtils::shapeAsString(gradI).c_str());
if (!isNCHW) {
input = new NDArray(input->permute(
{0, 3, 1, 2})); // [bS, iH, iW, iC] -> [bS, iC, iH, iW]
gradI = new NDArray(gradI->permute(
{0, 3, 1, 2})); // [bS, iH, iW, iC] -> [bS, iC, iH, iW]
gradO = new NDArray(gradO->permute(
{0, 3, 1, 2})); // [bS, oH, oW, iC] -> [bS, iC, oH, oW]
}
if (isSameMode) // SAME
ConvolutionUtils::calcPadding2D(pH, pW, oH, oW, iH, iW, kH, kW, sH, sW, dH, dW);
auto poolingMode = PoolingType::MAX_POOL;
dnnl_memory_desc_t empty;
dnnl::memory::desc pool_src_md(empty), pool_diff_src_md(empty), pool_dst_md(empty);
dnnl::memory::desc user_src_md(empty), user_diff_src_md(empty), user_dst_md(empty);
dnnl::memory::dims pool_strides, pool_kernel, pool_padding, pool_padding_r;
dnnl::algorithm algorithm;
mkldnnUtils::getMKLDNNMemoryDescPool2d(kH, kW, sH, sW, pH, pW, dH, dW, poolingMode, extraParam0,
true,
bS, iC, iH, iW, oC, oH, oW, input, gradI, gradO, algorithm,
&pool_src_md, &pool_diff_src_md, &pool_dst_md, &user_src_md,
&user_diff_src_md, &user_dst_md,
pool_strides, pool_kernel, pool_padding, pool_padding_r);
// input is sometimes null, so we can't rely on pool_src_md being valid
auto pool_desc = pooling_forward::desc(prop_kind::forward, algorithm,
input->buffer() != nullptr ? pool_src_md : pool_diff_src_md,
pool_dst_md, pool_strides, pool_kernel, pool_padding,
pool_padding_r);
auto engine = mkldnnUtils::getEngine(LaunchContext::defaultContext()->engine());
dnnl::stream stream(engine);
auto pool_prim_desc = pooling_forward::primitive_desc(pool_desc, engine);
auto poolB_desc = pooling_backward::desc(algorithm, pool_diff_src_md, pool_dst_md,
pool_strides, pool_kernel, pool_padding, pool_padding_r);
auto poolB_prim_desc = pooling_backward::primitive_desc(poolB_desc, engine, pool_prim_desc);
auto userB_src_memory = dnnl::memory(user_src_md, engine, gradI->buffer());
auto userB_dst_memory = dnnl::memory(user_dst_md, engine, gradO->buffer());
auto poolB_src_memory = userB_src_memory;
if (poolB_prim_desc.diff_src_desc() != userB_src_memory.get_desc()) {
poolB_src_memory = dnnl::memory(poolB_prim_desc.diff_src_desc(), engine);
}
auto poolB_dst_memory = userB_dst_memory;
if (poolB_prim_desc.diff_dst_desc() != userB_dst_memory.get_desc()) {
poolB_dst_memory = dnnl::memory(poolB_prim_desc.diff_dst_desc(), engine);
reorder(userB_dst_memory, poolB_dst_memory).execute(stream, userB_dst_memory, poolB_dst_memory);
}
auto user_src_memory = dnnl::memory(user_src_md, engine, input->buffer());
auto pool_src_memory = user_src_memory;
if (pool_prim_desc.src_desc() != user_src_memory.get_desc()) {
pool_src_memory = dnnl::memory(pool_prim_desc.src_desc(), engine);
reorder(user_src_memory, pool_src_memory).execute(stream, user_src_memory, pool_src_memory);
}
auto pool_dst_memory = dnnl::memory(pool_prim_desc.dst_desc(), engine);
auto pool_workspace_memory = dnnl::memory(pool_prim_desc.workspace_desc(), engine);
pooling_forward(pool_prim_desc).execute(stream, {{DNNL_ARG_SRC, pool_src_memory},
{DNNL_ARG_DST, pool_dst_memory},
{DNNL_ARG_WORKSPACE, pool_workspace_memory}});
// probably wrong, fix that
pooling_backward(poolB_prim_desc).execute(stream, {{DNNL_ARG_DIFF_DST, poolB_dst_memory},
{DNNL_ARG_WORKSPACE, pool_workspace_memory},
{DNNL_ARG_DIFF_SRC, poolB_src_memory}});
if (poolB_prim_desc.diff_src_desc() != userB_src_memory.get_desc()) {
reorder(poolB_src_memory, userB_src_memory).execute(stream, poolB_src_memory, userB_src_memory);
}
stream.wait();
if (!isNCHW) {
delete input;
delete gradI;
delete gradO;
}
return Status::OK();
}
PLATFORM_CHECK(maxpool2d_bp, ENGINE_CPU) {
auto input = INPUT_VARIABLE(0);
auto output = OUTPUT_VARIABLE(0);
return block.isUseMKLDNN() && nd4j::MKLDNNStream::isSupported({input, output});
}
}
}
} | [
"[email protected]"
] | |
0d50c002e7fb9f0995b25db6b3c8e124fc36fcec | 511a1bbd0b4dd7a0faadd4f7cf85594e1483eb58 | /ReadWritLockTest/UTILITY/include/SmartPtr.h | c7a3e1ffb13ccb7f4b6f6f63f909d3d521814f3a | [] | no_license | bestustc/LINUX-WriteReadLock | 566a774f55d16471c0723025f06df9ffae2f2745 | 06ef8e2fddd9d78355f7769a5d6f4a943ff000fa | refs/heads/master | 2021-01-16T21:43:50.725949 | 2014-06-10T07:10:47 | 2014-06-10T07:10:47 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 5,848 | h | #pragma once
/****************************************************************************
** 1. 不接受局部变量或者全局变量等固定分配内存方式
** 2. 不接受数组
** 3. new/malloc出来的内存，智能指针会隐式释放，不能显示释放
** 4. new/malloc出来的内存，一旦分配给一个智能指针的时候，就不能再赋值给第二个智能指针，如果需要进行类似操作，请用智能指针操作
** by Wang Zhaoyang
****************************************************************************/
#include <iostream>
#include "Mutex.h"
#include <string>
using namespace std;
template <typename T>
class SmartPtr
{
private:
int *m_count; // m_ptr引用的次数
T *m_ptr;
int *m_ptrIsDelete; //TRUE:删除 FALSE:未删除
CMUTEX *m_pMutex;
CMUTEX m_mutex;
void InitPtr()
{
m_count = NULL;
m_ptr = NULL;
m_pMutex = NULL;
m_ptrIsDelete = NULL;
}
void DestroyPtr()
{
delete m_count;
delete m_ptr;
delete m_pMutex;
delete m_ptrIsDelete;
}
void Init(T* ths)
{
m_count = new int;
*m_count = 1;
m_pMutex = new CMUTEX;
m_ptr = ths;
m_ptrIsDelete = new int;
*m_ptrIsDelete = FALSE;
}
/************************************************************************/
/* 指针赋值 */
/************************************************************************/
void Add(SmartPtr& ths)
{
if (ths.m_pMutex == NULL)
return;
// ths本身有引用计数在，不需要判断指针是否为空，如果为空，表示逻辑出问题
AutoLock locker(ths.m_pMutex);
// 如果赋值的指针已经调用过delete，则被赋值的指针清空
if (*(ths.m_ptrIsDelete) == TRUE)
{
InitPtr();
return;
}
++*ths.m_count;
m_count = ths.m_count;
m_ptr = ths.m_ptr;
m_pMutex = ths.m_pMutex;
m_ptrIsDelete = ths.m_ptrIsDelete;
}
/************************************************************************/
/* 删除指针，不阻塞 */
/************************************************************************/
void DeleteForNotBlock()
{
if (m_pMutex == NULL)
return;
m_pMutex->Lock();
--*m_count;
// 当引用计算为0的时候，表示m_ptr只在该智能指针中已经完成
// 调用该指针的时候，在指针需要已经锁住了
if (*m_count == 0)
{
m_pMutex->UnLock();
DestroyPtr();
InitPtr();
return;
}
m_pMutex->UnLock();
InitPtr();
}
public:
SmartPtr()
{
AutoLock locker(&m_mutex);
InitPtr();
}
SmartPtr(SmartPtr<T> &ths)
{
AutoLock locker(&m_mutex);
AutoLock locker1(&ths.m_mutex);
InitPtr();
Add(ths);
}
SmartPtr(const SmartPtr<T> &ths)
{
AutoLock locker(&m_mutex);
AutoLock locker1((CMUTEX *)&ths.m_mutex);
InitPtr();
Add(const_cast<SmartPtr&>(ths));
}
SmartPtr(T *t)
{
AutoLock locker(&m_mutex);
Init(t);
}
~SmartPtr()
{
AutoLock locker(&m_mutex);
DeleteForNotBlock();
}
void Delete()
{
AutoLock locker(&m_mutex);
if (m_pMutex == NULL)
return;
m_pMutex->Lock();
*m_ptrIsDelete = TRUE;
m_pMutex->UnLock();
}
BOOL IsDelete()
{
AutoLock locker(&m_mutex);
if (m_pMutex == NULL)
return TRUE;
AutoLock locker1(m_pMutex);
if ((m_ptrIsDelete == NULL) || (*m_ptrIsDelete == TRUE))
return TRUE;
else
return FALSE;
}
/************************************************************************/
/* 比较运算符号重载 */
/************************************************************************/
/*bool operator==(int v)
{
AutoLock locker(m_pMutex);
return m_ptr == v;
}
bool operator==(SmartPtr &ths)
{
AutoLock locker1(m_pMutex);
AutoLock locker2(ths.m_pMutex);
return m_ptr == ths.m_ptr;
}*/
/************************************************************************/
/* 赋值运算符号重载 */
/************************************************************************/
SmartPtr& operator=(SmartPtr& ths)
{
if (this == &ths)
return *this;
// 需要放在上一个判断语句之后，否则可能会造成死锁
AutoLock locker(&m_mutex);
AutoLock locker1(&ths.m_mutex);
DeleteForNotBlock();
Add(ths);
return *this;
}
// 尽量不要使用该函数，以免造成逻辑错误
/*SmartPtr& operator=(T *ths)
{
DeleteForNotBlock();
Init(ths);
return *this;
}*/
/************************************************************************/
/* 指针运算符号重载 */
/************************************************************************/
T *operator->()
{
AutoLock locker1(&m_mutex);
if (m_pMutex == NULL)
return NULL;
AutoLock locker(m_pMutex);
return m_ptr;
}
T &operator*()
{
AutoLock locker1(&m_mutex);
if (m_pMutex == NULL)
return *m_ptr;
AutoLock locker(m_pMutex);
return *m_ptr;
}
/************************************************************************/
/* 输入输出重载 */
/************************************************************************/
friend ostream& operator << (ostream &ot, SmartPtr &ths)
{
ot << *ths.m_ptr;
return ot;
}
friend istream& operator >> (istream &it, SmartPtr &ths)
{
it >> *ths->m_ptr;
return it;
}
};
| [
"[email protected]"
] | |
2fbcf8ab3fb52e050a884d6f8713a149614914ed | 0ae7fb33fe5fc4d584303a75f397503a559bea0c | /C Plus Plus/sorts/sorts/main.cpp | 0356ae05c02ca7a96048e2830736fc08d6918818 | [] | no_license | MohanLi/Demo | 071704359e9757300b33dce8fc34f4ab9ae90a82 | 9f2f5032ed92749ce1bc8f490ade8a12986e5c47 | refs/heads/master | 2020-04-06T07:05:17.500809 | 2016-06-19T23:20:48 | 2016-06-19T23:20:48 | 40,398,895 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 422 | cpp | #include <iostream>
#include "Sort.h"
using namespace std;
void test()
{
int array[10] = {15, 12, 0, 45, 78, 3, 44, 99, 65, 20};
/*
for (int i = 0; i < 10; i++)
{
array[i] = rand() % 1000;
}*/
Sort *sort = new Sort;
sort->insertSort(array, sizeof(array)/sizeof(*array));
for (auto data : array)
{
cout << data << " ";
}
}
int main()
{
test();
system("pause");
return 0;
} | [
"[email protected]"
] | |
04440490f7f714b6ee00eebcbe78ac77acc1a716 | a6a19c37ae2f6afa06b4fd2056e2671879538d77 | /Jerk Minimization/main.cpp | f949d4bd383f1a36840a68d1f84aebf85227585f | [] | no_license | rmiucic/udacity_sandbox | 1705eae43abbfc5b014b949f5740cfb7dd79da71 | 92762acd0ec53e9483cdddbfc2103a7d11b999ae | refs/heads/master | 2020-04-11T00:54:19.929906 | 2019-03-05T18:41:40 | 2019-03-05T18:41:40 | 161,399,773 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,039 | cpp | #include <cmath>
#include <iostream>
#include <vector>
#include "Dense"
#include "grader.h"
using std::vector;
using Eigen::MatrixXd;
using Eigen::VectorXd;
using std::pow;
/**
* TODO: complete this function
*/
vector<double> JMT(vector<double> &start, vector<double> &end, double T) {
/**
* Calculate the Jerk Minimizing Trajectory that connects the initial state
* to the final state in time T.
*
* @param start - the vehicles start location given as a length three array
* corresponding to initial values of [s, s_dot, s_double_dot]
* @param end - the desired end state for vehicle. Like "start" this is a
* length three array.
* @param T - The duration, in seconds, over which this maneuver should occur.
*
* @output an array of length 6, each value corresponding to a coefficent in
* the polynomial:
* s(t) = a_0 + a_1 * t + a_2 * t**2 + a_3 * t**3 + a_4 * t**4 + a_5 * t**5
*
* EXAMPLE
* > JMT([0, 10, 0], [10, 10, 0], 1)
* [0.0, 10.0, 0.0, 0.0, 0.0, 0.0]
*/
MatrixXd M = MatrixXd(3, 3);
M << T*T*T, T*T*T*T, T*T*T*T*T,
3*T*T, 4*T*T*T, 5*T*T*T*T,
6*T, 12*T*T, 20*T*T*T;
MatrixXd S = MatrixXd(3,1);
S << end[0] - (start[0] + start[1] * T + 0.5 * start[2] * T*T),
end[1] - (start[1] + start[2] * T),
end[2] - start[2];
MatrixXd Mi = M.inverse();
MatrixXd A345 = Mi*S;
vector <double> result = {start[0], start[1], .5*start[2]};
for(int i = 0; i < A345.size(); ++i)
{
result.push_back(A345.data()[i]);
}
return result;
}
int main() {
// create test cases
vector< test_case > tc = create_tests();
bool total_correct = true;
for(int i = 0; i < tc.size(); ++i) {
vector<double> jmt = JMT(tc[i].start, tc[i].end, tc[i].T);
bool correct = close_enough(jmt, answers[i]);
total_correct &= correct;
}
if(!total_correct) {
std::cout << "Try again!" << std::endl;
} else {
std::cout << "Nice work!" << std::endl;
}
return 0;
} | [
"[email protected]"
] | |
38b68171282128d57c6b765a5d47738893a22892 | 2914bf293930a228b1ca550c4cf128a19f1dcf27 | /26_Login_with_SQLite/26_12_Load_Data_after_Login/build-26_12_Load_Data_after_Login-Desktop-Debug/ui_employeeinfo.h | 3d142886540e05ee76f4462570a7506fd835c57d | [] | no_license | wildenali/Belajar-GUI-dengan-QtCreator | b8ba61579ceaf6a85ed7fc21479fbf477b75d8f3 | 3a1485c5c39767d177170170110d87f6aceb7d8b | refs/heads/master | 2020-04-16T20:21:00.338469 | 2019-01-28T14:11:10 | 2019-01-28T14:11:10 | 165,895,983 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,331 | h | /********************************************************************************
** Form generated from reading UI file 'employeeinfo.ui'
**
** Created by: Qt User Interface Compiler version 5.5.1
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/
#ifndef UI_EMPLOYEEINFO_H
#define UI_EMPLOYEEINFO_H
#include <QtCore/QVariant>
#include <QtWidgets/QAction>
#include <QtWidgets/QApplication>
#include <QtWidgets/QButtonGroup>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QDialog>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QLabel>
#include <QtWidgets/QLineEdit>
#include <QtWidgets/QListView>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QTableView>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>
QT_BEGIN_NAMESPACE
class Ui_EmployeeInfo
{
public:
QWidget *layoutWidget;
QVBoxLayout *verticalLayout_2;
QHBoxLayout *horizontalLayout_5;
QPushButton *pushButton_Save;
QPushButton *pushButton_Update;
QPushButton *pushButton_Delete;
QLabel *label_2;
QLabel *label_sec_status;
QWidget *layoutWidget_2;
QVBoxLayout *verticalLayout;
QHBoxLayout *horizontalLayout;
QLabel *label_EID;
QLineEdit *txt_EID;
QHBoxLayout *horizontalLayout_2;
QLabel *label_Surename;
QLineEdit *txt_Surename;
QHBoxLayout *horizontalLayout_3;
QLabel *label_Name;
QLineEdit *txt_Name;
QHBoxLayout *horizontalLayout_4;
QLabel *label_Age;
QLineEdit *txt_Age;
QLabel *label;
QLabel *label_3;
QListView *listView;
QTableView *tableView;
QComboBox *comboBox;
QPushButton *pushButton_Load;
void setupUi(QDialog *EmployeeInfo)
{
if (EmployeeInfo->objectName().isEmpty())
EmployeeInfo->setObjectName(QStringLiteral("EmployeeInfo"));
EmployeeInfo->resize(937, 394);
layoutWidget = new QWidget(EmployeeInfo);
layoutWidget->setObjectName(QStringLiteral("layoutWidget"));
layoutWidget->setGeometry(QRect(9, 151, 180, 97));
verticalLayout_2 = new QVBoxLayout(layoutWidget);
verticalLayout_2->setObjectName(QStringLiteral("verticalLayout_2"));
verticalLayout_2->setContentsMargins(0, 0, 0, 0);
horizontalLayout_5 = new QHBoxLayout();
horizontalLayout_5->setObjectName(QStringLiteral("horizontalLayout_5"));
pushButton_Save = new QPushButton(layoutWidget);
pushButton_Save->setObjectName(QStringLiteral("pushButton_Save"));
horizontalLayout_5->addWidget(pushButton_Save);
pushButton_Update = new QPushButton(layoutWidget);
pushButton_Update->setObjectName(QStringLiteral("pushButton_Update"));
horizontalLayout_5->addWidget(pushButton_Update);
verticalLayout_2->addLayout(horizontalLayout_5);
pushButton_Delete = new QPushButton(layoutWidget);
pushButton_Delete->setObjectName(QStringLiteral("pushButton_Delete"));
verticalLayout_2->addWidget(pushButton_Delete);
label_2 = new QLabel(EmployeeInfo);
label_2->setObjectName(QStringLiteral("label_2"));
label_2->setGeometry(QRect(540, 10, 81, 17));
label_sec_status = new QLabel(EmployeeInfo);
label_sec_status->setObjectName(QStringLiteral("label_sec_status"));
label_sec_status->setGeometry(QRect(20, 350, 601, 17));
layoutWidget_2 = new QWidget(EmployeeInfo);
layoutWidget_2->setObjectName(QStringLiteral("layoutWidget_2"));
layoutWidget_2->setGeometry(QRect(9, 9, 225, 136));
verticalLayout = new QVBoxLayout(layoutWidget_2);
verticalLayout->setObjectName(QStringLiteral("verticalLayout"));
verticalLayout->setContentsMargins(0, 0, 0, 0);
horizontalLayout = new QHBoxLayout();
horizontalLayout->setObjectName(QStringLiteral("horizontalLayout"));
label_EID = new QLabel(layoutWidget_2);
label_EID->setObjectName(QStringLiteral("label_EID"));
horizontalLayout->addWidget(label_EID);
txt_EID = new QLineEdit(layoutWidget_2);
txt_EID->setObjectName(QStringLiteral("txt_EID"));
horizontalLayout->addWidget(txt_EID);
verticalLayout->addLayout(horizontalLayout);
horizontalLayout_2 = new QHBoxLayout();
horizontalLayout_2->setObjectName(QStringLiteral("horizontalLayout_2"));
label_Surename = new QLabel(layoutWidget_2);
label_Surename->setObjectName(QStringLiteral("label_Surename"));
horizontalLayout_2->addWidget(label_Surename);
txt_Surename = new QLineEdit(layoutWidget_2);
txt_Surename->setObjectName(QStringLiteral("txt_Surename"));
horizontalLayout_2->addWidget(txt_Surename);
verticalLayout->addLayout(horizontalLayout_2);
horizontalLayout_3 = new QHBoxLayout();
horizontalLayout_3->setObjectName(QStringLiteral("horizontalLayout_3"));
label_Name = new QLabel(layoutWidget_2);
label_Name->setObjectName(QStringLiteral("label_Name"));
horizontalLayout_3->addWidget(label_Name);
txt_Name = new QLineEdit(layoutWidget_2);
txt_Name->setObjectName(QStringLiteral("txt_Name"));
horizontalLayout_3->addWidget(txt_Name);
verticalLayout->addLayout(horizontalLayout_3);
horizontalLayout_4 = new QHBoxLayout();
horizontalLayout_4->setObjectName(QStringLiteral("horizontalLayout_4"));
label_Age = new QLabel(layoutWidget_2);
label_Age->setObjectName(QStringLiteral("label_Age"));
horizontalLayout_4->addWidget(label_Age);
txt_Age = new QLineEdit(layoutWidget_2);
txt_Age->setObjectName(QStringLiteral("txt_Age"));
horizontalLayout_4->addWidget(txt_Age);
verticalLayout->addLayout(horizontalLayout_4);
label = new QLabel(EmployeeInfo);
label->setObjectName(QStringLiteral("label"));
label->setGeometry(QRect(400, 10, 67, 17));
label_3 = new QLabel(EmployeeInfo);
label_3->setObjectName(QStringLiteral("label_3"));
label_3->setGeometry(QRect(260, 10, 81, 17));
listView = new QListView(EmployeeInfo);
listView->setObjectName(QStringLiteral("listView"));
listView->setGeometry(QRect(370, 30, 131, 221));
tableView = new QTableView(EmployeeInfo);
tableView->setObjectName(QStringLiteral("tableView"));
tableView->setGeometry(QRect(520, 30, 371, 221));
comboBox = new QComboBox(EmployeeInfo);
comboBox->setObjectName(QStringLiteral("comboBox"));
comboBox->setGeometry(QRect(240, 30, 121, 27));
pushButton_Load = new QPushButton(EmployeeInfo);
pushButton_Load->setObjectName(QStringLiteral("pushButton_Load"));
pushButton_Load->setGeometry(QRect(260, 270, 571, 27));
retranslateUi(EmployeeInfo);
QMetaObject::connectSlotsByName(EmployeeInfo);
} // setupUi
void retranslateUi(QDialog *EmployeeInfo)
{
EmployeeInfo->setWindowTitle(QApplication::translate("EmployeeInfo", "Dialog", 0));
pushButton_Save->setText(QApplication::translate("EmployeeInfo", "Save", 0));
pushButton_Update->setText(QApplication::translate("EmployeeInfo", "Update", 0));
pushButton_Delete->setText(QApplication::translate("EmployeeInfo", "Hapuuus", 0));
label_2->setText(QApplication::translate("EmployeeInfo", "TableView", 0));
label_sec_status->setText(QApplication::translate("EmployeeInfo", "...", 0));
label_EID->setText(QApplication::translate("EmployeeInfo", "EID", 0));
label_Surename->setText(QApplication::translate("EmployeeInfo", "Surename", 0));
label_Name->setText(QApplication::translate("EmployeeInfo", "Name", 0));
label_Age->setText(QApplication::translate("EmployeeInfo", "Age", 0));
label->setText(QApplication::translate("EmployeeInfo", "ListView", 0));
label_3->setText(QApplication::translate("EmployeeInfo", "ComboBox", 0));
pushButton_Load->setText(QApplication::translate("EmployeeInfo", "Loaaad List", 0));
} // retranslateUi
};
namespace Ui {
class EmployeeInfo: public Ui_EmployeeInfo {};
} // namespace Ui
QT_END_NAMESPACE
#endif // UI_EMPLOYEEINFO_H
| [
"[email protected]"
] | |
31bc7c8c443c0b4cd8d928c8f1325c1065b2cdbf | 1c94933868169b68c1f50f35df126b1de7990e08 | /Inheritance/call_by_address.cpp | a70556d02cc83e2498a94aa12892f36201c79d48 | [] | no_license | chandan121988/C | 7502f98c843b0d86a272300d9bbc82692823fcd6 | 090b43113576aee5275cc5c9097dcff089df54d8 | refs/heads/main | 2023-09-03T02:17:49.425148 | 2021-11-21T15:40:24 | 2021-11-21T15:40:24 | 430,387,337 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 595 | cpp | /* C++ Pointers and Functions. This C++ program
* demonstrates about invoking the functions by
* passing the pointers in C++ */
#include<iostream>
#include<conio.h>
using namespace std;
void swap(int* x, int* y);
void main()
{
//clrscr();
int a, b;
cout << "Enter two numbers: ";
cin >> a >> b;
cout << "\nOriginal Values\n";
cout << "a = " << a << " and b = " << b << "\n";
swap(&a, &b);
cout << "\nSwapped Values\n";
cout << "a = " << a << " and b = " << b << "\n";
//getch();
}
void swap(int* x, int* y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
} | [
"[email protected]"
] | |
e65b52637a2ed64c777829fbcf84938621c8417b | 1bca4fc0734aa41bb1c6da461ec3b84ff3dd99bc | /src/version.cpp | c6bb38f8ca0bdf8b452f1bc289eb9b62a9781a8b | [
"MIT"
] | permissive | wolfoxonly/qqc | 12f892c9030c5232d403b609decf5b297cd8ceaf | 807e67ba65b555ab38a655ae4823fa9af2ae3bc4 | refs/heads/master | 2020-03-10T20:46:31.603204 | 2018-04-15T14:33:17 | 2018-04-15T14:33:17 | 129,576,997 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,645 | cpp | // Copyright (c) 2012 The QQcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <string>
#include "version.h"
// Name of client reported in the 'version' message. Report the same name
// for both QQcoind and QQcoin-qt, to make it harder for attackers to
// target servers or GUI users specifically.
const std::string CLIENT_NAME("QQcoinV1.0.0.0");//coingo.vip
// Client version number
#define CLIENT_VERSION_SUFFIX ""
// The following part of the code determines the CLIENT_BUILD variable.
// Several mechanisms are used for this:
// * first, if HAVE_BUILD_INFO is defined, include build.h, a file that is
// generated by the build environment, possibly containing the output
// of git-describe in a macro called BUILD_DESC
// * secondly, if this is an exported version of the code, GIT_ARCHIVE will
// be defined (automatically using the export-subst git attribute), and
// GIT_COMMIT will contain the commit id.
// * then, three options exist for determining CLIENT_BUILD:
// * if BUILD_DESC is defined, use that literally (output of git-describe)
// * if not, but GIT_COMMIT is defined, use v[maj].[min].[rev].[build]-g[commit]
// * otherwise, use v[maj].[min].[rev].[build]-unk
// finally CLIENT_VERSION_SUFFIX is added
// First, include build.h if requested
#ifdef HAVE_BUILD_INFO
# include "obj/build.h"
#endif
// git will put "#define GIT_ARCHIVE 1" on the next line inside archives. $Format:%n#define GIT_ARCHIVE 1$
#ifdef GIT_ARCHIVE
# define GIT_COMMIT_ID "$Format:%h$"
# define GIT_COMMIT_DATE "$Format:%cD$"
#endif
#define BUILD_DESC_FROM_COMMIT(maj,min,rev,build,commit) \
"v" DO_STRINGIZE(maj) "." DO_STRINGIZE(min) "." DO_STRINGIZE(rev) "." DO_STRINGIZE(build) "-g" commit
#define BUILD_DESC_FROM_UNKNOWN(maj,min,rev,build) \
"v" DO_STRINGIZE(maj) "." DO_STRINGIZE(min) "." DO_STRINGIZE(rev) "." DO_STRINGIZE(build) "-unk"
#ifndef BUILD_DESC
# ifdef GIT_COMMIT_ID
# define BUILD_DESC BUILD_DESC_FROM_COMMIT(QQCOIN_VERSION_MAJOR, QQCOIN_VERSION_MINOR, QQCOIN_VERSION_REVISION, QQCOIN_VERSION_BUILD, GIT_COMMIT_ID)
# else
# define BUILD_DESC BUILD_DESC_FROM_UNKNOWN(QQCOIN_VERSION_MAJOR, QQCOIN_VERSION_MINOR, QQCOIN_VERSION_REVISION, QQCOIN_VERSION_BUILD)
# endif
#endif
#ifndef BUILD_DATE
# ifdef GIT_COMMIT_DATE
# define BUILD_DATE GIT_COMMIT_DATE
# else
# define BUILD_DATE __DATE__ ", " __TIME__
# endif
#endif
const std::string CLIENT_BUILD(BUILD_DESC CLIENT_VERSION_SUFFIX);
const std::string CLIENT_DATE(BUILD_DATE);
| [
"[email protected]"
] | |
a26434153931d2a40ea7b2118112742088cf352f | 32ede8b34c2bbcb8ba365700f486e72b9a9098f8 | /Zigzag/Augest/Aug 13/D.cpp | b84e4514867be91194de09e98ea9addb0fd888b4 | [] | no_license | Cookiefan/ZigZag | 8c5182a1716b9f704ce7ec9b451d996e2dcc72af | a69f7d7fd0022eb8eb4fbf8c3956d6ca3ec38ee6 | refs/heads/master | 2021-03-22T04:52:31.037127 | 2019-08-19T12:55:37 | 2019-08-19T12:55:37 | 67,702,047 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,150 | cpp | #include <bits/stdc++.h>
#define maxn 5200
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
LL f[maxn];
pii g[maxn];
struct stick
{
int l;
long long v;
}a[maxn];
int n,m;
pii change(pii s, int x)
{
pii t=s;
if (x>=t.first)
{
t.second=t.first;
t.first=x;
}
else if (x>t.second)
t.second=x;
return t;
}
int sum(pii s)
{
return s.first+s.second;
}
bool cmp(stick a, stick b)
{
return a.l>b.l;
}
int main()
{
int Case;
scanf("%d",&Case);
for (int o=1;o<=Case;o++)
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++) scanf("%d%d",&a[i].l, &a[i].v);
sort(a+1, a+n+1, cmp);
LL ans=0;
for (int i=1;i<=n;i++) ans=max(ans, a[i].v);
for (int i=0;i<=n;i++)
for (int j=0;j<=2*m;j++)
{
f[j]=0;
g[j]=pii(0,0);
}
for (int i=1;i<=n;i++)
for (int j=2*m;j>=a[i].l;j--)
{
pii tmp=change(g[j-a[i].l], a[i].l);
if (2*j-tmp.first-tmp.second<=2*m)
{
if (f[j]<f[j-a[i].l]+a[i].v || f[j]==f[j-a[i].l]+a[i].v && sum(tmp)>sum(g[j]))
{
f[j]=f[j-a[i].l]+a[i].v;
g[j]=tmp;
}
ans=max(f[j], ans);
}
}
printf("Case #%d: %I64d\n",o,ans);
}
return 0;
} | [
"[email protected]"
] | |
c4e426be5bd9549fd5f83949a70f3ef45f6e0dcf | bb7307bc3d05d699f8351575dee5641f26048797 | /labo8/cache/fileserver/requestdispatcherthread.h | abb6c72f19e7c0b524c4e5eaac4ab339c0bdaa1a | [] | no_license | antoineNourZaf/PCOLabServer | 522a611b28c07280ba86194f48d81430d45fb285 | f47e1bcc16f486da7024718700d043a3196a1cda | refs/heads/master | 2020-03-15T11:13:35.340763 | 2018-06-15T09:52:21 | 2018-06-15T09:52:21 | 132,116,327 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,759 | h | #ifndef REQUESTDISPATCHERTHREAD_H
#define REQUESTDISPATCHERTHREAD_H
#include <QObject>
#include <QThread>
#include <QDebug>
#include "abstractbuffer.h"
#include "response.h"
#include "request.h"
#include "requesthandlerrunnable.h"
#include "QVector"
#include "threadpool.h"
/**
* @author Jimmy Verdasca & Antoine Nourazar
*/
/**
* @brief The RequestDispatcherThread class who manage the requests and create the threads who handle them
*/
class RequestDispatcherThread: public QThread
{
Q_OBJECT
public:
/**
* @brief RequestDispatcherThread constructor
* @param responses prod-cons buffer
* @param hasDebugLog bool indicating if we want logs
*/
RequestDispatcherThread(AbstractBuffer<Request>* requests, AbstractBuffer<Response>* responses, bool hasDebugLog);
protected:
/**
* @brief run read the prod-cons buffer,
* and each time he found a request,
* create a handling thread to manage the request
*/
void run();
private:
/**
* @brief requests the prod-cons buffer where we receive the requests
*/
AbstractBuffer<Request>* requests;
/**
* @brief requests the prod-cons buffer where the created thread have to send the response
*/
AbstractBuffer<Response>* responses;
/**
* @brief hasDebugLog the bool indicating if we want logs
*/
bool hasDebugLog;
QVector<RequestHandlerRunnable *> threadsStarted;
/**
* @brief requestReady create a new thread who will manage the request
* and send the response generated to the response dispatcher
* @param request that we want to manage
*/
void requestReady(Request request, ThreadPool* pool, ReaderWriterCache* cache);
};
#endif // REQUESTDISPATCHERTHREAD_H
| [
"[email protected]"
] | |
5aa0fca5f29c69869630c249543e5b8b62216ad8 | 8aa47dd44e58164a90597bebcd99e9ded6430e5e | /Phase 2 misc Files/InstructionsTest/Numeric.cpp | b876a88778b89186559f20ee4551d01e94ad67c9 | [] | no_license | froyvalencia/Machine_Instruction_Simulator_VM | 338d5c227f2c0608dca3d067127c329119297f6b | dfc9652d6ea049f8b2eedae12a54f85278f8c750 | refs/heads/master | 2021-05-01T18:46:11.387135 | 2016-12-12T23:22:54 | 2016-12-12T23:22:54 | 71,618,268 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,297 | cpp | /*
@author Froylan Valencia
VAR<name>,<type>,<optional:sizeincaseofstringonly>,<defaultvalue>
VAR$myint,NUMERIC,100
*/
#include "Numeric.h"
std::string NUMERIC = "Numeric";
//constructor
Numeric::Numeric() {}
Numeric::Numeric(std::string n,int v){
name = n;
type = NUMERIC;
value = v;
}
Numeric::~Numeric(){}
void Numeric::initialize(vector<string> line){
name = line.at(1);
type = line.at(2);
value = stoi(line.at(3));
}
VAR * Numeric::clone(vector<string> line){
Numeric * numeric = new Numeric();
numeric->initialize(line);
return numeric;
}
//sets value
void Numeric::setValue(int v){
value = v;
}
//returns value
int Numeric::getValue() const{
return value;
}
//prints the type
//virtual
//Operator Overloading
Numeric Numeric::operator*(const Numeric& other){
int result = value * other.getValue();
return Numeric(name, result);
}
Numeric Numeric::operator/(const Numeric& other){
if(other.getValue() == 0) {
//std::cout<<"Error: Divide by Zero."<< std::endl;
//system.exit(1);
}
int result = value / other.getValue();
return Numeric(name, result);
}
Numeric Numeric::operator-(const Numeric& other){ //overload +
int result = value - other.getValue();
return Numeric(name, result);
}
Numeric Numeric::operator+(const Numeric& other){ //overload +
int result = value + other.getValue();
return Numeric(name, result);
}
//int Numeric::operator+(const Numeric& other){ //overload +
//int result = value + other->getValue();
//return int;
//}
Numeric& Numeric::operator=(const Numeric& other) { // copy assignment
if (this != &other) { // self-assignment check expected
//copy data from other's storage to this storage
value = other.getValue();
name = other.name;
}
return *this;
}
Numeric* Numeric::operator+=(const Numeric* other){
value += other->getValue();
return this;
}
Numeric* Numeric::operator+=(const int& i){
value += i;
return this;
}
Numeric* Numeric::operator+=(const double& d){
value += ((int) d);
return this;
}
Numeric* Numeric::operator*=(const Numeric* other){
value *= other->getValue();
return this;
}
Numeric* Numeric::operator*=(const int& i){
value *= i;
return this;
}
Numeric* Numeric::operator*=(const double& d){
value *= ((int) d);
return this;
}
| [
"[email protected]"
] | |
565f6b402c0411ab2a0ba7fa36f7fc78fc140f6f | 4c25432a6d82aaebd82fd48e927317b15a6bf6ab | /data/dataset_2017/dataset_2017_8/elin42/8294486_5630967708385280_elin42.cpp | 67a1e50fed60a47ee7242c85d37e9874342aafe2 | [] | no_license | wzj1988tv/code-imitator | dca9fb7c2e7559007e5dbadbbc0d0f2deeb52933 | 07a461d43e5c440931b6519c8a3f62e771da2fc2 | refs/heads/master | 2020-12-09T05:33:21.473300 | 2020-01-09T15:29:24 | 2020-01-09T15:29:24 | 231,937,335 | 1 | 0 | null | 2020-01-05T15:28:38 | 2020-01-05T15:28:37 | null | UTF-8 | C++ | false | false | 1,443 | cpp | #include <algorithm>
#include <cfloat>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define mp make_pair
#define forf(i, n) for (int i = 0; i < n; i++)
#define forb(i, n) for (int i = n - 1; i >= 0; i--)
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<double> vd;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<string> vs;
typedef vector<vector<string> > vvs;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;
typedef set<int> si;
typedef vector<si> vsi;
using namespace std;
int main() {
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
int d, n;
cin >> d >> n;
vi k(n), s(n);
long double ans = d;
forf(i, n) {
cin >> k[i] >> s[i];
//double t = (double) (d - k[i]) / s[i];
//ans = min(ans, (double) d / t);
ans = min(ans, (long double) d * s[i] / (d - k[i]));
}
cout << "Case #" << t << ": ";
cout << fixed << setprecision(8) << ans << '\n';
}
return 0;
}
| [
"[email protected]"
] | |
019a415636a709237ff143438823303ded3de9de | 78ba2643ac413c1aa0a7aaa6892ceab10b4d3637 | /Lecture_Practice/11_oct.cpp | 6e5b235970ab77e74da64d344bff6b36ac17f864 | [] | no_license | chemist29/COE_322 | ce5cf0e6eee19c7fb06cad11e883f942a68a2cb4 | 626b26fd2b75249038b9847a772ab0221866d729 | refs/heads/master | 2020-04-10T02:08:15.791089 | 2018-12-06T21:53:17 | 2018-12-06T21:53:17 | 160,736,392 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 385 | cpp | #include<iostream>
#include<cmath>
using std::cout;
using std::endl;
using std::string;
int main()
{
float x = 3.1415;
int i;
cout << x <<endl;
cout << (int)x<<endl;
cout << sizeof(float)<<endl;
cout <<sizeof(double)<<endl;
cout << sizeof(int)<<"int"<<endl;
cout << sizeof(unsigned) <<"unsigned"<< endl;
cout << sizeof(short)<<"short"<<endl;
cout << sizeof(long)<<endl;
}
| [
"[email protected]"
] | |
95eec6dd43408e78582cf248b6ba0d4ae18b9c94 | c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64 | /Engine/Source/Editor/BlueprintGraph/Private/K2Node_Literal.cpp | f356787afbebb3689941cd507fca5d90c9a3075d | [
"MIT",
"LicenseRef-scancode-proprietary-license"
] | permissive | windystrife/UnrealEngine_NVIDIAGameWorks | c3c7863083653caf1bc67d3ef104fb4b9f302e2a | b50e6338a7c5b26374d66306ebc7807541ff815e | refs/heads/4.18-GameWorks | 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 | MIT | 2022-12-16T05:36:38 | 2018-03-06T15:44:09 | C++ | UTF-8 | C++ | false | false | 8,843 | cpp | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#include "K2Node_Literal.h"
#include "GameFramework/Actor.h"
#include "EdGraphSchema_K2.h"
#include "BPTerminal.h"
#include "KismetCompilerMisc.h"
#include "KismetCompiler.h"
#include "Styling/SlateIconFinder.h"
#include "ClassIconFinder.h"
#include "BlueprintNodeBinder.h"
#include "BlueprintBoundNodeSpawner.h"
#include "BlueprintActionDatabaseRegistrar.h"
#define LOCTEXT_NAMESPACE "K2Node_Literal"
class FKCHandler_LiteralStatement : public FNodeHandlingFunctor
{
public:
FKCHandler_LiteralStatement(FKismetCompilerContext& InCompilerContext)
: FNodeHandlingFunctor(InCompilerContext)
{
}
virtual void RegisterNet(FKismetFunctionContext& Context, UEdGraphPin* Net) override
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
UK2Node_Literal* LiteralNode = Cast<UK2Node_Literal>(Net->GetOwningNode());
check(LiteralNode);
UObject* TargetObject = LiteralNode->GetObjectRef();
if( !TargetObject )
{
CompilerContext.MessageLog.Warning(*LOCTEXT("InvalidLevelActor_Warning", "Node @@ is not referencing a valid level actor").ToString(), LiteralNode);
}
const FString TargetObjectName = TargetObject ? TargetObject->GetPathName() : TEXT("None");
// First, try to see if we already have a term for this object
FBPTerminal* Term = NULL;
for( int32 i = 0; i < Context.LevelActorReferences.Num(); i++ )
{
FBPTerminal& CurrentTerm = Context.LevelActorReferences[i];
if( CurrentTerm.PropertyDefault == TargetObjectName )
{
Term = &CurrentTerm;
break;
}
}
// If we didn't find one, then create a new term
if( !Term )
{
FString RefPropName = (TargetObject ? TargetObject->GetName() : TEXT("None")) + TEXT("_") + (Context.SourceGraph ? *Context.SourceGraph->GetName() : TEXT("None")) + TEXT("_RefProperty");
Term = new (Context.LevelActorReferences) FBPTerminal();
Term->CopyFromPin(Net, Context.NetNameMap->MakeValidName(Net));
Term->Name = RefPropName;
Term->PropertyDefault = TargetObjectName;
}
check(Term);
Context.NetMap.Add(Net, Term);
}
};
UK2Node_Literal::UK2Node_Literal(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
}
static FString ValuePinName(TEXT("Value"));
void UK2Node_Literal::AllocateDefaultPins()
{
// The literal node only has one pin: an output of the desired value, on a wildcard pin type
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
CreatePin(EGPD_Output, Schema->PC_Object, FString(), nullptr, *ValuePinName);
// After allocating the pins, try to coerce pin type
SetObjectRef( ObjectRef );
}
void UK2Node_Literal::PostReconstructNode()
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* ValuePin = GetValuePin();
// See if we need to fix up the value pin to have a valid type after reconstruction. Could be invalid with a stale object ref
if( ValuePin && !ObjectRef && (ValuePin->LinkedTo.Num() > 0) )
{
// Loop over the node, and figure out the most derived class connected to this pin, and use that, so everyone is happy
UClass* PinSubtype = NULL;
for( TArray<UEdGraphPin*>::TIterator PinIt(ValuePin->LinkedTo); PinIt; ++PinIt )
{
UClass* TestType = Cast<UClass>((*PinIt)->PinType.PinSubCategoryObject.Get());
if( !TestType )
{
// If this isn't a class, we're connected to something we shouldn't be. Bail and make the scripter fix it up.
return;
}
else
{
if( TestType && (!PinSubtype || (PinSubtype != TestType && TestType->IsChildOf(PinSubtype))) )
{
PinSubtype = TestType;
}
}
}
const UEdGraphPin* ConnectedPin = ValuePin->LinkedTo[0];
ValuePin->PinType = ConnectedPin->PinType;
ValuePin->PinType.PinSubCategoryObject = PinSubtype;
}
Super::PostReconstructNode();
}
FText UK2Node_Literal::GetTooltipText() const
{
return NSLOCTEXT("K2Node", "Literal_Tooltip", "Stores a reference to an actor in the level");
}
FText UK2Node_Literal::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
AActor* Actor = Cast<AActor>(ObjectRef);
if( ObjectRef != NULL )
{
if(Actor != NULL)
{
return FText::FromString(Actor->GetActorLabel());
}
else
{
return FText::FromString(ObjectRef->GetName());
}
}
else
{
return NSLOCTEXT("K2Node", "Unknown", "Unknown");
}
}
FLinearColor UK2Node_Literal::GetNodeTitleColor() const
{
UEdGraphPin* ValuePin = GetValuePin();
if( ValuePin )
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
return Schema->GetPinTypeColor(ValuePin->PinType);
}
else
{
return Super::GetNodeTitleColor();
}
}
void UK2Node_Literal::GetMenuActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar) const
{
UClass* ActionKey = GetClass();
if (!ActionRegistrar.IsOpenForRegistration(ActionKey))
{
return;
}
auto CanBindObjectLambda = [](UObject const* BindingObject)
{
if(AActor const* Actor = Cast<AActor>(BindingObject))
{
// Make sure the Actor has a world
if(Actor->GetWorld())
{
return true;
}
}
return false;
};
auto PostBindSetupLambda = [](UEdGraphNode* NewNode, UObject* BindObject)->bool
{
UK2Node_Literal* LiteralNode = CastChecked<UK2Node_Literal>(NewNode);
LiteralNode->SetObjectRef(BindObject);
return true;
};
auto UiSpecOverride = [](const FBlueprintActionContext& /*Context*/, const IBlueprintNodeBinder::FBindingSet& Bindings, FBlueprintActionUiSpec* UiSpecOut)
{
if (Bindings.Num() == 1)
{
const AActor* ActorObj = CastChecked<AActor>(Bindings.CreateConstIterator()->Get());
UiSpecOut->MenuName = FText::Format( NSLOCTEXT("K2Node", "LiteralTitle", "Create a Reference to {0}"),
FText::FromString(ActorObj->GetActorLabel()) );
const FSlateIcon Icon = FSlateIconFinder::FindIconForClass(ActorObj->GetClass());
if (Icon.IsSet())
{
UiSpecOut->Icon = Icon;
}
}
else if (Bindings.Num() > 1)
{
UiSpecOut->MenuName = FText::Format(NSLOCTEXT("K2Node", "LiteralTitleMultipleActors", "Create References to {0} selected Actors"),
FText::AsNumber(Bindings.Num()) );
auto BindingIt = Bindings.CreateConstIterator();
UClass* CommonClass = BindingIt->Get()->GetClass();
for (++BindingIt; BindingIt; ++BindingIt)
{
UClass* Class = BindingIt->Get()->GetClass();
while (!Class->IsChildOf(CommonClass))
{
CommonClass = CommonClass->GetSuperClass();
}
}
const FSlateIcon Icon = FSlateIconFinder::FindIconForClass(CommonClass);
if (Icon.IsSet())
{
UiSpecOut->Icon = Icon;
}
}
else
{
UiSpecOut->MenuName = NSLOCTEXT("K2Node", "FallbackLiteralTitle", "Error: No Actors in Context");
}
};
UBlueprintBoundNodeSpawner* NodeSpawner = UBlueprintBoundNodeSpawner::Create(GetClass());
NodeSpawner->CanBindObjectDelegate = UBlueprintBoundNodeSpawner::FCanBindObjectDelegate::CreateStatic(CanBindObjectLambda);
NodeSpawner->OnBindObjectDelegate = UBlueprintBoundNodeSpawner::FOnBindObjectDelegate::CreateStatic(PostBindSetupLambda);
NodeSpawner->DynamicUiSignatureGetter = UBlueprintBoundNodeSpawner::FUiSpecOverrideDelegate::CreateStatic(UiSpecOverride);
ActionRegistrar.AddBlueprintAction(ActionKey, NodeSpawner);
}
UK2Node::ERedirectType UK2Node_Literal::DoPinsMatchForReconstruction(const UEdGraphPin* NewPin, int32 NewPinIndex, const UEdGraphPin* OldPin, int32 OldPinIndex) const
{
// This allows the value pin (the only pin) to stay connected through reconstruction, even if the name changes due to an actor in the renamed, etc
return ERedirectType_Name;
}
AActor* UK2Node_Literal::GetReferencedLevelActor() const
{
return Cast<AActor>(ObjectRef);
}
UEdGraphPin* UK2Node_Literal::GetValuePin() const
{
return (Pins.Num() > 0) ? Pins[0] : NULL;
}
void UK2Node_Literal::SetObjectRef(UObject* NewValue)
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* ValuePin = GetValuePin();
// First, see if this is an object
if( NewValue )
{
ObjectRef = NewValue;
// Set the pin type to reflect the object we're referencing
if( ValuePin )
{
ValuePin->Modify();
ValuePin->PinType.PinCategory = Schema->PC_Object;
ValuePin->PinType.PinSubCategory.Reset();
ValuePin->PinType.PinSubCategoryObject = ObjectRef->GetClass();
}
}
if( ValuePin )
{
ValuePin->PinFriendlyName = GetNodeTitle(ENodeTitleType::FullTitle);
ValuePin->PinName = ValuePin->PinFriendlyName.BuildSourceString();
}
}
FNodeHandlingFunctor* UK2Node_Literal::CreateNodeHandler(FKismetCompilerContext& CompilerContext) const
{
return new FKCHandler_LiteralStatement(CompilerContext);
}
FSlateIcon UK2Node_Literal::GetIconAndTint(FLinearColor& OutColor) const
{
if(ObjectRef != NULL)
{
return FSlateIconFinder::FindIconForClass(ObjectRef->GetClass());
}
return Super::GetIconAndTint(OutColor);
}
#undef LOCTEXT_NAMESPACE
| [
"[email protected]"
] | |
e865acba0ae3790a824458704ed0c9091b9e63b7 | 6a87a5d90e8f1e33fe5bf1de388391d144b6e247 | /GeneralHoughTransform/Code/ObjectDetection.cpp | e2973ac31b94b102a1e333548a7f3ad4b2e77a47 | [] | no_license | kevinzhangftw/Generalized-Hough-Transform | b6f00d8966f317a41c58a5f7c24f91f301381078 | 527baedea4423365cd4bd8daf917afb36a0ab21f | refs/heads/master | 2021-01-22T04:09:29.449299 | 2017-02-27T04:59:49 | 2017-02-27T04:59:49 | 81,694,309 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,707 | cpp | //
// ObjectDetection.cpp
// GeneralHoughTransform
//
// Created by Kai Zhang on 2017-02-17.
// Copyright © 2017 Kai Zhang. All rights reserved.
//
#include "ObjectDetection.hpp"
#include "Inspector.hpp"
static Mat loadImage(const String& name){
Mat image = imread(name, IMREAD_GRAYSCALE);
if (image.empty())
{
std::cerr << "Can't load image - " << name << std::endl;
exit(-1);
}
return image;
}
Mat overlay(Mat &graySource, Mat accumulation) {
Mat copy = graySource.clone();
for (int i = 0; i < graySource.cols; i++) {
for (int j = 0; j < graySource.rows; j++) {
if (accumulation.at<float>(j,i) > 0) {
circle(copy, Point(i,j),50, Scalar(0,0,255),0, 6,0);
}
}
}
return copy;
}
Mat ObjectDetection::detect(String source, String object) {
Mat grayObject = grayScaleOf(object);
TableGenerator tabler = TableGenerator();
Mat graySource = grayScaleOf(source);
medianBlur(graySource, graySource, 5);
Mat sourceEdge = tabler.detectEdges(graySource);
Mat sourcePhiMat = tabler.phiMat(graySource);
// inspect(grayObject);
// inspect(graySource);
// inspect(sourceEdge);
// inspect(sourcePhiMat);
Rtable rTable = tabler.generate(grayObject);
tabler.inspectTable(rTable);
VoteAccumulator acc = VoteAccumulator();
Mat accumulation = acc.accumulate(sourceEdge, sourcePhiMat, rTable); //uchar
inspect(accumulation);
Mat overlaid = overlay(graySource, accumulation);
/*
Vec2i objectPosition = detectObject(bear, ghtModel);
Mat detectedImage = putCircleIntoAt(source, objectPosition);
*/
inspect(overlaid);
return graySource;
}
Mat ObjectDetection::grayScaleOf(String object) {
Mat objectMat;
if (object == "bear") {
objectMat = imread("template_bear.png", 1);
} else if (object == "elephant") {
objectMat = imread("template_elephant.png", 1);
} else if (object == "Q") {
objectMat = imread("template_Q.png", 1);
} else if (object == "K") {
objectMat = imread("template_K.png", 1);
} else if (object == "block") {
return loadImage("block.tif");
} else if (object == "animals") {
objectMat = imread("animals.jpg");
} else if (object == "blockelement") {
return loadImage("blockelement.png");
}else if (object == "blockscience") {
return loadImage("blockscience.png");
}else if (object == "letters") {
return loadImage("letters.png");
}
Mat tempMat;
cvtColor(objectMat, tempMat, CV_BGR2GRAY);
// Mat edgeImage = detectEdges(tempMat);
return tempMat;
}
| [
"[email protected]"
] | |
f7cc0bdfc2cea7ce66ec0bacb80f77e8d4109163 | 5f0b8d4a0817a46a9ae18a057a62c2442c0eb17e | /Include/event/ChangeListener.h | 130dfe64f3dcfb970c17057351e2a41f7e3a25e6 | [
"BSD-3-Clause"
] | permissive | gui-works/ui | 3327cfef7b9bbb596f2202b81f3fc9a32d5cbe2b | 023faf07ff7f11aa7d35c7849b669d18f8911cc6 | refs/heads/master | 2020-07-18T00:46:37.172575 | 2009-11-18T22:05:25 | 2009-11-18T22:05:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,924 | h | /*
* Copyright (c) 2003-2006, Bram Stein
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CHANGELISTENER_H
#define CHANGELISTENER_H
#include "../Pointers.h"
#include "./EventListener.h"
namespace ui
{
namespace event
{
/**
* Listens for ChangeEvents.
*/
class ChangeListener : public EventListener
{
public:
virtual ~ChangeListener() {};
virtual void stateChanged(const ChangeEvent &e) = 0;
};
}
}
#endif | [
"bs@bram.(none)"
] | bs@bram.(none) |
388c95efbbd4716aadddce7fc9a20aacd7a2f81c | 1a41836c57f1628cf2d796af3ca736d98044553e | /modules/canbus/vehicle/teshun/protocol/gw_vcu_sts_0x218_218.h | 1915fefbd41592b2b0b377c5beb20f0a954e1483 | [] | no_license | ColleyLi/JMCMAuto | 67fc7971bc8fe8725de5297ad7121d472db891ee | 54e727271e9d9f0fb300cdf7ab0dcc7789c6ca95 | refs/heads/master | 2023-04-25T19:49:21.978686 | 2021-06-03T10:28:49 | 2021-06-03T10:28:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,094 | h | /******************************************************************************
* Copyright 2017 The JmcAuto Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*****************************************************************************/
#ifndef MODULES_CANBUS_VEHICLE_TESHUN_PROTOCOL_GW_VCU_STS_0X218_218_H_
#define MODULES_CANBUS_VEHICLE_TESHUN_PROTOCOL_GW_VCU_STS_0X218_218_H_
#include "modules/drivers/canbus/can_comm/protocol_data.h"
#include "modules/canbus/proto/chassis_detail.pb.h"
namespace jmc_auto {
namespace canbus {
namespace teshun {
class Gwvcusts0x218218 : public ::jmc_auto::drivers::canbus::ProtocolData<
::jmc_auto::canbus::ChassisDetail> {
public:
static const int32_t ID;
Gwvcusts0x218218();
void Parse(const std::uint8_t* bytes, int32_t length,
ChassisDetail* chassis) const override;
private:
// config detail: {'name': 'Checksum_0x218', 'offset': 0.0, 'precision': 1.0, 'len': 8, 'is_signed_var': False, 'physical_range': '[0|255]', 'bit': 63, 'type': 'int', 'order': 'motorola', 'physical_unit': ''}
int checksum_0x218(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'Rolling_Counter_0x218', 'offset': 0.0, 'precision': 1.0, 'len': 4, 'is_signed_var': False, 'physical_range': '[0|15]', 'bit': 51, 'type': 'int', 'order': 'motorola', 'physical_unit': ''}
int rolling_counter_0x218(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_NLockRequest', 'enum': {0: 'VCU_NLOCKREQUEST_NO_USE', 1: 'VCU_NLOCKREQUEST_LOCK', 2: 'VCU_NLOCKREQUEST_UNLOCK', 3: 'VCU_NLOCKREQUEST_INVALID'}, 'precision': 1.0, 'len': 2, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|3]', 'bit': 53, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_nlockrequestType vcu_nlockrequest(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_PLockRequest', 'enum': {0: 'VCU_PLOCKREQUEST_NO_USE', 1: 'VCU_PLOCKREQUEST_LOCK', 2: 'VCU_PLOCKREQUEST_UNLOCK', 3: 'VCU_PLOCKREQUEST_INVALID'}, 'precision': 1.0, 'len': 2, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|3]', 'bit': 55, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_plockrequestType vcu_plockrequest(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_Vehicle_Mode', 'enum': {1: 'VCU_VEHICLE_MODE_STANDBY_IG_OFF_MODE', 2: 'VCU_VEHICLE_MODE_VEHICLE_RESET_MODE', 3: 'VCU_VEHICLE_MODE_HV_ACTIVATION_MODE', 4: 'VCU_VEHICLE_MODE_DRIVING_MODE', 5: 'VCU_VEHICLE_MODE_HV_TERMINATION_MODE', 6: 'VCU_VEHICLE_MODE_CHARGING_MODE', 7: 'VCU_VEHICLE_MODE_RESERVED', 8: 'VCU_VEHICLE_MODE_EMER_DRIVING_MODE'}, 'precision': 1.0, 'len': 4, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|15]', 'bit': 39, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
//Gw_vcu_sts_0x218_218::Vcu_vehicle_modeType vcu_vehicle_mode(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_EngaddFuel_RQ', 'enum': {0: 'VCU_ENGADDFUEL_RQ_NO_RQ', 1: 'VCU_ENGADDFUEL_RQ_RQ'}, 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|1]', 'bit': 21, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_engaddfuel_rqType vcu_engaddfuel_rq(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_FAN_RQ', 'enum': {0: 'VCU_FAN_RQ_NO_RQ', 1: 'VCU_FAN_RQ_FAN_LOW_RQ', 4: 'VCU_FAN_RQ_FAN_HIGH_RQ'}, 'precision': 1.0, 'len': 3, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|7]', 'bit': 31, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_fan_rqType vcu_fan_rq(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_EngStart_RQ', 'enum': {0: 'VCU_ENGSTART_RQ_NO_RQ', 1: 'VCU_ENGSTART_RQ_RQ'}, 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|1]', 'bit': 28, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_engstart_rqType vcu_engstart_rq(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_DCU_ParkRequest', 'enum': {0: 'VCU_DCU_PARKREQUEST_OFF', 1: 'VCU_DCU_PARKREQUEST_PARK', 2: 'VCU_DCU_PARKREQUEST_UNPARK', 3: 'VCU_DCU_PARKREQUEST_INVALID'}, 'precision': 1.0, 'len': 2, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|3]', 'bit': 44, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_dcu_parkrequestType vcu_dcu_parkrequest(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_ActualGearLevelPositionValid', 'enum': {0: 'VCU_ACTUALGEARLEVELPOSITIONVALID_VALID', 1: 'VCU_ACTUALGEARLEVELPOSITIONVALID_INVALID'}, 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|1]', 'bit': 32, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_actualgearlevelpositionvalidType vcu_actualgearlevelpositionvalid(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_ActualGearLevelPosition', 'enum': {0: 'VCU_ACTUALGEARLEVELPOSITION_INITIAL', 1: 'VCU_ACTUALGEARLEVELPOSITION_P_PARK', 2: 'VCU_ACTUALGEARLEVELPOSITION_R_REVERSE', 3: 'VCU_ACTUALGEARLEVELPOSITION_N_NEUTRAL', 4: 'VCU_ACTUALGEARLEVELPOSITION_D_DRIVE', 5: 'VCU_ACTUALGEARLEVELPOSITION_INVALID'}, 'precision': 1.0, 'len': 3, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|7]', 'bit': 47, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_actualgearlevelpositionType vcu_actualgearlevelposition(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_BMS_ChgStart_ALW', 'enum': {0: 'VCU_BMS_CHGSTART_ALW_FORBID', 1: 'VCU_BMS_CHGSTART_ALW_ALLOW'}, 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|1]', 'bit': 22, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_bms_chgstart_alwType vcu_bms_chgstart_alw(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_BMS_HVOnOff_REQ', 'enum': {0: 'VCU_BMS_HVONOFF_REQ_FORBID', 1: 'VCU_BMS_HVONOFF_REQ_ALLOW'}, 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|1]', 'bit': 23, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_bms_hvonoff_reqType vcu_bms_hvonoff_req(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_VehFailGrade_ERR', 'enum': {0: 'VCU_VEHFAILGRADE_ERR_NORMAL', 1: 'VCU_VEHFAILGRADE_ERR_LEVEL1', 2: 'VCU_VEHFAILGRADE_ERR_LEVEL2', 3: 'VCU_VEHFAILGRADE_ERR_LEVEL3'}, 'precision': 1.0, 'len': 2, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|3]', 'bit': 25, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_vehfailgrade_errType vcu_vehfailgrade_err(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_Running_Mode', 'enum': {0: 'VCU_RUNNING_MODE_STANDBY', 1: 'VCU_RUNNING_MODE_EV_MODE', 2: 'VCU_RUNNING_MODE_HYBIRD_MODE'}, 'precision': 1.0, 'len': 2, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|3]', 'bit': 27, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_running_modeType vcu_running_mode(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_BP_Sleep_Allowed', 'enum': {0: 'VCU_BP_SLEEP_ALLOWED_NOT_ALLOWED', 1: 'VCU_BP_SLEEP_ALLOWED_ALLOWED'}, 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|1]', 'bit': 33, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_bp_sleep_allowedType vcu_bp_sleep_allowed(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_HVIL_In', 'enum': {0: 'VCU_HVIL_IN_OFF', 1: 'VCU_HVIL_IN_ON'}, 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|1]', 'bit': 34, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_hvil_inType vcu_hvil_in(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_HVIL_OUT', 'enum': {0: 'VCU_HVIL_OUT_OFF', 1: 'VCU_HVIL_OUT_ON'}, 'precision': 1.0, 'len': 1, 'is_signed_var': False, 'offset': 0.0, 'physical_range': '[0|1]', 'bit': 35, 'type': 'enum', 'order': 'motorola', 'physical_unit': ''}
Gw_vcu_sts_0x218_218::Vcu_hvil_outType vcu_hvil_out(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_BP_Input_Cooling_Temp', 'offset': -40.0, 'precision': 1.0, 'len': 8, 'is_signed_var': False, 'physical_range': '[-40|215]', 'bit': 15, 'type': 'int', 'order': 'motorola', 'physical_unit': '\\A1\\E6'}
int vcu_bp_input_cooling_temp(const std::uint8_t* bytes, const int32_t length) const;
// config detail: {'name': 'VCU_Motor_Input_Cooling_Temp', 'offset': -40.0, 'precision': 1.0, 'len': 8, 'is_signed_var': False, 'physical_range': '[-40|215]', 'bit': 7, 'type': 'int', 'order': 'motorola', 'physical_unit': '\\A1\\E6'}
int vcu_motor_input_cooling_temp(const std::uint8_t* bytes, const int32_t length) const;
};
} // namespace teshun
} // namespace canbus
} // namespace jmc_auto
#endif // MODULES_CANBUS_VEHICL_TESHUN_PROTOCOL_GW_VCU_STS_0X218_218_H_
| [
"[email protected]"
] | |
1aaf45271b73dc98a4bf1d4b080a8b333676d086 | 2a24077d4fc3c7c93595b93f0632dcdff6b9e9ec | /array_string/test_wiggleSortII.cpp | 938d4e6b76c3465b51fc8eb73ec8cae73fdd476b | [] | no_license | ZhifeiDing/algorithm_learning | 6bf71eaf3713b3cb83bc96121e38ed2cdbe69385 | f6c4ad45e52dd58140380c862cae56bf02f7da78 | refs/heads/master | 2020-12-18T13:40:40.626037 | 2016-07-08T13:39:44 | 2016-07-08T13:39:44 | 34,025,191 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 231 | cpp | #include "leetcode.hpp"
void test_wiggleSortII() {
srand((unsigned int)time(NULL));
int n = rand()%15;
vector<int> nums;
gen_array(n, nums);
print_array(nums);
wiggleSortII(nums);
print_array(nums);
}
| [
"[email protected]"
] | |
945077bac04e0268411dae4a378707c2ecb8f34e | 44adf8a434334eaad957ebec19043f08fb8c3d87 | /VI Maratona MIneira de Programação/d.cpp | d852ddf2df935d0c73de799afb76a5ee89227a8b | [] | no_license | FabioVL/Competitive-Programming | c4fb94d3d5102d779c977248ab9b7d0fd84831e3 | d8c65b5c1943a6cded9e22a238b9d92fb9d51215 | refs/heads/master | 2021-01-12T16:58:25.332053 | 2018-03-14T14:06:21 | 2018-03-14T14:06:21 | 71,480,327 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 170 | cpp | #include <bits/stdc++.h>
using namespace std;
long long m,x,cont;
double p,j;
int main()
{
cin >> m >> p >> j >> x;
// cout << (int)(log(x/(m*j))/log(1-p)) << endl;
} | [
"[email protected]"
] | |
8bd71a2bdd8d7b9249b69545096c20605bac2f8a | fed96c5bb908174471430ef5284d2e43e23cc403 | /src/arm/bit_field_selector.h | ce3ecdbccf457b962f8343ef62281d5b1bb41902 | [] | no_license | dillonhuff/BinaryAnalyzer | 63e08b4a1fef06a87a8931a87a91168a6287a506 | 21cb20cba3d3e0619a8bf45aa6ba1c1b73ee7baa | refs/heads/master | 2021-01-10T20:44:20.145574 | 2015-02-19T05:12:51 | 2015-02-19T05:12:51 | 30,892,213 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 244 | h | #ifndef BIT_FIELD_SELECTOR_H_
#define BIT_FIELD_SELECTOR_H_
#include "arm/arm_instruction.h"
#include "utils/bit_field.h"
class bit_field_selector {
public:
virtual bit_field select_bits(arm_instruction* instr, bit_field* bits);
};
#endif
| [
"[email protected]"
] | |
445680b4941878edd1c6f6ab69a58459b0d91675 | 3aa9a68026ab10ced85dec559b6b4dfcb74ae251 | /leetCode/simplify-path/Accepted/2-6-2021, 12_00_58 PM/Solution.cpp | 49d0120af34d8e4ccc89b0763530356264483d3c | [] | no_license | kushuu/competitive_programming_all | 10eee29c3ca0656a2ffa37b142df680c3a022f1b | 5edaec66d2179a012832698035bdfb0957dbd806 | refs/heads/master | 2023-08-17T15:09:48.492816 | 2021-10-04T20:09:37 | 2021-10-04T20:09:37 | 334,891,360 | 3 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,192 | cpp | // https://leetcode.com/problems/simplify-path
class Solution {
public:
string simplifyPath(string path) {
int size = path.size();
vector<string> split;
stack<string> st;
string temp = "";
for(int i = 0; i < size; i++) {
if(path[i] == '/') {
if(temp != "") split.push_back(temp);
temp = "";
}
else {
temp += path[i];
}
}
if(temp != "") split.push_back(temp);
string ans = "/";
for(auto i : split) {
if(i == ".") continue;
if(i == "..") {
if(st.size() > 0) {
st.pop();
}
else continue;
}
else {
// cout << st.size();
st.push(i);
}
}
split.clear();
while(!st.empty()) {
// cout << st.top();
split.push_back(st.top());
st.pop();
}
reverse(split.begin(), split.end());
for(auto i : split) ans += i+'/';
if(ans != "/") ans.pop_back();
return ans;
}
}; | [
"[email protected]"
] | |
7db2c759f603704ebf4c0a9a42270358e232fabd | 6c470edae2e5af96623a398ee30faf3dcfa37868 | /BBoxLODs/BBoxLODs.h | f5e68b99d204c2189f892fca9d6c61c08beabe92 | [
"MIT"
] | permissive | lastmoonbeam/Lumberyard_120_Components | 7d0b1120255bbc94beae583108d0dafc1ea27ddf | baf8b7dee95fbf1680247d7229b8e6031de01a92 | refs/heads/master | 2020-08-25T19:23:45.167529 | 2020-02-07T11:59:43 | 2020-02-07T11:59:43 | 216,991,651 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,330 | h | #pragma once
#include <AzCore/Component/Component.h>
#include <AzCore/Component/TickBus.h>
#include <AzCore/Component/EntityBus.h>
#include <AzFramework/Entity/GameEntityContextBus.h>
#include <AzCore/Component/TransformBus.h>
#include <AzCore/Asset/AssetCommon.h>
#include <AzCore/Script/ScriptProperty.h>
#include <AzCore/std/smart_ptr/unique_ptr.h>
#include <Integration/Assets/MotionAsset.h>
#include <Integration/ActorComponentBus.h>
namespace GameProject
{
class BBoxLODComponent
: public AZ::Component
, private AzFramework::GameEntityContextEventBus::Handler
, private AZ::TickBus::Handler
, private EMotionFX::Integration::ActorComponentNotificationBus::Handler
{
public:
AZ_COMPONENT(BBoxLODComponent, "{4D7A9962-4BB1-41F8-91E9-1A6819C1A2E9}", AZ::Component);
BBoxLODComponent() = default;
virtual ~BBoxLODComponent() {};
// AZ::Component
static void Reflect(AZ::ReflectContext* context);
void Init() override;
void Activate() override;
void Deactivate() override;
//GameEntityContextEventBus
void OnGameEntitiesStarted() override;
private:
// ActorComponentNotificationBus::Handler
void OnActorInstanceCreated(EMotionFX::ActorInstance* actorInstance) override;
void OnActorInstanceDestroyed(EMotionFX::ActorInstance* actorInstance) override;
// AZ::TickBus::Handler
void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
int GetTickOrder() override { return AZ::ComponentTickBus::TICK_GAME + 1; };
void UpdateLODLevelByBoundingBox(EMotionFX::ActorInstance* actorInstance, const AZStd::vector<float>& distances, AZ::EntityId entityId);
void DrawRect(AZ::Vector2 min, AZ::Vector2 max);
void DrawLODLabel(AZ::Vector2 pos, float lod, float ratio);
void GenerateDefaultRatioLODs(AZ::u32 numLodLevels);
AZ::u32 GetLODByBoundingBoxSquare(const AZStd::vector<float>& squares, float square);
EMotionFX::ActorInstance* m_actorInstance = nullptr; // Associated actor instance (retrieved from Actor Component).
AZStd::vector<float> m_lodSquares; // Lod squares that decide which lod the actor should choose.
bool m_debugBBoxBounds = false;
AZ::Vector3 m_minbb = AZ::Vector3(-0.5, -0.5, 0);
AZ::Vector3 m_maxbb = AZ::Vector3(0.5, 0.5, 2);
float m_LODBoundingBoxFactor = 10.0f;
AZ::u32 m_maxLOD = 0;
};
} | [
""
] | |
e9ac2d406da96c965c5b1df6ffe7706ac93d5225 | d3fd85e739bc696077b93f56236d711634ce04af | /SoftI2CMaster.h | 148080bdf0ec51c976b32fd04b2cfcd2ef369c55 | [] | no_license | winklerlukas/GeminiLight | 3a31aecb40e9497913428a4b77e18def7b60057e | 46a210a806e8e5db55b9b39a392d19a8f9e1b44b | refs/heads/master | 2021-01-18T14:09:35.686450 | 2014-05-28T12:13:15 | 2014-05-28T12:13:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,293 | h | #ifndef SoftI2CMaster_h
#define SoftI2CMaster_h
#include <inttypes.h>
#define _SOFTI2CMASTER_VERSION 12 // software version of this library
class SoftI2CMaster
{
private:
// per object data
uint8_t _sdaPin;
uint8_t _sclPin;
uint8_t _sdaBitMask;
uint8_t _sclBitMask;
volatile uint8_t *_sdaPortReg;
volatile uint8_t *_sclPortReg;
volatile uint8_t *_sdaDirReg;
volatile uint8_t *_sclDirReg;
uint8_t usePullups;
// private methods
void setPins(uint8_t sdaPin, uint8_t sclPin, uint8_t usePullups);
void i2c_writebit( uint8_t c );
uint8_t i2c_readbit(void);
void i2c_init(void);
void i2c_start(void);
void i2c_repstart(void);
void i2c_stop(void);
uint8_t i2c_write( uint8_t c );
uint8_t i2c_read( uint8_t ack );
public:
// public methods
SoftI2CMaster(uint8_t sdaPin, uint8_t sclPin);
SoftI2CMaster(uint8_t sdaPin, uint8_t sclPin, uint8_t usePullups);
uint8_t beginTransmission(uint8_t address);
uint8_t beginTransmission(int address);
uint8_t endTransmission(void);
uint8_t send(uint8_t);
void send(uint8_t*, uint8_t);
void send(int);
void send(char*);
uint8_t requestFrom(int address);
uint8_t requestFrom(uint8_t address);
uint8_t receive( uint8_t ack );
uint8_t receive();
uint8_t receiveLast();
};
#endif
| [
"[email protected]"
] | |
8652d797321cc501933e8c56ed60c9b25851ad6b | 993ce8c9c7114b3f1cc8e153e62f95623e68c062 | /Classes/Demon/ArbitrationDemon.cpp | 527a9908b9ee88ba769bb3a841e6df2da81d43ea | [] | no_license | cleancoindev/Arbitration-Bot | d0f266684c2e0af0deb2b4691542dfe71f7b0515 | 985dcd908de5a042b2fab199ffb8c9ef18d67288 | refs/heads/master | 2022-01-28T00:46:42.248634 | 2019-05-27T07:21:23 | 2019-05-27T07:21:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 658 | cpp | //
// ArbitrationDemon.cpp
// Arbitration
//
// Created by Pavlo Boiko on 13.11.17.
// Copyright © 2017 Pavlo Boiko. All rights reserved.
//
#include "ArbitrationDemon.hpp"
#include <unistd.h>
ArbitrationDemon::ArbitrationDemon(std::vector<ExchangeCenter> _centers,int _updateInterval) {
centers = _centers;
shouldUpdate = true;
updateInterval = _updateInterval;
updateCenters();
}
void ArbitrationDemon::updateCenters() {
if (!shouldUpdate) return;
for(auto ¢er: centers) {
center.update();
}
sleep(updateInterval);
updateCenters();
}
void ArbitrationDemon::stopDemon() {
shouldUpdate = false;
}
| [
"[email protected]"
] | |
c4eebdc6a4e77cf39b4bc5fe59a673c8aa0dcd38 | 9644f19ffdac3a5d0eec4c8f802a9ab998719f82 | /Online Judges/UVA/567.cpp | 6bbd0dfba99d149084d17e9e36f677e5b8d1a036 | [] | no_license | ypizarroza1990/ACM | ca472a3773be0c925cc312960aa82046fc4057fa | 3a5a81a66540bcdae9960b497d9cf8ef4c8a50f0 | refs/heads/master | 2021-01-18T19:14:19.920891 | 2020-02-18T19:18:10 | 2020-02-18T19:18:10 | 56,805,153 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,121 | cpp | //============================================================================
// Name : COJ.cpp
// Author : Anthrax
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <iostream>
#include <cstdio>
using namespace std;
int M[30][30],x,y,m,q,t=1;;
#define INF 1e9
void floyd(int n){
for(int k=1;k<=n;k++)
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
M[i][j]=min(M[i][j],M[i][k]+M[k][j]);
}
void fill(int n){
for(int i=0;i<=n;i++)
for(int j=0;j<=n;j++){
M[i][j]=INF;
if(i==j)
M[i][j]=0;
}
}
int main() {
//freopen("en.in","r",stdin);
while(scanf("%d",&x)==1){
fill(20);
for(int i=0;i<x;i++){
scanf("%d",&y);
M[1][y]=M[y][1]=1;
}
for(int i=2;i<20;i++){
scanf("%d",&x);
for(int j=0;j<x;j++){
scanf("%d",&y);
M[i][y]=M[y][i]=1;
}
}
floyd(20);
printf("Test Set #%d\n",t++);
scanf("%d",&q);
while(q--){
scanf("%d %d",&x,&y);
printf("%2d to %2d: %d\n",x,y,M[x][y]);
}
printf("\n");
}
return 0;
}
| [
"[email protected]"
] | |
21430a6875fbd031e89864d3a65d3df249646a0a | d0c44dd3da2ef8c0ff835982a437946cbf4d2940 | /cmake-build-debug/programs_tiling/function14567/function14567_schedule_0/function14567_schedule_0.cpp | 693617088888d5f7a5fc6411493966f582ce05a0 | [] | no_license | IsraMekki/tiramisu_code_generator | 8b3f1d63cff62ba9f5242c019058d5a3119184a3 | 5a259d8e244af452e5301126683fa4320c2047a3 | refs/heads/master | 2020-04-29T17:27:57.987172 | 2019-04-23T16:50:32 | 2019-04-23T16:50:32 | 176,297,755 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,313 | cpp | #include <tiramisu/tiramisu.h>
using namespace tiramisu;
int main(int argc, char **argv){
tiramisu::init("function14567_schedule_0");
constant c0("c0", 128), c1("c1", 512), c2("c2", 1024);
var i0("i0", 0, c0), i1("i1", 0, c1), i2("i2", 0, c2), i01("i01"), i02("i02"), i03("i03"), i04("i04");
input input00("input00", {i0}, p_int32);
input input01("input01", {i1, i2}, p_int32);
input input02("input02", {i0, i1}, p_int32);
input input03("input03", {i0, i1}, p_int32);
computation comp0("comp0", {i0, i1, i2}, input00(i0) + input01(i1, i2) - input02(i0, i1) + input03(i0, i1));
comp0.tile(i0, i1, 32, 32, i01, i02, i03, i04);
comp0.parallelize(i01);
buffer buf00("buf00", {128}, p_int32, a_input);
buffer buf01("buf01", {512, 1024}, p_int32, a_input);
buffer buf02("buf02", {128, 512}, p_int32, a_input);
buffer buf03("buf03", {128, 512}, p_int32, a_input);
buffer buf0("buf0", {128, 512, 1024}, p_int32, a_output);
input00.store_in(&buf00);
input01.store_in(&buf01);
input02.store_in(&buf02);
input03.store_in(&buf03);
comp0.store_in(&buf0);
tiramisu::codegen({&buf00, &buf01, &buf02, &buf03, &buf0}, "../data/programs/function14567/function14567_schedule_0/function14567_schedule_0.o");
return 0;
} | [
"[email protected]"
] | |
ec6aafec9c5658a8624cc76a7459e8e1f16793be | 8314693edc5f7fceeb38fa249bb3cc9253d419ca | /taichi/ir/type.h | 9556c41116402bf8c35f8b1d273e0a0982933707 | [
"MIT"
] | permissive | weiplanet/taichi | 22c6cd730d9ff33b77b5019a86dd47a5e3b8fa57 | ceea597141bd1f0f0b2a380e5dabd50fb6ed04a6 | refs/heads/master | 2022-12-29T06:18:31.449604 | 2020-10-16T20:57:35 | 2020-10-16T20:57:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,072 | h | #pragma once
#include "taichi/common/core.h"
TLANG_NAMESPACE_BEGIN
enum class PrimitiveTypeID : int {
#define PER_TYPE(x) x,
#include "taichi/inc/data_type.inc.h"
#undef PER_TYPE
};
class Type {
public:
virtual std::string to_string() const = 0;
template <typename T>
bool is() const {
return cast<T>() != nullptr;
}
template <typename T>
const T *cast() const {
return dynamic_cast<const T *>(this);
}
template <typename T>
T *cast() {
return dynamic_cast<T *>(this);
}
template <typename T>
T *as() {
auto p = dynamic_cast<T *>(this);
TI_ASSERT(p != nullptr);
return p;
}
int vector_width() const;
virtual ~Type() {
}
};
// A "Type" handle. This should be removed later.
class DataType {
public:
DataType();
DataType(Type *ptr) : ptr_(ptr) {
}
DataType(const DataType &o) : ptr_(o.ptr_) {
}
bool operator==(const DataType &o) const {
return ptr_ == o.ptr_;
}
bool operator!=(const DataType &o) const {
return !(*this == o);
}
std::size_t hash() const;
std::string to_string() const {
return ptr_->to_string();
};
// TODO: DataType itself should be a pointer in the future
Type *get_ptr() const {
return ptr_;
}
// Temporary API and members
// for LegacyVectorType-compatibility
Type *operator->() const {
return ptr_;
}
DataType &operator=(const DataType &o) {
ptr_ = o.ptr_;
return *this;
}
bool is_pointer() const;
void set_is_pointer(bool ptr);
DataType ptr_removed() const;
private:
Type *ptr_;
};
class PrimitiveType : public Type {
public:
#define PER_TYPE(x) static DataType x;
#include "taichi/inc/data_type.inc.h"
#undef PER_TYPE
PrimitiveTypeID type;
PrimitiveType(PrimitiveTypeID type) : type(type) {
}
std::string to_string() const override;
static DataType get(PrimitiveTypeID type);
};
class PointerType : public Type {
public:
PointerType(Type *pointee, bool is_bit_pointer)
: pointee_(pointee), is_bit_pointer_(is_bit_pointer) {
}
Type *get_pointee_type() const {
return pointee_;
}
auto get_addr_space() const {
return addr_space_;
}
bool is_bit_pointer() const {
return is_bit_pointer_;
}
std::string to_string() const override {
return fmt::format("*{}", pointee_->to_string());
};
private:
Type *pointee_{nullptr};
int addr_space_{0}; // TODO: make this an enum
bool is_bit_pointer_{false};
};
class VectorType : public Type {
public:
VectorType(int num_elements, Type *element)
: num_elements_(num_elements), element_(element) {
}
Type *get_element_type() const {
return element_;
}
int get_num_elements() const {
return num_elements_;
}
std::string to_string() const override {
return fmt::format("[{} x {}]", num_elements_, element_->to_string());
};
private:
int num_elements_{0};
Type *element_{nullptr};
};
DataType LegacyVectorType(int width,
DataType data_type,
bool is_pointer = false);
TLANG_NAMESPACE_END
| [
"[email protected]"
] | |
616e74865b978ff0b2ebe26e15ffb4ad48adde8d | 30276975fa3758fe5d70eb9d1cb423a78651e38a | /support/placeholders/Serial.h | 9ce0b286eb6becf36ac424a5dcc3f6b588699ef8 | [] | no_license | ryantuck/lit-halo | 911295bcac1abed58dfbec553fb040023118a2d9 | bc8f50b1a8716679d4fc17c214de21caf2affa56 | refs/heads/master | 2021-01-20T10:35:45.317919 | 2014-08-07T17:45:29 | 2014-08-07T17:45:29 | 8,165,957 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 670 | h | // ####################################################################
//
// Serial.h
//
// Replaces cout commands so two copies of code (xcode and arduino)
// don't have to be kept.
//
// ####################################################################
#ifndef __cppTesting__Serial__
#define __cppTesting__Serial__
#include <iostream>
#include <string.h>
class SerialClass
{
public:
void print(int integer);
void print(std::string myString);
void print(float myFloat);
void print(double myDouble);
void println();
void println(int myInt);
void println(std::string myString);
void println(float myFloat);
void println(double myDouble);
};
#endif
| [
"[email protected]"
] | |
7bc935043c1f109117dedac0d2c01ebe3dbdd903 | 1d4f51af666147aeea3649e7ce344fb6f1258838 | /Final Hololens App/Il2CppOutputProject/Source/il2cppOutput/UnityEngine.CoreModule3.cpp | 2c2c37ba517203c9e6b1015ddfee1bda61e83e2e | [] | no_license | Mori-Levinzon/CAD-Inspector | d75d29ff663761e2305055babdbc1b927ee364d5 | 780b133ad1ef3b7846f95237763d702086e638a7 | refs/heads/master | 2023-06-07T04:47:38.784636 | 2021-07-02T12:25:29 | 2021-07-02T12:25:29 | 250,212,314 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 323,758 | cpp | #include "pch-cpp.hpp"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <limits>
#include <stdint.h>
template <typename T1>
struct VirtActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename R, typename T1, typename T2>
struct VirtFuncInvoker2
{
typedef R (*Func)(void*, T1, T2, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
struct VirtActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename R>
struct VirtFuncInvoker0
{
typedef R (*Func)(void*, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename T1>
struct GenericVirtActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename R, typename T1, typename T2>
struct GenericVirtFuncInvoker2
{
typedef R (*Func)(void*, T1, T2, const RuntimeMethod*);
static inline R Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
return ((Func)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
struct GenericVirtActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename T1>
struct InterfaceActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename R, typename T1, typename T2>
struct InterfaceFuncInvoker2
{
typedef R (*Func)(void*, T1, T2, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
return ((Func)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
struct InterfaceActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename T1>
struct GenericInterfaceActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename R, typename T1, typename T2>
struct GenericInterfaceFuncInvoker2
{
typedef R (*Func)(void*, T1, T2, const RuntimeMethod*);
static inline R Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
return ((Func)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
struct GenericInterfaceActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
// System.Globalization.CodePageDataItem
struct CodePageDataItem_t09A62F57142BF0456C8F414898A37E79BCC9F09E;
// System.Delegate
struct Delegate_t;
// System.DelegateData
struct DelegateData_t17DD30660E330C49381DAA99F934BE75CB11F288;
// System.Collections.Hashtable
struct Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC;
// System.Collections.IDictionary
struct IDictionary_t99871C56B8EC2452AC5C4CF3831695E617B89D3A;
// UnityEngine.Events.InvokableCallList
struct InvokableCallList_tB7C66AA0C00F9C102C8BDC17A144E569AC7527A9;
// UnityEngine.Networking.PlayerConnection.MessageEventArgs
struct MessageEventArgs_t6905F6AA12A37C5A38BBCB907E9215622364DCCA;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// UnityEngine.Events.PersistentCallGroup
struct PersistentCallGroup_t9A1D83DA2BA3118C103FA87D93CE92557A956FDC;
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50;
// UnityEngine.RectTransform
struct RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072;
// System.Runtime.Serialization.SafeSerializationManager
struct SafeSerializationManager_tDE44F029589A028F8A3053C5C06153FAB4AAE29F;
// Microsoft.Win32.SafeHandles.SafeWaitHandle
struct SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1;
// UnityEngine.Transform
struct Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1;
// UnityEngine.Windows.WebCam.VideoCapture
struct VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91;
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5;
// UnityEngine.Windows.WebCam.PhotoCapture/OnPhotoModeStartedCallback
struct OnPhotoModeStartedCallback_t21FCF86FB7933100968EE01A7B4BFB751F53EF92;
// UnityEngine.Windows.WebCam.PhotoCapture/OnPhotoModeStoppedCallback
struct OnPhotoModeStoppedCallback_tF6A2F039E1A8DB64BD4CF25675BED44F74E5B1F6;
// UnityEngine.Windows.Speech.PhraseRecognitionSystem/ErrorDelegate
struct ErrorDelegate_t4E0F6E50E9C786DB72C82D69540E01FB9EFD3D9C;
// UnityEngine.Windows.Speech.PhraseRecognitionSystem/StatusDelegate
struct StatusDelegate_tD751E0623EDFECE1A8492E9DB58E762EFC0D2528;
// UnityEngine.Windows.Speech.PhraseRecognizer/PhraseRecognizedDelegate
struct PhraseRecognizedDelegate_t13C88401D803DCE6F7A0250C3C86F0FF1FD8662F;
// UnityEngine.Playables.PlayableBinding/CreateOutputMethod
struct CreateOutputMethod_t7A129D00E8823B50AEDD0C9B082C9CB3DF863876;
// UnityEngine.Networking.PlayerConnection.PlayerConnection/<>c__DisplayClass12_0
struct U3CU3Ec__DisplayClass12_0_tC029C4F11E384EFEF6FD86B7BEC83D295D098769;
// UnityEngine.Networking.PlayerConnection.PlayerConnection/<>c__DisplayClass13_0
struct U3CU3Ec__DisplayClass13_0_t1A8EBE4E3370D09549DE4FD59077B3A7AEAD0C54;
// UnityEngine.Networking.PlayerConnection.PlayerConnection/<>c__DisplayClass20_0
struct U3CU3Ec__DisplayClass20_0_tEA47E236E3FCEC75772DAF52911B35E8F14766DD;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/<>c__DisplayClass6_0
struct U3CU3Ec__DisplayClass6_0_t96633FB6A2AE351A4A3FCDF89D10891DA07AD54F;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/<>c__DisplayClass7_0
struct U3CU3Ec__DisplayClass7_0_t7C625D285CBB757F88C0232D12D88EDABF06EB60;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/<>c__DisplayClass8_0
struct U3CU3Ec__DisplayClass8_0_tE64E7CAC5415DCD425D14A6062600087CC872B93;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/ConnectionChangeEvent
struct ConnectionChangeEvent_tCA1C8C14171C72EC394EF45450D69C1585067BDF;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageEvent
struct MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers
struct MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F;
// UnityEngine.LowLevel.PlayerLoopSystem/UpdateFunction
struct UpdateFunction_tEDC2A88F61F179480CAA9443E6ADDA3F126B8AEA;
// UnityEngine.RectTransform/ReapplyDrivenProperties
struct ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE;
// UnityEngine.Transform/Enumerator
struct Enumerator_t8A0B2200373BC9628C065322A1BA07AAA47E0259;
// UnityEngine.UnhandledExceptionHandler/<>c
struct U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF;
// UnityEngine.Windows.WebCam.VideoCapture/OnStartedRecordingVideoCallback
struct OnStartedRecordingVideoCallback_tF42862BD94B6DEE3AFBAEC068CB93D2B35E366A9;
// UnityEngine.Windows.WebCam.VideoCapture/OnStoppedRecordingVideoCallback
struct OnStoppedRecordingVideoCallback_t2D7EC27C8904AE0EE068D13F918E42EECF965DD6;
// UnityEngine.Windows.WebCam.VideoCapture/OnVideoCaptureResourceCreatedCallback
struct OnVideoCaptureResourceCreatedCallback_t3699FD2DE7FEF286A229B548E358133211BBA956;
// UnityEngine.Windows.WebCam.VideoCapture/OnVideoModeStartedCallback
struct OnVideoModeStartedCallback_t201EBB65059DA254ED2A4B24D365C4F6EAE9DF75;
// UnityEngine.Windows.WebCam.VideoCapture/OnVideoModeStoppedCallback
struct OnVideoModeStoppedCallback_tA0921FEE66B3EDE3E01E8D6526CF5203ED3C273C;
// UnityEngine.Events.UnityEvent`1<UnityEngine.Networking.PlayerConnection.MessageEventArgs>
struct UnityEvent_1_t5380899C55F3CD7FD1CD64F13EE5E1E4B11D602B;
// UnityEngine.Events.UnityEvent`1<System.Int32>
struct UnityEvent_1_tB235B5DAD099AC425DC059D10DEB8B97A35E2BBF;
// UnityEngine.Events.UnityEvent`1<System.Object>
struct UnityEvent_1_t32063FE815890FF672DF76288FAC4ABE089B899F;
// System.AsyncCallback
struct AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA;
// System.Byte[]
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726;
// System.Char[]
struct CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34;
// System.Text.DecoderFallback
struct DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D;
// System.Text.DecoderReplacementFallback
struct DecoderReplacementFallback_t8DA345EC4EF3A35A2667365F691EE69408A62130;
// System.Delegate[]
struct DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8;
// System.Text.EncoderFallback
struct EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4;
// System.Text.EncoderReplacementFallback
struct EncoderReplacementFallback_t61E36A507D7FA8034B49F86DBE560EC77A6A8418;
// System.Text.Encoding
struct Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827;
// System.Threading.EventWaitHandle
struct EventWaitHandle_t80CDEB33529EF7549E7D3E3B689D8272B9F37F3C;
// System.Exception
struct Exception_t;
// System.IAsyncResult
struct IAsyncResult_tC9F97BF36FCF122D29D3101D80642278297BF370;
// System.Int32[]
struct Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32;
// System.IntPtr[]
struct IntPtrU5BU5D_t27FC72B0409D75AAF33EC42498E8094E95FEE9A6;
// System.Collections.Generic.KeyValuePair`2<System.Byte[],System.Text.Encoding>[]
struct KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7;
// System.Threading.ManualResetEvent
struct ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA;
// System.Object[]
struct ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE;
// UnityEngine.Windows.Speech.SemanticMeaning[]
struct SemanticMeaningU5BU5D_t7BA8135E11B4D0C1065824DA86D4B3DB63A5B4DD;
// System.Threading.SendOrPostCallback
struct SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C;
// System.Diagnostics.StackTrace[]
struct StackTraceU5BU5D_t4AD999C288CB6D1F38A299D12B1598D606588971;
// System.String
struct String_t;
// System.Text.UTF32Encoding
struct UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014;
// System.Text.UTF8Encoding
struct UTF8Encoding_t6EE88BC62116B5328F6CF4E39C9CC49EED2ED282;
// System.UnhandledExceptionEventArgs
struct UnhandledExceptionEventArgs_tFA66D5AA8F6337DEF8E2B494B3B8C377C9FDB885;
// System.UnhandledExceptionEventHandler
struct UnhandledExceptionEventHandler_t1DF125A860ED9B70F24ADFA6CB0781533A23DA64;
// System.Text.UnicodeEncoding
struct UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68;
IL2CPP_EXTERN_C RuntimeClass* Debug_tEB68BCBEB8EFD60F8043C67146DC05E7F50F374B_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* DecoderReplacementFallback_t8DA345EC4EF3A35A2667365F691EE69408A62130_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* EncoderReplacementFallback_t61E36A507D7FA8034B49F86DBE560EC77A6A8418_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* EncodingUtility_tF25232B383AA56BB15E7955C1C9FC356F9770983_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Exception_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Guid_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* SpeechError_t3B8EC653706113444C6077B380A8FD5DF407EC8F_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* SpeechSystemStatus_t9D1FF73360901F27A8117402D1F5BCC7E1309BF5_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UTF8Encoding_t6EE88BC62116B5328F6CF4E39C9CC49EED2ED282_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C String_t* _stringLiteralB8F710F417E2D96E747683BF53A8CA9BB6B9648C;
IL2CPP_EXTERN_C const RuntimeMethod* KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UnityEvent_1__ctor_m30F443398054B5E3666B3C86E64A5C0FF97D93FF_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UnityEvent_1__ctor_mC7E63F58C7EFC8E8747E3619B7564A7325F03D3B_RuntimeMethod_var;
IL2CPP_EXTERN_C const uint32_t ConnectionChangeEvent__ctor_m95EBD8B5EA1C4A14A5F2B71CEE1A2C18C73DB0A1_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t CreateOutputMethod_BeginInvoke_m082AE47F9DFBF0C1787081D2D628E0E5CECCBFF1_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EncodingUtility__cctor_m6BADEB7670563CC438C10AF259028A7FF06AD65F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ErrorDelegate_BeginInvoke_mD2A98805D514FF2FE986EAB635AECA18A6CB42F8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t MessageEvent__ctor_mE4D70D8837C51E422C9A40C3F8F34ACB9AB572BB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t MessageTypeSubscribers__ctor_mA51A6D3E38DBAA5B8237BAB1688F669F24982F29_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t OnPhotoModeStartedCallback_BeginInvoke_m4AB861825C43FBA4BB652B26EF01085FEF25B0CD_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t OnPhotoModeStoppedCallback_BeginInvoke_m70BAC41BE079FC59B70B141F732DCE97FA7BC5AA_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t OnStartedRecordingVideoCallback_BeginInvoke_m1E4D58E53791FAACD887CFB36445C5FEA8F7CD06_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t OnStoppedRecordingVideoCallback_BeginInvoke_mA92F3961C471FBD5E16F95840A8CB912E20C54BC_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t OnVideoModeStartedCallback_BeginInvoke_m4A3CEBB5158BB4DCB0F8DD884D88A53CE484CEFB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t OnVideoModeStoppedCallback_BeginInvoke_mDBF06C8C08B108AB38F91C075A660AFA1D40876C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t PhraseRecognizedDelegate_BeginInvoke_m7AA286808D7E2C74F4ABA0C33D494837575D1056_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t StatusDelegate_BeginInvoke_m5E20320BB35F9113700B3DA0DFAEF01DEE14DAC8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t U3CU3Ec_U3CRegisterUECatcherU3Eb__0_0_mB2E6DD6B9C72FA3D5DB8D311DB281F272A587278_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t U3CU3Ec__DisplayClass12_0_U3CRegisterU3Eb__0_m27C1416BAD7AF0A1BF83339C8A03865A6487B234_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t U3CU3Ec__DisplayClass13_0_U3CUnregisterU3Eb__0_mBA34804D7BB1B4FFE45D077BBB07BFA81C8DCB00_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t U3CU3Ec__DisplayClass6_0_U3CInvokeMessageIdSubscribersU3Eb__0_mEF5D5DFC8F7C2CEC86378AC3BBD40E80A1D9C615_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t U3CU3Ec__DisplayClass7_0_U3CAddAndCreateU3Eb__0_mAA3D205F35F7BE200A5DDD14099F56312FBED909_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t U3CU3Ec__DisplayClass8_0_U3CUnregisterManagedCallbackU3Eb__0_m70805C4CE0F8DD258CC3975A8C90313A0A609BE3_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t U3CU3Ec__cctor_m5B3F5B8A2DD74DC42F3E777C1FDD1C880EFA95BA_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t WorkRequest_Invoke_m1C292B7297918C5F2DBE70971895FE8D5C33AA20_MetadataUsageId;
struct Delegate_t_marshaled_com;
struct Delegate_t_marshaled_pinvoke;
struct Exception_t_marshaled_com;
struct Exception_t_marshaled_pinvoke;
struct SemanticMeaning_t5AEB02C787CA22E278A1E6D32FDA7CCA378F86E3_marshaled_com;
struct SemanticMeaning_t5AEB02C787CA22E278A1E6D32FDA7CCA378F86E3_marshaled_pinvoke;
struct VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91;;
struct VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshaled_pinvoke;
struct VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshaled_pinvoke;;
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726;
struct KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7;
struct DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8;
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
// System.Object
struct Il2CppArrayBounds;
// System.Array
// System.EventArgs
struct EventArgs_tBCAACA538A5195B6D6C8DFCC3524A2A4A67FD8BA : public RuntimeObject
{
public:
public:
};
struct EventArgs_tBCAACA538A5195B6D6C8DFCC3524A2A4A67FD8BA_StaticFields
{
public:
// System.EventArgs System.EventArgs::Empty
EventArgs_tBCAACA538A5195B6D6C8DFCC3524A2A4A67FD8BA * ___Empty_0;
public:
inline static int32_t get_offset_of_Empty_0() { return static_cast<int32_t>(offsetof(EventArgs_tBCAACA538A5195B6D6C8DFCC3524A2A4A67FD8BA_StaticFields, ___Empty_0)); }
inline EventArgs_tBCAACA538A5195B6D6C8DFCC3524A2A4A67FD8BA * get_Empty_0() const { return ___Empty_0; }
inline EventArgs_tBCAACA538A5195B6D6C8DFCC3524A2A4A67FD8BA ** get_address_of_Empty_0() { return &___Empty_0; }
inline void set_Empty_0(EventArgs_tBCAACA538A5195B6D6C8DFCC3524A2A4A67FD8BA * value)
{
___Empty_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Empty_0), (void*)value);
}
};
// System.MarshalByRefObject
struct MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8 : public RuntimeObject
{
public:
// System.Object System.MarshalByRefObject::_identity
RuntimeObject * ____identity_0;
public:
inline static int32_t get_offset_of__identity_0() { return static_cast<int32_t>(offsetof(MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8, ____identity_0)); }
inline RuntimeObject * get__identity_0() const { return ____identity_0; }
inline RuntimeObject ** get_address_of__identity_0() { return &____identity_0; }
inline void set__identity_0(RuntimeObject * value)
{
____identity_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____identity_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8_marshaled_pinvoke
{
Il2CppIUnknown* ____identity_0;
};
// Native definition for COM marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8_marshaled_com
{
Il2CppIUnknown* ____identity_0;
};
// System.String
struct String_t : public RuntimeObject
{
public:
// System.Int32 System.String::m_stringLength
int32_t ___m_stringLength_0;
// System.Char System.String::m_firstChar
Il2CppChar ___m_firstChar_1;
public:
inline static int32_t get_offset_of_m_stringLength_0() { return static_cast<int32_t>(offsetof(String_t, ___m_stringLength_0)); }
inline int32_t get_m_stringLength_0() const { return ___m_stringLength_0; }
inline int32_t* get_address_of_m_stringLength_0() { return &___m_stringLength_0; }
inline void set_m_stringLength_0(int32_t value)
{
___m_stringLength_0 = value;
}
inline static int32_t get_offset_of_m_firstChar_1() { return static_cast<int32_t>(offsetof(String_t, ___m_firstChar_1)); }
inline Il2CppChar get_m_firstChar_1() const { return ___m_firstChar_1; }
inline Il2CppChar* get_address_of_m_firstChar_1() { return &___m_firstChar_1; }
inline void set_m_firstChar_1(Il2CppChar value)
{
___m_firstChar_1 = value;
}
};
struct String_t_StaticFields
{
public:
// System.String System.String::Empty
String_t* ___Empty_5;
public:
inline static int32_t get_offset_of_Empty_5() { return static_cast<int32_t>(offsetof(String_t_StaticFields, ___Empty_5)); }
inline String_t* get_Empty_5() const { return ___Empty_5; }
inline String_t** get_address_of_Empty_5() { return &___Empty_5; }
inline void set_Empty_5(String_t* value)
{
___Empty_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Empty_5), (void*)value);
}
};
// System.Text.DecoderFallback
struct DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D : public RuntimeObject
{
public:
// System.Boolean System.Text.DecoderFallback::bIsMicrosoftBestFitFallback
bool ___bIsMicrosoftBestFitFallback_0;
public:
inline static int32_t get_offset_of_bIsMicrosoftBestFitFallback_0() { return static_cast<int32_t>(offsetof(DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D, ___bIsMicrosoftBestFitFallback_0)); }
inline bool get_bIsMicrosoftBestFitFallback_0() const { return ___bIsMicrosoftBestFitFallback_0; }
inline bool* get_address_of_bIsMicrosoftBestFitFallback_0() { return &___bIsMicrosoftBestFitFallback_0; }
inline void set_bIsMicrosoftBestFitFallback_0(bool value)
{
___bIsMicrosoftBestFitFallback_0 = value;
}
};
struct DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D_StaticFields
{
public:
// System.Text.DecoderFallback modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.DecoderFallback::replacementFallback
DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * ___replacementFallback_1;
// System.Text.DecoderFallback modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.DecoderFallback::exceptionFallback
DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * ___exceptionFallback_2;
// System.Object System.Text.DecoderFallback::s_InternalSyncObject
RuntimeObject * ___s_InternalSyncObject_3;
public:
inline static int32_t get_offset_of_replacementFallback_1() { return static_cast<int32_t>(offsetof(DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D_StaticFields, ___replacementFallback_1)); }
inline DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * get_replacementFallback_1() const { return ___replacementFallback_1; }
inline DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D ** get_address_of_replacementFallback_1() { return &___replacementFallback_1; }
inline void set_replacementFallback_1(DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * value)
{
___replacementFallback_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___replacementFallback_1), (void*)value);
}
inline static int32_t get_offset_of_exceptionFallback_2() { return static_cast<int32_t>(offsetof(DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D_StaticFields, ___exceptionFallback_2)); }
inline DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * get_exceptionFallback_2() const { return ___exceptionFallback_2; }
inline DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D ** get_address_of_exceptionFallback_2() { return &___exceptionFallback_2; }
inline void set_exceptionFallback_2(DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * value)
{
___exceptionFallback_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___exceptionFallback_2), (void*)value);
}
inline static int32_t get_offset_of_s_InternalSyncObject_3() { return static_cast<int32_t>(offsetof(DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D_StaticFields, ___s_InternalSyncObject_3)); }
inline RuntimeObject * get_s_InternalSyncObject_3() const { return ___s_InternalSyncObject_3; }
inline RuntimeObject ** get_address_of_s_InternalSyncObject_3() { return &___s_InternalSyncObject_3; }
inline void set_s_InternalSyncObject_3(RuntimeObject * value)
{
___s_InternalSyncObject_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_InternalSyncObject_3), (void*)value);
}
};
// System.Text.EncoderFallback
struct EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 : public RuntimeObject
{
public:
// System.Boolean System.Text.EncoderFallback::bIsMicrosoftBestFitFallback
bool ___bIsMicrosoftBestFitFallback_0;
public:
inline static int32_t get_offset_of_bIsMicrosoftBestFitFallback_0() { return static_cast<int32_t>(offsetof(EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4, ___bIsMicrosoftBestFitFallback_0)); }
inline bool get_bIsMicrosoftBestFitFallback_0() const { return ___bIsMicrosoftBestFitFallback_0; }
inline bool* get_address_of_bIsMicrosoftBestFitFallback_0() { return &___bIsMicrosoftBestFitFallback_0; }
inline void set_bIsMicrosoftBestFitFallback_0(bool value)
{
___bIsMicrosoftBestFitFallback_0 = value;
}
};
struct EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4_StaticFields
{
public:
// System.Text.EncoderFallback modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.EncoderFallback::replacementFallback
EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * ___replacementFallback_1;
// System.Text.EncoderFallback modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.EncoderFallback::exceptionFallback
EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * ___exceptionFallback_2;
// System.Object System.Text.EncoderFallback::s_InternalSyncObject
RuntimeObject * ___s_InternalSyncObject_3;
public:
inline static int32_t get_offset_of_replacementFallback_1() { return static_cast<int32_t>(offsetof(EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4_StaticFields, ___replacementFallback_1)); }
inline EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * get_replacementFallback_1() const { return ___replacementFallback_1; }
inline EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 ** get_address_of_replacementFallback_1() { return &___replacementFallback_1; }
inline void set_replacementFallback_1(EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * value)
{
___replacementFallback_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___replacementFallback_1), (void*)value);
}
inline static int32_t get_offset_of_exceptionFallback_2() { return static_cast<int32_t>(offsetof(EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4_StaticFields, ___exceptionFallback_2)); }
inline EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * get_exceptionFallback_2() const { return ___exceptionFallback_2; }
inline EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 ** get_address_of_exceptionFallback_2() { return &___exceptionFallback_2; }
inline void set_exceptionFallback_2(EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * value)
{
___exceptionFallback_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___exceptionFallback_2), (void*)value);
}
inline static int32_t get_offset_of_s_InternalSyncObject_3() { return static_cast<int32_t>(offsetof(EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4_StaticFields, ___s_InternalSyncObject_3)); }
inline RuntimeObject * get_s_InternalSyncObject_3() const { return ___s_InternalSyncObject_3; }
inline RuntimeObject ** get_address_of_s_InternalSyncObject_3() { return &___s_InternalSyncObject_3; }
inline void set_s_InternalSyncObject_3(RuntimeObject * value)
{
___s_InternalSyncObject_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_InternalSyncObject_3), (void*)value);
}
};
// System.Text.Encoding
struct Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 : public RuntimeObject
{
public:
// System.Int32 System.Text.Encoding::m_codePage
int32_t ___m_codePage_9;
// System.Globalization.CodePageDataItem System.Text.Encoding::dataItem
CodePageDataItem_t09A62F57142BF0456C8F414898A37E79BCC9F09E * ___dataItem_10;
// System.Boolean System.Text.Encoding::m_deserializedFromEverett
bool ___m_deserializedFromEverett_11;
// System.Boolean System.Text.Encoding::m_isReadOnly
bool ___m_isReadOnly_12;
// System.Text.EncoderFallback System.Text.Encoding::encoderFallback
EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * ___encoderFallback_13;
// System.Text.DecoderFallback System.Text.Encoding::decoderFallback
DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * ___decoderFallback_14;
public:
inline static int32_t get_offset_of_m_codePage_9() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827, ___m_codePage_9)); }
inline int32_t get_m_codePage_9() const { return ___m_codePage_9; }
inline int32_t* get_address_of_m_codePage_9() { return &___m_codePage_9; }
inline void set_m_codePage_9(int32_t value)
{
___m_codePage_9 = value;
}
inline static int32_t get_offset_of_dataItem_10() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827, ___dataItem_10)); }
inline CodePageDataItem_t09A62F57142BF0456C8F414898A37E79BCC9F09E * get_dataItem_10() const { return ___dataItem_10; }
inline CodePageDataItem_t09A62F57142BF0456C8F414898A37E79BCC9F09E ** get_address_of_dataItem_10() { return &___dataItem_10; }
inline void set_dataItem_10(CodePageDataItem_t09A62F57142BF0456C8F414898A37E79BCC9F09E * value)
{
___dataItem_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___dataItem_10), (void*)value);
}
inline static int32_t get_offset_of_m_deserializedFromEverett_11() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827, ___m_deserializedFromEverett_11)); }
inline bool get_m_deserializedFromEverett_11() const { return ___m_deserializedFromEverett_11; }
inline bool* get_address_of_m_deserializedFromEverett_11() { return &___m_deserializedFromEverett_11; }
inline void set_m_deserializedFromEverett_11(bool value)
{
___m_deserializedFromEverett_11 = value;
}
inline static int32_t get_offset_of_m_isReadOnly_12() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827, ___m_isReadOnly_12)); }
inline bool get_m_isReadOnly_12() const { return ___m_isReadOnly_12; }
inline bool* get_address_of_m_isReadOnly_12() { return &___m_isReadOnly_12; }
inline void set_m_isReadOnly_12(bool value)
{
___m_isReadOnly_12 = value;
}
inline static int32_t get_offset_of_encoderFallback_13() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827, ___encoderFallback_13)); }
inline EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * get_encoderFallback_13() const { return ___encoderFallback_13; }
inline EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 ** get_address_of_encoderFallback_13() { return &___encoderFallback_13; }
inline void set_encoderFallback_13(EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * value)
{
___encoderFallback_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___encoderFallback_13), (void*)value);
}
inline static int32_t get_offset_of_decoderFallback_14() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827, ___decoderFallback_14)); }
inline DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * get_decoderFallback_14() const { return ___decoderFallback_14; }
inline DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D ** get_address_of_decoderFallback_14() { return &___decoderFallback_14; }
inline void set_decoderFallback_14(DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * value)
{
___decoderFallback_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___decoderFallback_14), (void*)value);
}
};
struct Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields
{
public:
// System.Text.Encoding modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.Encoding::defaultEncoding
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___defaultEncoding_0;
// System.Text.Encoding modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.Encoding::unicodeEncoding
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___unicodeEncoding_1;
// System.Text.Encoding modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.Encoding::bigEndianUnicode
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___bigEndianUnicode_2;
// System.Text.Encoding modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.Encoding::utf7Encoding
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___utf7Encoding_3;
// System.Text.Encoding modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.Encoding::utf8Encoding
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___utf8Encoding_4;
// System.Text.Encoding modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.Encoding::utf32Encoding
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___utf32Encoding_5;
// System.Text.Encoding modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.Encoding::asciiEncoding
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___asciiEncoding_6;
// System.Text.Encoding modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.Encoding::latin1Encoding
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___latin1Encoding_7;
// System.Collections.Hashtable modreq(System.Runtime.CompilerServices.IsVolatile) System.Text.Encoding::encodings
Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC * ___encodings_8;
// System.Object System.Text.Encoding::s_InternalSyncObject
RuntimeObject * ___s_InternalSyncObject_15;
public:
inline static int32_t get_offset_of_defaultEncoding_0() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___defaultEncoding_0)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_defaultEncoding_0() const { return ___defaultEncoding_0; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_defaultEncoding_0() { return &___defaultEncoding_0; }
inline void set_defaultEncoding_0(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___defaultEncoding_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___defaultEncoding_0), (void*)value);
}
inline static int32_t get_offset_of_unicodeEncoding_1() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___unicodeEncoding_1)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_unicodeEncoding_1() const { return ___unicodeEncoding_1; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_unicodeEncoding_1() { return &___unicodeEncoding_1; }
inline void set_unicodeEncoding_1(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___unicodeEncoding_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___unicodeEncoding_1), (void*)value);
}
inline static int32_t get_offset_of_bigEndianUnicode_2() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___bigEndianUnicode_2)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_bigEndianUnicode_2() const { return ___bigEndianUnicode_2; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_bigEndianUnicode_2() { return &___bigEndianUnicode_2; }
inline void set_bigEndianUnicode_2(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___bigEndianUnicode_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___bigEndianUnicode_2), (void*)value);
}
inline static int32_t get_offset_of_utf7Encoding_3() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___utf7Encoding_3)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_utf7Encoding_3() const { return ___utf7Encoding_3; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_utf7Encoding_3() { return &___utf7Encoding_3; }
inline void set_utf7Encoding_3(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___utf7Encoding_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___utf7Encoding_3), (void*)value);
}
inline static int32_t get_offset_of_utf8Encoding_4() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___utf8Encoding_4)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_utf8Encoding_4() const { return ___utf8Encoding_4; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_utf8Encoding_4() { return &___utf8Encoding_4; }
inline void set_utf8Encoding_4(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___utf8Encoding_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___utf8Encoding_4), (void*)value);
}
inline static int32_t get_offset_of_utf32Encoding_5() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___utf32Encoding_5)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_utf32Encoding_5() const { return ___utf32Encoding_5; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_utf32Encoding_5() { return &___utf32Encoding_5; }
inline void set_utf32Encoding_5(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___utf32Encoding_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___utf32Encoding_5), (void*)value);
}
inline static int32_t get_offset_of_asciiEncoding_6() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___asciiEncoding_6)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_asciiEncoding_6() const { return ___asciiEncoding_6; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_asciiEncoding_6() { return &___asciiEncoding_6; }
inline void set_asciiEncoding_6(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___asciiEncoding_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___asciiEncoding_6), (void*)value);
}
inline static int32_t get_offset_of_latin1Encoding_7() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___latin1Encoding_7)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_latin1Encoding_7() const { return ___latin1Encoding_7; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_latin1Encoding_7() { return &___latin1Encoding_7; }
inline void set_latin1Encoding_7(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___latin1Encoding_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___latin1Encoding_7), (void*)value);
}
inline static int32_t get_offset_of_encodings_8() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___encodings_8)); }
inline Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC * get_encodings_8() const { return ___encodings_8; }
inline Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC ** get_address_of_encodings_8() { return &___encodings_8; }
inline void set_encodings_8(Hashtable_t7565AB92A12227AD5BADD6911F10D87EE52509AC * value)
{
___encodings_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___encodings_8), (void*)value);
}
inline static int32_t get_offset_of_s_InternalSyncObject_15() { return static_cast<int32_t>(offsetof(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827_StaticFields, ___s_InternalSyncObject_15)); }
inline RuntimeObject * get_s_InternalSyncObject_15() const { return ___s_InternalSyncObject_15; }
inline RuntimeObject ** get_address_of_s_InternalSyncObject_15() { return &___s_InternalSyncObject_15; }
inline void set_s_InternalSyncObject_15(RuntimeObject * value)
{
___s_InternalSyncObject_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_InternalSyncObject_15), (void*)value);
}
};
// System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52 : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52_marshaled_com
{
};
// UnityEngine.Events.UnityEventBase
struct UnityEventBase_tBB43047292084BA63C5CBB1A379A8BB88611C6FB : public RuntimeObject
{
public:
// UnityEngine.Events.InvokableCallList UnityEngine.Events.UnityEventBase::m_Calls
InvokableCallList_tB7C66AA0C00F9C102C8BDC17A144E569AC7527A9 * ___m_Calls_0;
// UnityEngine.Events.PersistentCallGroup UnityEngine.Events.UnityEventBase::m_PersistentCalls
PersistentCallGroup_t9A1D83DA2BA3118C103FA87D93CE92557A956FDC * ___m_PersistentCalls_1;
// System.Boolean UnityEngine.Events.UnityEventBase::m_CallsDirty
bool ___m_CallsDirty_2;
public:
inline static int32_t get_offset_of_m_Calls_0() { return static_cast<int32_t>(offsetof(UnityEventBase_tBB43047292084BA63C5CBB1A379A8BB88611C6FB, ___m_Calls_0)); }
inline InvokableCallList_tB7C66AA0C00F9C102C8BDC17A144E569AC7527A9 * get_m_Calls_0() const { return ___m_Calls_0; }
inline InvokableCallList_tB7C66AA0C00F9C102C8BDC17A144E569AC7527A9 ** get_address_of_m_Calls_0() { return &___m_Calls_0; }
inline void set_m_Calls_0(InvokableCallList_tB7C66AA0C00F9C102C8BDC17A144E569AC7527A9 * value)
{
___m_Calls_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Calls_0), (void*)value);
}
inline static int32_t get_offset_of_m_PersistentCalls_1() { return static_cast<int32_t>(offsetof(UnityEventBase_tBB43047292084BA63C5CBB1A379A8BB88611C6FB, ___m_PersistentCalls_1)); }
inline PersistentCallGroup_t9A1D83DA2BA3118C103FA87D93CE92557A956FDC * get_m_PersistentCalls_1() const { return ___m_PersistentCalls_1; }
inline PersistentCallGroup_t9A1D83DA2BA3118C103FA87D93CE92557A956FDC ** get_address_of_m_PersistentCalls_1() { return &___m_PersistentCalls_1; }
inline void set_m_PersistentCalls_1(PersistentCallGroup_t9A1D83DA2BA3118C103FA87D93CE92557A956FDC * value)
{
___m_PersistentCalls_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_PersistentCalls_1), (void*)value);
}
inline static int32_t get_offset_of_m_CallsDirty_2() { return static_cast<int32_t>(offsetof(UnityEventBase_tBB43047292084BA63C5CBB1A379A8BB88611C6FB, ___m_CallsDirty_2)); }
inline bool get_m_CallsDirty_2() const { return ___m_CallsDirty_2; }
inline bool* get_address_of_m_CallsDirty_2() { return &___m_CallsDirty_2; }
inline void set_m_CallsDirty_2(bool value)
{
___m_CallsDirty_2 = value;
}
};
// UnityEngine.Networking.PlayerConnection.MessageEventArgs
struct MessageEventArgs_t6905F6AA12A37C5A38BBCB907E9215622364DCCA : public RuntimeObject
{
public:
// System.Int32 UnityEngine.Networking.PlayerConnection.MessageEventArgs::playerId
int32_t ___playerId_0;
// System.Byte[] UnityEngine.Networking.PlayerConnection.MessageEventArgs::data
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___data_1;
public:
inline static int32_t get_offset_of_playerId_0() { return static_cast<int32_t>(offsetof(MessageEventArgs_t6905F6AA12A37C5A38BBCB907E9215622364DCCA, ___playerId_0)); }
inline int32_t get_playerId_0() const { return ___playerId_0; }
inline int32_t* get_address_of_playerId_0() { return &___playerId_0; }
inline void set_playerId_0(int32_t value)
{
___playerId_0 = value;
}
inline static int32_t get_offset_of_data_1() { return static_cast<int32_t>(offsetof(MessageEventArgs_t6905F6AA12A37C5A38BBCB907E9215622364DCCA, ___data_1)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_data_1() const { return ___data_1; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_data_1() { return &___data_1; }
inline void set_data_1(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___data_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___data_1), (void*)value);
}
};
// UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass20_0
struct U3CU3Ec__DisplayClass20_0_tEA47E236E3FCEC75772DAF52911B35E8F14766DD : public RuntimeObject
{
public:
// System.Boolean UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass20_0::msgReceived
bool ___msgReceived_0;
public:
inline static int32_t get_offset_of_msgReceived_0() { return static_cast<int32_t>(offsetof(U3CU3Ec__DisplayClass20_0_tEA47E236E3FCEC75772DAF52911B35E8F14766DD, ___msgReceived_0)); }
inline bool get_msgReceived_0() const { return ___msgReceived_0; }
inline bool* get_address_of_msgReceived_0() { return &___msgReceived_0; }
inline void set_msgReceived_0(bool value)
{
___msgReceived_0 = value;
}
};
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers
struct MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F : public RuntimeObject
{
public:
// System.String UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers::m_messageTypeId
String_t* ___m_messageTypeId_0;
// System.Int32 UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers::subscriberCount
int32_t ___subscriberCount_1;
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageEvent UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers::messageCallback
MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B * ___messageCallback_2;
public:
inline static int32_t get_offset_of_m_messageTypeId_0() { return static_cast<int32_t>(offsetof(MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F, ___m_messageTypeId_0)); }
inline String_t* get_m_messageTypeId_0() const { return ___m_messageTypeId_0; }
inline String_t** get_address_of_m_messageTypeId_0() { return &___m_messageTypeId_0; }
inline void set_m_messageTypeId_0(String_t* value)
{
___m_messageTypeId_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_messageTypeId_0), (void*)value);
}
inline static int32_t get_offset_of_subscriberCount_1() { return static_cast<int32_t>(offsetof(MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F, ___subscriberCount_1)); }
inline int32_t get_subscriberCount_1() const { return ___subscriberCount_1; }
inline int32_t* get_address_of_subscriberCount_1() { return &___subscriberCount_1; }
inline void set_subscriberCount_1(int32_t value)
{
___subscriberCount_1 = value;
}
inline static int32_t get_offset_of_messageCallback_2() { return static_cast<int32_t>(offsetof(MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F, ___messageCallback_2)); }
inline MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B * get_messageCallback_2() const { return ___messageCallback_2; }
inline MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B ** get_address_of_messageCallback_2() { return &___messageCallback_2; }
inline void set_messageCallback_2(MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B * value)
{
___messageCallback_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___messageCallback_2), (void*)value);
}
};
// UnityEngine.TextAsset_EncodingUtility
struct EncodingUtility_tF25232B383AA56BB15E7955C1C9FC356F9770983 : public RuntimeObject
{
public:
public:
};
struct EncodingUtility_tF25232B383AA56BB15E7955C1C9FC356F9770983_StaticFields
{
public:
// System.Collections.Generic.KeyValuePair`2<System.Byte[],System.Text.Encoding>[] UnityEngine.TextAsset_EncodingUtility::encodingLookup
KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7* ___encodingLookup_0;
// System.Text.Encoding UnityEngine.TextAsset_EncodingUtility::targetEncoding
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___targetEncoding_1;
public:
inline static int32_t get_offset_of_encodingLookup_0() { return static_cast<int32_t>(offsetof(EncodingUtility_tF25232B383AA56BB15E7955C1C9FC356F9770983_StaticFields, ___encodingLookup_0)); }
inline KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7* get_encodingLookup_0() const { return ___encodingLookup_0; }
inline KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7** get_address_of_encodingLookup_0() { return &___encodingLookup_0; }
inline void set_encodingLookup_0(KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7* value)
{
___encodingLookup_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___encodingLookup_0), (void*)value);
}
inline static int32_t get_offset_of_targetEncoding_1() { return static_cast<int32_t>(offsetof(EncodingUtility_tF25232B383AA56BB15E7955C1C9FC356F9770983_StaticFields, ___targetEncoding_1)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_targetEncoding_1() const { return ___targetEncoding_1; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_targetEncoding_1() { return &___targetEncoding_1; }
inline void set_targetEncoding_1(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___targetEncoding_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___targetEncoding_1), (void*)value);
}
};
// UnityEngine.Transform_Enumerator
struct Enumerator_t8A0B2200373BC9628C065322A1BA07AAA47E0259 : public RuntimeObject
{
public:
// UnityEngine.Transform UnityEngine.Transform_Enumerator::outer
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * ___outer_0;
// System.Int32 UnityEngine.Transform_Enumerator::currentIndex
int32_t ___currentIndex_1;
public:
inline static int32_t get_offset_of_outer_0() { return static_cast<int32_t>(offsetof(Enumerator_t8A0B2200373BC9628C065322A1BA07AAA47E0259, ___outer_0)); }
inline Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * get_outer_0() const { return ___outer_0; }
inline Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 ** get_address_of_outer_0() { return &___outer_0; }
inline void set_outer_0(Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * value)
{
___outer_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___outer_0), (void*)value);
}
inline static int32_t get_offset_of_currentIndex_1() { return static_cast<int32_t>(offsetof(Enumerator_t8A0B2200373BC9628C065322A1BA07AAA47E0259, ___currentIndex_1)); }
inline int32_t get_currentIndex_1() const { return ___currentIndex_1; }
inline int32_t* get_address_of_currentIndex_1() { return &___currentIndex_1; }
inline void set_currentIndex_1(int32_t value)
{
___currentIndex_1 = value;
}
};
// UnityEngine.UnhandledExceptionHandler_<>c
struct U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF : public RuntimeObject
{
public:
public:
};
struct U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF_StaticFields
{
public:
// UnityEngine.UnhandledExceptionHandler_<>c UnityEngine.UnhandledExceptionHandler_<>c::<>9
U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF * ___U3CU3E9_0;
// System.UnhandledExceptionEventHandler UnityEngine.UnhandledExceptionHandler_<>c::<>9__0_0
UnhandledExceptionEventHandler_t1DF125A860ED9B70F24ADFA6CB0781533A23DA64 * ___U3CU3E9__0_0_1;
public:
inline static int32_t get_offset_of_U3CU3E9_0() { return static_cast<int32_t>(offsetof(U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF_StaticFields, ___U3CU3E9_0)); }
inline U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF * get_U3CU3E9_0() const { return ___U3CU3E9_0; }
inline U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF ** get_address_of_U3CU3E9_0() { return &___U3CU3E9_0; }
inline void set_U3CU3E9_0(U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF * value)
{
___U3CU3E9_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CU3E9_0), (void*)value);
}
inline static int32_t get_offset_of_U3CU3E9__0_0_1() { return static_cast<int32_t>(offsetof(U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF_StaticFields, ___U3CU3E9__0_0_1)); }
inline UnhandledExceptionEventHandler_t1DF125A860ED9B70F24ADFA6CB0781533A23DA64 * get_U3CU3E9__0_0_1() const { return ___U3CU3E9__0_0_1; }
inline UnhandledExceptionEventHandler_t1DF125A860ED9B70F24ADFA6CB0781533A23DA64 ** get_address_of_U3CU3E9__0_0_1() { return &___U3CU3E9__0_0_1; }
inline void set_U3CU3E9__0_0_1(UnhandledExceptionEventHandler_t1DF125A860ED9B70F24ADFA6CB0781533A23DA64 * value)
{
___U3CU3E9__0_0_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CU3E9__0_0_1), (void*)value);
}
};
// System.Boolean
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TrueString_5), (void*)value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_t07D1E3F34E4813023D64F584DFF7B34C9D922F37_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FalseString_6), (void*)value);
}
};
// System.Byte
struct Byte_t0111FAB8B8685667EDDAF77683F0D8F86B659056
{
public:
// System.Byte System.Byte::m_value
uint8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Byte_t0111FAB8B8685667EDDAF77683F0D8F86B659056, ___m_value_0)); }
inline uint8_t get_m_value_0() const { return ___m_value_0; }
inline uint8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint8_t value)
{
___m_value_0 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Byte[],System.Text.Encoding>
struct KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B, ___key_0)); }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* get_key_0() const { return ___key_0; }
inline ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B, ___value_1)); }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * get_value_1() const { return ___value_1; }
inline Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>
struct KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.DateTime
struct DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405
{
public:
// System.UInt64 System.DateTime::dateData
uint64_t ___dateData_44;
public:
inline static int32_t get_offset_of_dateData_44() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405, ___dateData_44)); }
inline uint64_t get_dateData_44() const { return ___dateData_44; }
inline uint64_t* get_address_of_dateData_44() { return &___dateData_44; }
inline void set_dateData_44(uint64_t value)
{
___dateData_44 = value;
}
};
struct DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields
{
public:
// System.Int32[] System.DateTime::DaysToMonth365
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___DaysToMonth365_29;
// System.Int32[] System.DateTime::DaysToMonth366
Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* ___DaysToMonth366_30;
// System.DateTime System.DateTime::MinValue
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___MinValue_31;
// System.DateTime System.DateTime::MaxValue
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___MaxValue_32;
public:
inline static int32_t get_offset_of_DaysToMonth365_29() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___DaysToMonth365_29)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_DaysToMonth365_29() const { return ___DaysToMonth365_29; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_DaysToMonth365_29() { return &___DaysToMonth365_29; }
inline void set_DaysToMonth365_29(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___DaysToMonth365_29 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth365_29), (void*)value);
}
inline static int32_t get_offset_of_DaysToMonth366_30() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___DaysToMonth366_30)); }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* get_DaysToMonth366_30() const { return ___DaysToMonth366_30; }
inline Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32** get_address_of_DaysToMonth366_30() { return &___DaysToMonth366_30; }
inline void set_DaysToMonth366_30(Int32U5BU5D_t70F1BDC14B1786481B176D6139A5E3B87DC54C32* value)
{
___DaysToMonth366_30 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth366_30), (void*)value);
}
inline static int32_t get_offset_of_MinValue_31() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___MinValue_31)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_MinValue_31() const { return ___MinValue_31; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_MinValue_31() { return &___MinValue_31; }
inline void set_MinValue_31(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___MinValue_31 = value;
}
inline static int32_t get_offset_of_MaxValue_32() { return static_cast<int32_t>(offsetof(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405_StaticFields, ___MaxValue_32)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_MaxValue_32() const { return ___MaxValue_32; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_MaxValue_32() { return &___MaxValue_32; }
inline void set_MaxValue_32(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___MaxValue_32 = value;
}
};
// System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA : public ValueType_tDBF999C1B75C48C68621878250DBF6CDBCF51E52
{
public:
public:
};
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t23B90B40F60E677A8025267341651C94AE079CDA_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t7B7FC5BC8091AA3B9CB0B29CDD80B5EE9254AA34* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___enumSeperatorCharArray_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t23B90B40F60E677A8025267341651C94AE079CDA_marshaled_com
{
};
// System.Guid
struct Guid_t
{
public:
// System.Int32 System.Guid::_a
int32_t ____a_1;
// System.Int16 System.Guid::_b
int16_t ____b_2;
// System.Int16 System.Guid::_c
int16_t ____c_3;
// System.Byte System.Guid::_d
uint8_t ____d_4;
// System.Byte System.Guid::_e
uint8_t ____e_5;
// System.Byte System.Guid::_f
uint8_t ____f_6;
// System.Byte System.Guid::_g
uint8_t ____g_7;
// System.Byte System.Guid::_h
uint8_t ____h_8;
// System.Byte System.Guid::_i
uint8_t ____i_9;
// System.Byte System.Guid::_j
uint8_t ____j_10;
// System.Byte System.Guid::_k
uint8_t ____k_11;
public:
inline static int32_t get_offset_of__a_1() { return static_cast<int32_t>(offsetof(Guid_t, ____a_1)); }
inline int32_t get__a_1() const { return ____a_1; }
inline int32_t* get_address_of__a_1() { return &____a_1; }
inline void set__a_1(int32_t value)
{
____a_1 = value;
}
inline static int32_t get_offset_of__b_2() { return static_cast<int32_t>(offsetof(Guid_t, ____b_2)); }
inline int16_t get__b_2() const { return ____b_2; }
inline int16_t* get_address_of__b_2() { return &____b_2; }
inline void set__b_2(int16_t value)
{
____b_2 = value;
}
inline static int32_t get_offset_of__c_3() { return static_cast<int32_t>(offsetof(Guid_t, ____c_3)); }
inline int16_t get__c_3() const { return ____c_3; }
inline int16_t* get_address_of__c_3() { return &____c_3; }
inline void set__c_3(int16_t value)
{
____c_3 = value;
}
inline static int32_t get_offset_of__d_4() { return static_cast<int32_t>(offsetof(Guid_t, ____d_4)); }
inline uint8_t get__d_4() const { return ____d_4; }
inline uint8_t* get_address_of__d_4() { return &____d_4; }
inline void set__d_4(uint8_t value)
{
____d_4 = value;
}
inline static int32_t get_offset_of__e_5() { return static_cast<int32_t>(offsetof(Guid_t, ____e_5)); }
inline uint8_t get__e_5() const { return ____e_5; }
inline uint8_t* get_address_of__e_5() { return &____e_5; }
inline void set__e_5(uint8_t value)
{
____e_5 = value;
}
inline static int32_t get_offset_of__f_6() { return static_cast<int32_t>(offsetof(Guid_t, ____f_6)); }
inline uint8_t get__f_6() const { return ____f_6; }
inline uint8_t* get_address_of__f_6() { return &____f_6; }
inline void set__f_6(uint8_t value)
{
____f_6 = value;
}
inline static int32_t get_offset_of__g_7() { return static_cast<int32_t>(offsetof(Guid_t, ____g_7)); }
inline uint8_t get__g_7() const { return ____g_7; }
inline uint8_t* get_address_of__g_7() { return &____g_7; }
inline void set__g_7(uint8_t value)
{
____g_7 = value;
}
inline static int32_t get_offset_of__h_8() { return static_cast<int32_t>(offsetof(Guid_t, ____h_8)); }
inline uint8_t get__h_8() const { return ____h_8; }
inline uint8_t* get_address_of__h_8() { return &____h_8; }
inline void set__h_8(uint8_t value)
{
____h_8 = value;
}
inline static int32_t get_offset_of__i_9() { return static_cast<int32_t>(offsetof(Guid_t, ____i_9)); }
inline uint8_t get__i_9() const { return ____i_9; }
inline uint8_t* get_address_of__i_9() { return &____i_9; }
inline void set__i_9(uint8_t value)
{
____i_9 = value;
}
inline static int32_t get_offset_of__j_10() { return static_cast<int32_t>(offsetof(Guid_t, ____j_10)); }
inline uint8_t get__j_10() const { return ____j_10; }
inline uint8_t* get_address_of__j_10() { return &____j_10; }
inline void set__j_10(uint8_t value)
{
____j_10 = value;
}
inline static int32_t get_offset_of__k_11() { return static_cast<int32_t>(offsetof(Guid_t, ____k_11)); }
inline uint8_t get__k_11() const { return ____k_11; }
inline uint8_t* get_address_of__k_11() { return &____k_11; }
inline void set__k_11(uint8_t value)
{
____k_11 = value;
}
};
struct Guid_t_StaticFields
{
public:
// System.Guid System.Guid::Empty
Guid_t ___Empty_0;
// System.Object System.Guid::_rngAccess
RuntimeObject * ____rngAccess_12;
// System.Security.Cryptography.RandomNumberGenerator System.Guid::_rng
RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * ____rng_13;
// System.Security.Cryptography.RandomNumberGenerator System.Guid::_fastRng
RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * ____fastRng_14;
public:
inline static int32_t get_offset_of_Empty_0() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ___Empty_0)); }
inline Guid_t get_Empty_0() const { return ___Empty_0; }
inline Guid_t * get_address_of_Empty_0() { return &___Empty_0; }
inline void set_Empty_0(Guid_t value)
{
___Empty_0 = value;
}
inline static int32_t get_offset_of__rngAccess_12() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____rngAccess_12)); }
inline RuntimeObject * get__rngAccess_12() const { return ____rngAccess_12; }
inline RuntimeObject ** get_address_of__rngAccess_12() { return &____rngAccess_12; }
inline void set__rngAccess_12(RuntimeObject * value)
{
____rngAccess_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rngAccess_12), (void*)value);
}
inline static int32_t get_offset_of__rng_13() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____rng_13)); }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * get__rng_13() const { return ____rng_13; }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 ** get_address_of__rng_13() { return &____rng_13; }
inline void set__rng_13(RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * value)
{
____rng_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rng_13), (void*)value);
}
inline static int32_t get_offset_of__fastRng_14() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____fastRng_14)); }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * get__fastRng_14() const { return ____fastRng_14; }
inline RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 ** get_address_of__fastRng_14() { return &____fastRng_14; }
inline void set__fastRng_14(RandomNumberGenerator_t2CB5440F189986116A2FA9F907AE52644047AC50 * value)
{
____fastRng_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&____fastRng_14), (void*)value);
}
};
// System.Int32
struct Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046
{
public:
// System.Int32 System.Int32::m_value
int32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int32_tFDE5F8CD43D10453F6A2E0C77FE48C6CC7009046, ___m_value_0)); }
inline int32_t get_m_value_0() const { return ___m_value_0; }
inline int32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int32_t value)
{
___m_value_0 = value;
}
};
// System.IntPtr
struct IntPtr_t
{
public:
// System.Void* System.IntPtr::m_value
void* ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
inline void* get_m_value_0() const { return ___m_value_0; }
inline void** get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(void* value)
{
___m_value_0 = value;
}
};
struct IntPtr_t_StaticFields
{
public:
// System.IntPtr System.IntPtr::Zero
intptr_t ___Zero_1;
public:
inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
inline intptr_t get_Zero_1() const { return ___Zero_1; }
inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
inline void set_Zero_1(intptr_t value)
{
___Zero_1 = value;
}
};
// System.Text.DecoderReplacementFallback
struct DecoderReplacementFallback_t8DA345EC4EF3A35A2667365F691EE69408A62130 : public DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D
{
public:
// System.String System.Text.DecoderReplacementFallback::strDefault
String_t* ___strDefault_4;
public:
inline static int32_t get_offset_of_strDefault_4() { return static_cast<int32_t>(offsetof(DecoderReplacementFallback_t8DA345EC4EF3A35A2667365F691EE69408A62130, ___strDefault_4)); }
inline String_t* get_strDefault_4() const { return ___strDefault_4; }
inline String_t** get_address_of_strDefault_4() { return &___strDefault_4; }
inline void set_strDefault_4(String_t* value)
{
___strDefault_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___strDefault_4), (void*)value);
}
};
// System.Text.EncoderReplacementFallback
struct EncoderReplacementFallback_t61E36A507D7FA8034B49F86DBE560EC77A6A8418 : public EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4
{
public:
// System.String System.Text.EncoderReplacementFallback::strDefault
String_t* ___strDefault_4;
public:
inline static int32_t get_offset_of_strDefault_4() { return static_cast<int32_t>(offsetof(EncoderReplacementFallback_t61E36A507D7FA8034B49F86DBE560EC77A6A8418, ___strDefault_4)); }
inline String_t* get_strDefault_4() const { return ___strDefault_4; }
inline String_t** get_address_of_strDefault_4() { return &___strDefault_4; }
inline void set_strDefault_4(String_t* value)
{
___strDefault_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___strDefault_4), (void*)value);
}
};
// System.Text.UTF32Encoding
struct UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014 : public Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827
{
public:
// System.Boolean System.Text.UTF32Encoding::emitUTF32ByteOrderMark
bool ___emitUTF32ByteOrderMark_16;
// System.Boolean System.Text.UTF32Encoding::isThrowException
bool ___isThrowException_17;
// System.Boolean System.Text.UTF32Encoding::bigEndian
bool ___bigEndian_18;
public:
inline static int32_t get_offset_of_emitUTF32ByteOrderMark_16() { return static_cast<int32_t>(offsetof(UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014, ___emitUTF32ByteOrderMark_16)); }
inline bool get_emitUTF32ByteOrderMark_16() const { return ___emitUTF32ByteOrderMark_16; }
inline bool* get_address_of_emitUTF32ByteOrderMark_16() { return &___emitUTF32ByteOrderMark_16; }
inline void set_emitUTF32ByteOrderMark_16(bool value)
{
___emitUTF32ByteOrderMark_16 = value;
}
inline static int32_t get_offset_of_isThrowException_17() { return static_cast<int32_t>(offsetof(UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014, ___isThrowException_17)); }
inline bool get_isThrowException_17() const { return ___isThrowException_17; }
inline bool* get_address_of_isThrowException_17() { return &___isThrowException_17; }
inline void set_isThrowException_17(bool value)
{
___isThrowException_17 = value;
}
inline static int32_t get_offset_of_bigEndian_18() { return static_cast<int32_t>(offsetof(UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014, ___bigEndian_18)); }
inline bool get_bigEndian_18() const { return ___bigEndian_18; }
inline bool* get_address_of_bigEndian_18() { return &___bigEndian_18; }
inline void set_bigEndian_18(bool value)
{
___bigEndian_18 = value;
}
};
// System.Text.UTF8Encoding
struct UTF8Encoding_t6EE88BC62116B5328F6CF4E39C9CC49EED2ED282 : public Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827
{
public:
// System.Boolean System.Text.UTF8Encoding::emitUTF8Identifier
bool ___emitUTF8Identifier_16;
// System.Boolean System.Text.UTF8Encoding::isThrowException
bool ___isThrowException_17;
public:
inline static int32_t get_offset_of_emitUTF8Identifier_16() { return static_cast<int32_t>(offsetof(UTF8Encoding_t6EE88BC62116B5328F6CF4E39C9CC49EED2ED282, ___emitUTF8Identifier_16)); }
inline bool get_emitUTF8Identifier_16() const { return ___emitUTF8Identifier_16; }
inline bool* get_address_of_emitUTF8Identifier_16() { return &___emitUTF8Identifier_16; }
inline void set_emitUTF8Identifier_16(bool value)
{
___emitUTF8Identifier_16 = value;
}
inline static int32_t get_offset_of_isThrowException_17() { return static_cast<int32_t>(offsetof(UTF8Encoding_t6EE88BC62116B5328F6CF4E39C9CC49EED2ED282, ___isThrowException_17)); }
inline bool get_isThrowException_17() const { return ___isThrowException_17; }
inline bool* get_address_of_isThrowException_17() { return &___isThrowException_17; }
inline void set_isThrowException_17(bool value)
{
___isThrowException_17 = value;
}
};
// System.Text.UnicodeEncoding
struct UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68 : public Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827
{
public:
// System.Boolean System.Text.UnicodeEncoding::isThrowException
bool ___isThrowException_16;
// System.Boolean System.Text.UnicodeEncoding::bigEndian
bool ___bigEndian_17;
// System.Boolean System.Text.UnicodeEncoding::byteOrderMark
bool ___byteOrderMark_18;
public:
inline static int32_t get_offset_of_isThrowException_16() { return static_cast<int32_t>(offsetof(UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68, ___isThrowException_16)); }
inline bool get_isThrowException_16() const { return ___isThrowException_16; }
inline bool* get_address_of_isThrowException_16() { return &___isThrowException_16; }
inline void set_isThrowException_16(bool value)
{
___isThrowException_16 = value;
}
inline static int32_t get_offset_of_bigEndian_17() { return static_cast<int32_t>(offsetof(UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68, ___bigEndian_17)); }
inline bool get_bigEndian_17() const { return ___bigEndian_17; }
inline bool* get_address_of_bigEndian_17() { return &___bigEndian_17; }
inline void set_bigEndian_17(bool value)
{
___bigEndian_17 = value;
}
inline static int32_t get_offset_of_byteOrderMark_18() { return static_cast<int32_t>(offsetof(UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68, ___byteOrderMark_18)); }
inline bool get_byteOrderMark_18() const { return ___byteOrderMark_18; }
inline bool* get_address_of_byteOrderMark_18() { return &___byteOrderMark_18; }
inline void set_byteOrderMark_18(bool value)
{
___byteOrderMark_18 = value;
}
};
struct UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68_StaticFields
{
public:
// System.UInt64 System.Text.UnicodeEncoding::highLowPatternMask
uint64_t ___highLowPatternMask_19;
public:
inline static int32_t get_offset_of_highLowPatternMask_19() { return static_cast<int32_t>(offsetof(UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68_StaticFields, ___highLowPatternMask_19)); }
inline uint64_t get_highLowPatternMask_19() const { return ___highLowPatternMask_19; }
inline uint64_t* get_address_of_highLowPatternMask_19() { return &___highLowPatternMask_19; }
inline void set_highLowPatternMask_19(uint64_t value)
{
___highLowPatternMask_19 = value;
}
};
// System.UnhandledExceptionEventArgs
struct UnhandledExceptionEventArgs_tFA66D5AA8F6337DEF8E2B494B3B8C377C9FDB885 : public EventArgs_tBCAACA538A5195B6D6C8DFCC3524A2A4A67FD8BA
{
public:
// System.Object System.UnhandledExceptionEventArgs::_Exception
RuntimeObject * ____Exception_1;
// System.Boolean System.UnhandledExceptionEventArgs::_IsTerminating
bool ____IsTerminating_2;
public:
inline static int32_t get_offset_of__Exception_1() { return static_cast<int32_t>(offsetof(UnhandledExceptionEventArgs_tFA66D5AA8F6337DEF8E2B494B3B8C377C9FDB885, ____Exception_1)); }
inline RuntimeObject * get__Exception_1() const { return ____Exception_1; }
inline RuntimeObject ** get_address_of__Exception_1() { return &____Exception_1; }
inline void set__Exception_1(RuntimeObject * value)
{
____Exception_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____Exception_1), (void*)value);
}
inline static int32_t get_offset_of__IsTerminating_2() { return static_cast<int32_t>(offsetof(UnhandledExceptionEventArgs_tFA66D5AA8F6337DEF8E2B494B3B8C377C9FDB885, ____IsTerminating_2)); }
inline bool get__IsTerminating_2() const { return ____IsTerminating_2; }
inline bool* get_address_of__IsTerminating_2() { return &____IsTerminating_2; }
inline void set__IsTerminating_2(bool value)
{
____IsTerminating_2 = value;
}
};
// System.Void
struct Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5
{
public:
union
{
struct
{
};
uint8_t Void_t700C6383A2A510C2CF4DD86DABD5CA9FF70ADAC5__padding[1];
};
public:
};
// UnityEngine.Events.UnityEvent`1<System.Int32>
struct UnityEvent_1_tB235B5DAD099AC425DC059D10DEB8B97A35E2BBF : public UnityEventBase_tBB43047292084BA63C5CBB1A379A8BB88611C6FB
{
public:
// System.Object[] UnityEngine.Events.UnityEvent`1::m_InvokeArray
ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* ___m_InvokeArray_3;
public:
inline static int32_t get_offset_of_m_InvokeArray_3() { return static_cast<int32_t>(offsetof(UnityEvent_1_tB235B5DAD099AC425DC059D10DEB8B97A35E2BBF, ___m_InvokeArray_3)); }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* get_m_InvokeArray_3() const { return ___m_InvokeArray_3; }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE** get_address_of_m_InvokeArray_3() { return &___m_InvokeArray_3; }
inline void set_m_InvokeArray_3(ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* value)
{
___m_InvokeArray_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_InvokeArray_3), (void*)value);
}
};
// UnityEngine.Events.UnityEvent`1<UnityEngine.Networking.PlayerConnection.MessageEventArgs>
struct UnityEvent_1_t5380899C55F3CD7FD1CD64F13EE5E1E4B11D602B : public UnityEventBase_tBB43047292084BA63C5CBB1A379A8BB88611C6FB
{
public:
// System.Object[] UnityEngine.Events.UnityEvent`1::m_InvokeArray
ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* ___m_InvokeArray_3;
public:
inline static int32_t get_offset_of_m_InvokeArray_3() { return static_cast<int32_t>(offsetof(UnityEvent_1_t5380899C55F3CD7FD1CD64F13EE5E1E4B11D602B, ___m_InvokeArray_3)); }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* get_m_InvokeArray_3() const { return ___m_InvokeArray_3; }
inline ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE** get_address_of_m_InvokeArray_3() { return &___m_InvokeArray_3; }
inline void set_m_InvokeArray_3(ObjectU5BU5D_tC1F4EE0DB0B7300255F5FD4AF64FE4C585CF5ADE* value)
{
___m_InvokeArray_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_InvokeArray_3), (void*)value);
}
};
// UnityEngine.PlayerLoop.PostLateUpdate_BatchModeUpdate
struct BatchModeUpdate_t8C6F527A5CA9A7A8E9CCCA61F2E99448C18AEAD2
{
public:
union
{
struct
{
};
uint8_t BatchModeUpdate_t8C6F527A5CA9A7A8E9CCCA61F2E99448C18AEAD2__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ClearImmediateRenderers
struct ClearImmediateRenderers_t37FCF798A50163FCAE31F618A88AA0928C40CAFB
{
public:
union
{
struct
{
};
uint8_t ClearImmediateRenderers_t37FCF798A50163FCAE31F618A88AA0928C40CAFB__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_DirectorLateUpdate
struct DirectorLateUpdate_t77313447CF25B5FBC7F6A738FC6B6FE4FB7D3B0E
{
public:
union
{
struct
{
};
uint8_t DirectorLateUpdate_t77313447CF25B5FBC7F6A738FC6B6FE4FB7D3B0E__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_DirectorRenderImage
struct DirectorRenderImage_t18FF15945AD4A75A4E38086E7E50F0839A6085B9
{
public:
union
{
struct
{
};
uint8_t DirectorRenderImage_t18FF15945AD4A75A4E38086E7E50F0839A6085B9__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_EndGraphicsJobsAfterScriptLateUpdate
struct EndGraphicsJobsAfterScriptLateUpdate_tE1D20D73472F346D7745C213712D90496E6E9350
{
public:
union
{
struct
{
};
uint8_t EndGraphicsJobsAfterScriptLateUpdate_tE1D20D73472F346D7745C213712D90496E6E9350__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_EnlightenRuntimeUpdate
struct EnlightenRuntimeUpdate_t0F7246E586E8744EBF22C6E557A5CDD79D42512F
{
public:
union
{
struct
{
};
uint8_t EnlightenRuntimeUpdate_t0F7246E586E8744EBF22C6E557A5CDD79D42512F__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ExecuteGameCenterCallbacks
struct ExecuteGameCenterCallbacks_t6AAA6429F53079FA5779EC93FF422C45F39B6A69
{
public:
union
{
struct
{
};
uint8_t ExecuteGameCenterCallbacks_t6AAA6429F53079FA5779EC93FF422C45F39B6A69__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_FinishFrameRendering
struct FinishFrameRendering_t6D8F987520D0CABFB634214E47EA6C98A1DE69F5
{
public:
union
{
struct
{
};
uint8_t FinishFrameRendering_t6D8F987520D0CABFB634214E47EA6C98A1DE69F5__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_GUIClearEvents
struct GUIClearEvents_t2ACF18A4B2C80DFB240DBE01D7B0B0751C3042ED
{
public:
union
{
struct
{
};
uint8_t GUIClearEvents_t2ACF18A4B2C80DFB240DBE01D7B0B0751C3042ED__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_InputEndFrame
struct InputEndFrame_t4E00F58665EC8A4AC407107E6AD65F8D9BE5D496
{
public:
union
{
struct
{
};
uint8_t InputEndFrame_t4E00F58665EC8A4AC407107E6AD65F8D9BE5D496__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_MemoryFrameMaintenance
struct MemoryFrameMaintenance_t8641D3964D8E591E9924C60B849CFC8E13781FCA
{
public:
union
{
struct
{
};
uint8_t MemoryFrameMaintenance_t8641D3964D8E591E9924C60B849CFC8E13781FCA__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ParticleSystemEndUpdateAll
struct ParticleSystemEndUpdateAll_t0C9862FC07BF69AEC1B23295BF70D3F4862D9DE8
{
public:
union
{
struct
{
};
uint8_t ParticleSystemEndUpdateAll_t0C9862FC07BF69AEC1B23295BF70D3F4862D9DE8__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_PhysicsSkinnedClothBeginUpdate
struct PhysicsSkinnedClothBeginUpdate_t23CEEF7DB8085BB3831A7670928EDD96A0BD36C1
{
public:
union
{
struct
{
};
uint8_t PhysicsSkinnedClothBeginUpdate_t23CEEF7DB8085BB3831A7670928EDD96A0BD36C1__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_PhysicsSkinnedClothFinishUpdate
struct PhysicsSkinnedClothFinishUpdate_tA2BC6F1632D750962DBB9A5331B880A3964D17C0
{
public:
union
{
struct
{
};
uint8_t PhysicsSkinnedClothFinishUpdate_tA2BC6F1632D750962DBB9A5331B880A3964D17C0__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_PlayerEmitCanvasGeometry
struct PlayerEmitCanvasGeometry_tD6837358BC1539ED3BFDA4A14DBA2634D21C7278
{
public:
union
{
struct
{
};
uint8_t PlayerEmitCanvasGeometry_tD6837358BC1539ED3BFDA4A14DBA2634D21C7278__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_PlayerSendFrameComplete
struct PlayerSendFrameComplete_tFCB4A131339039D456553596DC33CD625CFF7AAC
{
public:
union
{
struct
{
};
uint8_t PlayerSendFrameComplete_tFCB4A131339039D456553596DC33CD625CFF7AAC__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_PlayerSendFramePostPresent
struct PlayerSendFramePostPresent_t2F6B4A129327E35A001A0C0808FEFF20D1BAFCB6
{
public:
union
{
struct
{
};
uint8_t PlayerSendFramePostPresent_t2F6B4A129327E35A001A0C0808FEFF20D1BAFCB6__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_PlayerSendFrameStarted
struct PlayerSendFrameStarted_tBE2DDEEFF66EAD5BFC54776035F83F2BBFDC866A
{
public:
union
{
struct
{
};
uint8_t PlayerSendFrameStarted_tBE2DDEEFF66EAD5BFC54776035F83F2BBFDC866A__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_PlayerUpdateCanvases
struct PlayerUpdateCanvases_tA3BDD28A248E9294BBA8E93C53AF78B902A24CD4
{
public:
union
{
struct
{
};
uint8_t PlayerUpdateCanvases_tA3BDD28A248E9294BBA8E93C53AF78B902A24CD4__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_PresentAfterDraw
struct PresentAfterDraw_t26958AF5B43FD8A6101C88833BC41A0F5CE9830A
{
public:
union
{
struct
{
};
uint8_t PresentAfterDraw_t26958AF5B43FD8A6101C88833BC41A0F5CE9830A__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ProcessWebSendMessages
struct ProcessWebSendMessages_t5AD55E51AED08DA28C11DF31783B07C7A5128124
{
public:
union
{
struct
{
};
uint8_t ProcessWebSendMessages_t5AD55E51AED08DA28C11DF31783B07C7A5128124__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ProfilerEndFrame
struct ProfilerEndFrame_t9D91D2F297E099F92D03834C9FBFF860A8EF45DD
{
public:
union
{
struct
{
};
uint8_t ProfilerEndFrame_t9D91D2F297E099F92D03834C9FBFF860A8EF45DD__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ProfilerSynchronizeStats
struct ProfilerSynchronizeStats_t8B0F4436679D8BAF7D86793D207AD90477D601BB
{
public:
union
{
struct
{
};
uint8_t ProfilerSynchronizeStats_t8B0F4436679D8BAF7D86793D207AD90477D601BB__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ResetInputAxis
struct ResetInputAxis_t585B9BDCE262954A57C75B9492FCF7146662E21C
{
public:
union
{
struct
{
};
uint8_t ResetInputAxis_t585B9BDCE262954A57C75B9492FCF7146662E21C__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ScriptRunDelayedDynamicFrameRate
struct ScriptRunDelayedDynamicFrameRate_t6D962FA77CFBF776A2D946C07C567B795CF671B4
{
public:
union
{
struct
{
};
uint8_t ScriptRunDelayedDynamicFrameRate_t6D962FA77CFBF776A2D946C07C567B795CF671B4__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ShaderHandleErrors
struct ShaderHandleErrors_t2A99C9332EC9DE30DD16AF1FD18C582E5B02AE92
{
public:
union
{
struct
{
};
uint8_t ShaderHandleErrors_t2A99C9332EC9DE30DD16AF1FD18C582E5B02AE92__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_SortingGroupsUpdate
struct SortingGroupsUpdate_tBC21E7D8B383652646C08B9AE743A7EC38733CEF
{
public:
union
{
struct
{
};
uint8_t SortingGroupsUpdate_tBC21E7D8B383652646C08B9AE743A7EC38733CEF__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_ThreadedLoadingDebug
struct ThreadedLoadingDebug_t12597D128CC91C40B4C874800B0C3AEBF7DAD04B
{
public:
union
{
struct
{
};
uint8_t ThreadedLoadingDebug_t12597D128CC91C40B4C874800B0C3AEBF7DAD04B__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_TriggerEndOfFrameCallbacks
struct TriggerEndOfFrameCallbacks_tB5DD4CDE53AB8C30E72194AB21AFE73BFB4DC424
{
public:
union
{
struct
{
};
uint8_t TriggerEndOfFrameCallbacks_tB5DD4CDE53AB8C30E72194AB21AFE73BFB4DC424__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateAllRenderers
struct UpdateAllRenderers_t96FC2DF53BC1D90C7E40E2CAD10B8C674A94B86C
{
public:
union
{
struct
{
};
uint8_t UpdateAllRenderers_t96FC2DF53BC1D90C7E40E2CAD10B8C674A94B86C__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateAllSkinnedMeshes
struct UpdateAllSkinnedMeshes_tC6792E38655DE2113814AC6A642B3D937D6640F6
{
public:
union
{
struct
{
};
uint8_t UpdateAllSkinnedMeshes_tC6792E38655DE2113814AC6A642B3D937D6640F6__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateAudio
struct UpdateAudio_t87394777AB6FE384B45C0C013722C1F68A60CF58
{
public:
union
{
struct
{
};
uint8_t UpdateAudio_t87394777AB6FE384B45C0C013722C1F68A60CF58__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateCanvasRectTransform
struct UpdateCanvasRectTransform_t4E5EA2B18FCFD686E1F2052517657E391709422A
{
public:
union
{
struct
{
};
uint8_t UpdateCanvasRectTransform_t4E5EA2B18FCFD686E1F2052517657E391709422A__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateCaptureScreenshot
struct UpdateCaptureScreenshot_t4FC86A971BE4E341EE83B9BCF72D3642CB67E483
{
public:
union
{
struct
{
};
uint8_t UpdateCaptureScreenshot_t4FC86A971BE4E341EE83B9BCF72D3642CB67E483__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateCustomRenderTextures
struct UpdateCustomRenderTextures_t52B541FA5A7354ED440E274C6E357EBAA3F4C031
{
public:
union
{
struct
{
};
uint8_t UpdateCustomRenderTextures_t52B541FA5A7354ED440E274C6E357EBAA3F4C031__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateRectTransform
struct UpdateRectTransform_t6290D8B6BF5E990B5F706FE60B4A5CD954D72F13
{
public:
union
{
struct
{
};
uint8_t UpdateRectTransform_t6290D8B6BF5E990B5F706FE60B4A5CD954D72F13__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateResolution
struct UpdateResolution_t8394E04EF0F5C04C0C65B1DF23F0E3E700144B45
{
public:
union
{
struct
{
};
uint8_t UpdateResolution_t8394E04EF0F5C04C0C65B1DF23F0E3E700144B45__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateSubstance
struct UpdateSubstance_tC6E01D9640025CD7D0B09D636C02172D22F66967
{
public:
union
{
struct
{
};
uint8_t UpdateSubstance_tC6E01D9640025CD7D0B09D636C02172D22F66967__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateVideo
struct UpdateVideo_t1E34A645DFD2C4E5243980D958392F6969F3D064
{
public:
union
{
struct
{
};
uint8_t UpdateVideo_t1E34A645DFD2C4E5243980D958392F6969F3D064__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_UpdateVideoTextures
struct UpdateVideoTextures_t05417287668B8B95121C4236FD3A419DAC091BB5
{
public:
union
{
struct
{
};
uint8_t UpdateVideoTextures_t05417287668B8B95121C4236FD3A419DAC091BB5__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_VFXUpdate
struct VFXUpdate_tA520740E78D381B2830822C7FE90A203478B2214
{
public:
union
{
struct
{
};
uint8_t VFXUpdate_tA520740E78D381B2830822C7FE90A203478B2214__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PostLateUpdate_XRPostPresent
struct XRPostPresent_t1B355F20B2823F13F6FBC66E36526B280B7EA85C
{
public:
union
{
struct
{
};
uint8_t XRPostPresent_t1B355F20B2823F13F6FBC66E36526B280B7EA85C__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_AIUpdatePostScript
struct AIUpdatePostScript_t8A88713869A78E54E8A68D01A2DAE28612B31BE4
{
public:
union
{
struct
{
};
uint8_t AIUpdatePostScript_t8A88713869A78E54E8A68D01A2DAE28612B31BE4__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_ConstraintManagerUpdate
struct ConstraintManagerUpdate_t60B829793DBE56E48C551CA2FC80F7FE82EC0090
{
public:
union
{
struct
{
};
uint8_t ConstraintManagerUpdate_t60B829793DBE56E48C551CA2FC80F7FE82EC0090__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_DirectorDeferredEvaluate
struct DirectorDeferredEvaluate_t1ADCC8CADAB3489481182AE5AE94F2218BA8E08F
{
public:
union
{
struct
{
};
uint8_t DirectorDeferredEvaluate_t1ADCC8CADAB3489481182AE5AE94F2218BA8E08F__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_DirectorUpdateAnimationBegin
struct DirectorUpdateAnimationBegin_t1F818F8031BEDE2CDC67F69C0CDFF860F2063A74
{
public:
union
{
struct
{
};
uint8_t DirectorUpdateAnimationBegin_t1F818F8031BEDE2CDC67F69C0CDFF860F2063A74__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_DirectorUpdateAnimationEnd
struct DirectorUpdateAnimationEnd_tDFC00FCAC7FBFD798572D224654127451FF4CEC1
{
public:
union
{
struct
{
};
uint8_t DirectorUpdateAnimationEnd_tDFC00FCAC7FBFD798572D224654127451FF4CEC1__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_EndGraphicsJobsAfterScriptUpdate
struct EndGraphicsJobsAfterScriptUpdate_tD208592C17EBA50EB4E2E9B4E4C64C9122AE3C96
{
public:
union
{
struct
{
};
uint8_t EndGraphicsJobsAfterScriptUpdate_tD208592C17EBA50EB4E2E9B4E4C64C9122AE3C96__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_LegacyAnimationUpdate
struct LegacyAnimationUpdate_t4838E9C42DDCC98CF195A798F73DD5E57F559A37
{
public:
union
{
struct
{
};
uint8_t LegacyAnimationUpdate_t4838E9C42DDCC98CF195A798F73DD5E57F559A37__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_ParticleSystemBeginUpdateAll
struct ParticleSystemBeginUpdateAll_t87DCB20B8C93E68E52B943F1E3B31BB091FCA078
{
public:
union
{
struct
{
};
uint8_t ParticleSystemBeginUpdateAll_t87DCB20B8C93E68E52B943F1E3B31BB091FCA078__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_ScriptRunBehaviourLateUpdate
struct ScriptRunBehaviourLateUpdate_t58F4C9331E2958013C6CB7FEF18E370AD5043B9A
{
public:
union
{
struct
{
};
uint8_t ScriptRunBehaviourLateUpdate_t58F4C9331E2958013C6CB7FEF18E370AD5043B9A__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_UNetUpdate
struct UNetUpdate_tDD911C7D34BC0CE4B5C79DD46C45285E224E21B2
{
public:
union
{
struct
{
};
uint8_t UNetUpdate_tDD911C7D34BC0CE4B5C79DD46C45285E224E21B2__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_UpdateMasterServerInterface
struct UpdateMasterServerInterface_t1F40E6F5C301466C446578EF63381B5D1C8DA187
{
public:
union
{
struct
{
};
uint8_t UpdateMasterServerInterface_t1F40E6F5C301466C446578EF63381B5D1C8DA187__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreLateUpdate_UpdateNetworkManager
struct UpdateNetworkManager_tBEE4C45468BA0C0DBA98B8C25FC315233267AE2C
{
public:
union
{
struct
{
};
uint8_t UpdateNetworkManager_tBEE4C45468BA0C0DBA98B8C25FC315233267AE2C__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreUpdate_AIUpdate
struct AIUpdate_tACDB7E77F804905AFC0D39674778A62488A22CE2
{
public:
union
{
struct
{
};
uint8_t AIUpdate_tACDB7E77F804905AFC0D39674778A62488A22CE2__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreUpdate_CheckTexFieldInput
struct CheckTexFieldInput_t1FA363405F456B111E58078F4EFAB82912734432
{
public:
union
{
struct
{
};
uint8_t CheckTexFieldInput_t1FA363405F456B111E58078F4EFAB82912734432__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreUpdate_IMGUISendQueuedEvents
struct IMGUISendQueuedEvents_tF513CA3C17A07868E255F8D5A34C284803A22767
{
public:
union
{
struct
{
};
uint8_t IMGUISendQueuedEvents_tF513CA3C17A07868E255F8D5A34C284803A22767__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreUpdate_NewInputUpdate
struct NewInputUpdate_tF98FD69B5E9EAFEA02964DFFE852FF6029676308
{
public:
union
{
struct
{
};
uint8_t NewInputUpdate_tF98FD69B5E9EAFEA02964DFFE852FF6029676308__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreUpdate_Physics2DUpdate
struct Physics2DUpdate_tDC29C716549E1E860FD67BF84EF243D3BA595A60
{
public:
union
{
struct
{
};
uint8_t Physics2DUpdate_tDC29C716549E1E860FD67BF84EF243D3BA595A60__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreUpdate_PhysicsUpdate
struct PhysicsUpdate_tF321BF0A833E955AED90F182BBC9D6D7D40F2F25
{
public:
union
{
struct
{
};
uint8_t PhysicsUpdate_tF321BF0A833E955AED90F182BBC9D6D7D40F2F25__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreUpdate_SendMouseEvents
struct SendMouseEvents_t2D84BCC439FE9A04E341AD07ECEBF4E8B12D2F9D
{
public:
union
{
struct
{
};
uint8_t SendMouseEvents_t2D84BCC439FE9A04E341AD07ECEBF4E8B12D2F9D__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreUpdate_UpdateVideo
struct UpdateVideo_tE460041F5545E24C8A107B563F971F491286C0BD
{
public:
union
{
struct
{
};
uint8_t UpdateVideo_tE460041F5545E24C8A107B563F971F491286C0BD__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.PreUpdate_WindUpdate
struct WindUpdate_t40BB9BF39AEE43023A49F0335A9DAC9F91E43150
{
public:
union
{
struct
{
};
uint8_t WindUpdate_t40BB9BF39AEE43023A49F0335A9DAC9F91E43150__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.Update_DirectorUpdate
struct DirectorUpdate_t4A7FCDCBD027B9D28BFAFF7DEB5F33E0B5E27A85
{
public:
union
{
struct
{
};
uint8_t DirectorUpdate_t4A7FCDCBD027B9D28BFAFF7DEB5F33E0B5E27A85__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.Update_ScriptRunBehaviourUpdate
struct ScriptRunBehaviourUpdate_tAAEB9BAF1DB9036DFA153F433C2D719A7BC30536
{
public:
union
{
struct
{
};
uint8_t ScriptRunBehaviourUpdate_tAAEB9BAF1DB9036DFA153F433C2D719A7BC30536__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.Update_ScriptRunDelayedDynamicFrameRate
struct ScriptRunDelayedDynamicFrameRate_t1A2D15EEF198E3050B653FD370CBDFE82A46F66E
{
public:
union
{
struct
{
};
uint8_t ScriptRunDelayedDynamicFrameRate_t1A2D15EEF198E3050B653FD370CBDFE82A46F66E__padding[1];
};
public:
};
// UnityEngine.PlayerLoop.Update_ScriptRunDelayedTasks
struct ScriptRunDelayedTasks_t87535B3420E907071EA14E80AD9D811F29AA978A
{
public:
union
{
struct
{
};
uint8_t ScriptRunDelayedTasks_t87535B3420E907071EA14E80AD9D811F29AA978A__padding[1];
};
public:
};
// UnityEngine.ScriptingUtility_TestClass
struct TestClass_tE31E21A91B6A07C4CA1720FE6B57C980181F3F2C
{
public:
// System.Int32 UnityEngine.ScriptingUtility_TestClass::value
int32_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(TestClass_tE31E21A91B6A07C4CA1720FE6B57C980181F3F2C, ___value_0)); }
inline int32_t get_value_0() const { return ___value_0; }
inline int32_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(int32_t value)
{
___value_0 = value;
}
};
// UnityEngine.UnitySynchronizationContext_WorkRequest
struct WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393
{
public:
// System.Threading.SendOrPostCallback UnityEngine.UnitySynchronizationContext_WorkRequest::m_DelagateCallback
SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * ___m_DelagateCallback_0;
// System.Object UnityEngine.UnitySynchronizationContext_WorkRequest::m_DelagateState
RuntimeObject * ___m_DelagateState_1;
// System.Threading.ManualResetEvent UnityEngine.UnitySynchronizationContext_WorkRequest::m_WaitHandle
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___m_WaitHandle_2;
public:
inline static int32_t get_offset_of_m_DelagateCallback_0() { return static_cast<int32_t>(offsetof(WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393, ___m_DelagateCallback_0)); }
inline SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * get_m_DelagateCallback_0() const { return ___m_DelagateCallback_0; }
inline SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C ** get_address_of_m_DelagateCallback_0() { return &___m_DelagateCallback_0; }
inline void set_m_DelagateCallback_0(SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * value)
{
___m_DelagateCallback_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_DelagateCallback_0), (void*)value);
}
inline static int32_t get_offset_of_m_DelagateState_1() { return static_cast<int32_t>(offsetof(WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393, ___m_DelagateState_1)); }
inline RuntimeObject * get_m_DelagateState_1() const { return ___m_DelagateState_1; }
inline RuntimeObject ** get_address_of_m_DelagateState_1() { return &___m_DelagateState_1; }
inline void set_m_DelagateState_1(RuntimeObject * value)
{
___m_DelagateState_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_DelagateState_1), (void*)value);
}
inline static int32_t get_offset_of_m_WaitHandle_2() { return static_cast<int32_t>(offsetof(WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393, ___m_WaitHandle_2)); }
inline ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * get_m_WaitHandle_2() const { return ___m_WaitHandle_2; }
inline ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA ** get_address_of_m_WaitHandle_2() { return &___m_WaitHandle_2; }
inline void set_m_WaitHandle_2(ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * value)
{
___m_WaitHandle_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_WaitHandle_2), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_pinvoke
{
Il2CppMethodPointer ___m_DelagateCallback_0;
Il2CppIUnknown* ___m_DelagateState_1;
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___m_WaitHandle_2;
};
// Native definition for COM marshalling of UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_com
{
Il2CppMethodPointer ___m_DelagateCallback_0;
Il2CppIUnknown* ___m_DelagateState_1;
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___m_WaitHandle_2;
};
// System.Delegate
struct Delegate_t : public RuntimeObject
{
public:
// System.IntPtr System.Delegate::method_ptr
Il2CppMethodPointer ___method_ptr_0;
// System.IntPtr System.Delegate::invoke_impl
intptr_t ___invoke_impl_1;
// System.Object System.Delegate::m_target
RuntimeObject * ___m_target_2;
// System.IntPtr System.Delegate::method
intptr_t ___method_3;
// System.IntPtr System.Delegate::delegate_trampoline
intptr_t ___delegate_trampoline_4;
// System.IntPtr System.Delegate::extra_arg
intptr_t ___extra_arg_5;
// System.IntPtr System.Delegate::method_code
intptr_t ___method_code_6;
// System.Reflection.MethodInfo System.Delegate::method_info
MethodInfo_t * ___method_info_7;
// System.Reflection.MethodInfo System.Delegate::original_method_info
MethodInfo_t * ___original_method_info_8;
// System.DelegateData System.Delegate::data
DelegateData_t17DD30660E330C49381DAA99F934BE75CB11F288 * ___data_9;
// System.Boolean System.Delegate::method_is_virtual
bool ___method_is_virtual_10;
public:
inline static int32_t get_offset_of_method_ptr_0() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_ptr_0)); }
inline Il2CppMethodPointer get_method_ptr_0() const { return ___method_ptr_0; }
inline Il2CppMethodPointer* get_address_of_method_ptr_0() { return &___method_ptr_0; }
inline void set_method_ptr_0(Il2CppMethodPointer value)
{
___method_ptr_0 = value;
}
inline static int32_t get_offset_of_invoke_impl_1() { return static_cast<int32_t>(offsetof(Delegate_t, ___invoke_impl_1)); }
inline intptr_t get_invoke_impl_1() const { return ___invoke_impl_1; }
inline intptr_t* get_address_of_invoke_impl_1() { return &___invoke_impl_1; }
inline void set_invoke_impl_1(intptr_t value)
{
___invoke_impl_1 = value;
}
inline static int32_t get_offset_of_m_target_2() { return static_cast<int32_t>(offsetof(Delegate_t, ___m_target_2)); }
inline RuntimeObject * get_m_target_2() const { return ___m_target_2; }
inline RuntimeObject ** get_address_of_m_target_2() { return &___m_target_2; }
inline void set_m_target_2(RuntimeObject * value)
{
___m_target_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_target_2), (void*)value);
}
inline static int32_t get_offset_of_method_3() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_3)); }
inline intptr_t get_method_3() const { return ___method_3; }
inline intptr_t* get_address_of_method_3() { return &___method_3; }
inline void set_method_3(intptr_t value)
{
___method_3 = value;
}
inline static int32_t get_offset_of_delegate_trampoline_4() { return static_cast<int32_t>(offsetof(Delegate_t, ___delegate_trampoline_4)); }
inline intptr_t get_delegate_trampoline_4() const { return ___delegate_trampoline_4; }
inline intptr_t* get_address_of_delegate_trampoline_4() { return &___delegate_trampoline_4; }
inline void set_delegate_trampoline_4(intptr_t value)
{
___delegate_trampoline_4 = value;
}
inline static int32_t get_offset_of_extra_arg_5() { return static_cast<int32_t>(offsetof(Delegate_t, ___extra_arg_5)); }
inline intptr_t get_extra_arg_5() const { return ___extra_arg_5; }
inline intptr_t* get_address_of_extra_arg_5() { return &___extra_arg_5; }
inline void set_extra_arg_5(intptr_t value)
{
___extra_arg_5 = value;
}
inline static int32_t get_offset_of_method_code_6() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_code_6)); }
inline intptr_t get_method_code_6() const { return ___method_code_6; }
inline intptr_t* get_address_of_method_code_6() { return &___method_code_6; }
inline void set_method_code_6(intptr_t value)
{
___method_code_6 = value;
}
inline static int32_t get_offset_of_method_info_7() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_info_7)); }
inline MethodInfo_t * get_method_info_7() const { return ___method_info_7; }
inline MethodInfo_t ** get_address_of_method_info_7() { return &___method_info_7; }
inline void set_method_info_7(MethodInfo_t * value)
{
___method_info_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___method_info_7), (void*)value);
}
inline static int32_t get_offset_of_original_method_info_8() { return static_cast<int32_t>(offsetof(Delegate_t, ___original_method_info_8)); }
inline MethodInfo_t * get_original_method_info_8() const { return ___original_method_info_8; }
inline MethodInfo_t ** get_address_of_original_method_info_8() { return &___original_method_info_8; }
inline void set_original_method_info_8(MethodInfo_t * value)
{
___original_method_info_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___original_method_info_8), (void*)value);
}
inline static int32_t get_offset_of_data_9() { return static_cast<int32_t>(offsetof(Delegate_t, ___data_9)); }
inline DelegateData_t17DD30660E330C49381DAA99F934BE75CB11F288 * get_data_9() const { return ___data_9; }
inline DelegateData_t17DD30660E330C49381DAA99F934BE75CB11F288 ** get_address_of_data_9() { return &___data_9; }
inline void set_data_9(DelegateData_t17DD30660E330C49381DAA99F934BE75CB11F288 * value)
{
___data_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___data_9), (void*)value);
}
inline static int32_t get_offset_of_method_is_virtual_10() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_is_virtual_10)); }
inline bool get_method_is_virtual_10() const { return ___method_is_virtual_10; }
inline bool* get_address_of_method_is_virtual_10() { return &___method_is_virtual_10; }
inline void set_method_is_virtual_10(bool value)
{
___method_is_virtual_10 = value;
}
};
// Native definition for P/Invoke marshalling of System.Delegate
struct Delegate_t_marshaled_pinvoke
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t17DD30660E330C49381DAA99F934BE75CB11F288 * ___data_9;
int32_t ___method_is_virtual_10;
};
// Native definition for COM marshalling of System.Delegate
struct Delegate_t_marshaled_com
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t17DD30660E330C49381DAA99F934BE75CB11F288 * ___data_9;
int32_t ___method_is_virtual_10;
};
// System.Exception
struct Exception_t : public RuntimeObject
{
public:
// System.String System.Exception::_className
String_t* ____className_1;
// System.String System.Exception::_message
String_t* ____message_2;
// System.Collections.IDictionary System.Exception::_data
RuntimeObject* ____data_3;
// System.Exception System.Exception::_innerException
Exception_t * ____innerException_4;
// System.String System.Exception::_helpURL
String_t* ____helpURL_5;
// System.Object System.Exception::_stackTrace
RuntimeObject * ____stackTrace_6;
// System.String System.Exception::_stackTraceString
String_t* ____stackTraceString_7;
// System.String System.Exception::_remoteStackTraceString
String_t* ____remoteStackTraceString_8;
// System.Int32 System.Exception::_remoteStackIndex
int32_t ____remoteStackIndex_9;
// System.Object System.Exception::_dynamicMethods
RuntimeObject * ____dynamicMethods_10;
// System.Int32 System.Exception::_HResult
int32_t ____HResult_11;
// System.String System.Exception::_source
String_t* ____source_12;
// System.Runtime.Serialization.SafeSerializationManager System.Exception::_safeSerializationManager
SafeSerializationManager_tDE44F029589A028F8A3053C5C06153FAB4AAE29F * ____safeSerializationManager_13;
// System.Diagnostics.StackTrace[] System.Exception::captured_traces
StackTraceU5BU5D_t4AD999C288CB6D1F38A299D12B1598D606588971* ___captured_traces_14;
// System.IntPtr[] System.Exception::native_trace_ips
IntPtrU5BU5D_t27FC72B0409D75AAF33EC42498E8094E95FEE9A6* ___native_trace_ips_15;
public:
inline static int32_t get_offset_of__className_1() { return static_cast<int32_t>(offsetof(Exception_t, ____className_1)); }
inline String_t* get__className_1() const { return ____className_1; }
inline String_t** get_address_of__className_1() { return &____className_1; }
inline void set__className_1(String_t* value)
{
____className_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____className_1), (void*)value);
}
inline static int32_t get_offset_of__message_2() { return static_cast<int32_t>(offsetof(Exception_t, ____message_2)); }
inline String_t* get__message_2() const { return ____message_2; }
inline String_t** get_address_of__message_2() { return &____message_2; }
inline void set__message_2(String_t* value)
{
____message_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____message_2), (void*)value);
}
inline static int32_t get_offset_of__data_3() { return static_cast<int32_t>(offsetof(Exception_t, ____data_3)); }
inline RuntimeObject* get__data_3() const { return ____data_3; }
inline RuntimeObject** get_address_of__data_3() { return &____data_3; }
inline void set__data_3(RuntimeObject* value)
{
____data_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&____data_3), (void*)value);
}
inline static int32_t get_offset_of__innerException_4() { return static_cast<int32_t>(offsetof(Exception_t, ____innerException_4)); }
inline Exception_t * get__innerException_4() const { return ____innerException_4; }
inline Exception_t ** get_address_of__innerException_4() { return &____innerException_4; }
inline void set__innerException_4(Exception_t * value)
{
____innerException_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____innerException_4), (void*)value);
}
inline static int32_t get_offset_of__helpURL_5() { return static_cast<int32_t>(offsetof(Exception_t, ____helpURL_5)); }
inline String_t* get__helpURL_5() const { return ____helpURL_5; }
inline String_t** get_address_of__helpURL_5() { return &____helpURL_5; }
inline void set__helpURL_5(String_t* value)
{
____helpURL_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____helpURL_5), (void*)value);
}
inline static int32_t get_offset_of__stackTrace_6() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTrace_6)); }
inline RuntimeObject * get__stackTrace_6() const { return ____stackTrace_6; }
inline RuntimeObject ** get_address_of__stackTrace_6() { return &____stackTrace_6; }
inline void set__stackTrace_6(RuntimeObject * value)
{
____stackTrace_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stackTrace_6), (void*)value);
}
inline static int32_t get_offset_of__stackTraceString_7() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTraceString_7)); }
inline String_t* get__stackTraceString_7() const { return ____stackTraceString_7; }
inline String_t** get_address_of__stackTraceString_7() { return &____stackTraceString_7; }
inline void set__stackTraceString_7(String_t* value)
{
____stackTraceString_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stackTraceString_7), (void*)value);
}
inline static int32_t get_offset_of__remoteStackTraceString_8() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackTraceString_8)); }
inline String_t* get__remoteStackTraceString_8() const { return ____remoteStackTraceString_8; }
inline String_t** get_address_of__remoteStackTraceString_8() { return &____remoteStackTraceString_8; }
inline void set__remoteStackTraceString_8(String_t* value)
{
____remoteStackTraceString_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&____remoteStackTraceString_8), (void*)value);
}
inline static int32_t get_offset_of__remoteStackIndex_9() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackIndex_9)); }
inline int32_t get__remoteStackIndex_9() const { return ____remoteStackIndex_9; }
inline int32_t* get_address_of__remoteStackIndex_9() { return &____remoteStackIndex_9; }
inline void set__remoteStackIndex_9(int32_t value)
{
____remoteStackIndex_9 = value;
}
inline static int32_t get_offset_of__dynamicMethods_10() { return static_cast<int32_t>(offsetof(Exception_t, ____dynamicMethods_10)); }
inline RuntimeObject * get__dynamicMethods_10() const { return ____dynamicMethods_10; }
inline RuntimeObject ** get_address_of__dynamicMethods_10() { return &____dynamicMethods_10; }
inline void set__dynamicMethods_10(RuntimeObject * value)
{
____dynamicMethods_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&____dynamicMethods_10), (void*)value);
}
inline static int32_t get_offset_of__HResult_11() { return static_cast<int32_t>(offsetof(Exception_t, ____HResult_11)); }
inline int32_t get__HResult_11() const { return ____HResult_11; }
inline int32_t* get_address_of__HResult_11() { return &____HResult_11; }
inline void set__HResult_11(int32_t value)
{
____HResult_11 = value;
}
inline static int32_t get_offset_of__source_12() { return static_cast<int32_t>(offsetof(Exception_t, ____source_12)); }
inline String_t* get__source_12() const { return ____source_12; }
inline String_t** get_address_of__source_12() { return &____source_12; }
inline void set__source_12(String_t* value)
{
____source_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____source_12), (void*)value);
}
inline static int32_t get_offset_of__safeSerializationManager_13() { return static_cast<int32_t>(offsetof(Exception_t, ____safeSerializationManager_13)); }
inline SafeSerializationManager_tDE44F029589A028F8A3053C5C06153FAB4AAE29F * get__safeSerializationManager_13() const { return ____safeSerializationManager_13; }
inline SafeSerializationManager_tDE44F029589A028F8A3053C5C06153FAB4AAE29F ** get_address_of__safeSerializationManager_13() { return &____safeSerializationManager_13; }
inline void set__safeSerializationManager_13(SafeSerializationManager_tDE44F029589A028F8A3053C5C06153FAB4AAE29F * value)
{
____safeSerializationManager_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&____safeSerializationManager_13), (void*)value);
}
inline static int32_t get_offset_of_captured_traces_14() { return static_cast<int32_t>(offsetof(Exception_t, ___captured_traces_14)); }
inline StackTraceU5BU5D_t4AD999C288CB6D1F38A299D12B1598D606588971* get_captured_traces_14() const { return ___captured_traces_14; }
inline StackTraceU5BU5D_t4AD999C288CB6D1F38A299D12B1598D606588971** get_address_of_captured_traces_14() { return &___captured_traces_14; }
inline void set_captured_traces_14(StackTraceU5BU5D_t4AD999C288CB6D1F38A299D12B1598D606588971* value)
{
___captured_traces_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___captured_traces_14), (void*)value);
}
inline static int32_t get_offset_of_native_trace_ips_15() { return static_cast<int32_t>(offsetof(Exception_t, ___native_trace_ips_15)); }
inline IntPtrU5BU5D_t27FC72B0409D75AAF33EC42498E8094E95FEE9A6* get_native_trace_ips_15() const { return ___native_trace_ips_15; }
inline IntPtrU5BU5D_t27FC72B0409D75AAF33EC42498E8094E95FEE9A6** get_address_of_native_trace_ips_15() { return &___native_trace_ips_15; }
inline void set_native_trace_ips_15(IntPtrU5BU5D_t27FC72B0409D75AAF33EC42498E8094E95FEE9A6* value)
{
___native_trace_ips_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___native_trace_ips_15), (void*)value);
}
};
struct Exception_t_StaticFields
{
public:
// System.Object System.Exception::s_EDILock
RuntimeObject * ___s_EDILock_0;
public:
inline static int32_t get_offset_of_s_EDILock_0() { return static_cast<int32_t>(offsetof(Exception_t_StaticFields, ___s_EDILock_0)); }
inline RuntimeObject * get_s_EDILock_0() const { return ___s_EDILock_0; }
inline RuntimeObject ** get_address_of_s_EDILock_0() { return &___s_EDILock_0; }
inline void set_s_EDILock_0(RuntimeObject * value)
{
___s_EDILock_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_EDILock_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Exception
struct Exception_t_marshaled_pinvoke
{
char* ____className_1;
char* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_pinvoke* ____innerException_4;
char* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
char* ____stackTraceString_7;
char* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
char* ____source_12;
SafeSerializationManager_tDE44F029589A028F8A3053C5C06153FAB4AAE29F * ____safeSerializationManager_13;
StackTraceU5BU5D_t4AD999C288CB6D1F38A299D12B1598D606588971* ___captured_traces_14;
Il2CppSafeArray/*NONE*/* ___native_trace_ips_15;
};
// Native definition for COM marshalling of System.Exception
struct Exception_t_marshaled_com
{
Il2CppChar* ____className_1;
Il2CppChar* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_com* ____innerException_4;
Il2CppChar* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
Il2CppChar* ____stackTraceString_7;
Il2CppChar* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
Il2CppChar* ____source_12;
SafeSerializationManager_tDE44F029589A028F8A3053C5C06153FAB4AAE29F * ____safeSerializationManager_13;
StackTraceU5BU5D_t4AD999C288CB6D1F38A299D12B1598D606588971* ___captured_traces_14;
Il2CppSafeArray/*NONE*/* ___native_trace_ips_15;
};
// System.Threading.WaitHandle
struct WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842 : public MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8
{
public:
// System.IntPtr System.Threading.WaitHandle::waitHandle
intptr_t ___waitHandle_3;
// Microsoft.Win32.SafeHandles.SafeWaitHandle modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.WaitHandle::safeWaitHandle
SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1 * ___safeWaitHandle_4;
// System.Boolean System.Threading.WaitHandle::hasThreadAffinity
bool ___hasThreadAffinity_5;
public:
inline static int32_t get_offset_of_waitHandle_3() { return static_cast<int32_t>(offsetof(WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842, ___waitHandle_3)); }
inline intptr_t get_waitHandle_3() const { return ___waitHandle_3; }
inline intptr_t* get_address_of_waitHandle_3() { return &___waitHandle_3; }
inline void set_waitHandle_3(intptr_t value)
{
___waitHandle_3 = value;
}
inline static int32_t get_offset_of_safeWaitHandle_4() { return static_cast<int32_t>(offsetof(WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842, ___safeWaitHandle_4)); }
inline SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1 * get_safeWaitHandle_4() const { return ___safeWaitHandle_4; }
inline SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1 ** get_address_of_safeWaitHandle_4() { return &___safeWaitHandle_4; }
inline void set_safeWaitHandle_4(SafeWaitHandle_tF37EACEDF9C6F350EB4ABC1E1F869EECB0B5ABB1 * value)
{
___safeWaitHandle_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___safeWaitHandle_4), (void*)value);
}
inline static int32_t get_offset_of_hasThreadAffinity_5() { return static_cast<int32_t>(offsetof(WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842, ___hasThreadAffinity_5)); }
inline bool get_hasThreadAffinity_5() const { return ___hasThreadAffinity_5; }
inline bool* get_address_of_hasThreadAffinity_5() { return &___hasThreadAffinity_5; }
inline void set_hasThreadAffinity_5(bool value)
{
___hasThreadAffinity_5 = value;
}
};
struct WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842_StaticFields
{
public:
// System.IntPtr System.Threading.WaitHandle::InvalidHandle
intptr_t ___InvalidHandle_10;
public:
inline static int32_t get_offset_of_InvalidHandle_10() { return static_cast<int32_t>(offsetof(WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842_StaticFields, ___InvalidHandle_10)); }
inline intptr_t get_InvalidHandle_10() const { return ___InvalidHandle_10; }
inline intptr_t* get_address_of_InvalidHandle_10() { return &___InvalidHandle_10; }
inline void set_InvalidHandle_10(intptr_t value)
{
___InvalidHandle_10 = value;
}
};
// Native definition for P/Invoke marshalling of System.Threading.WaitHandle
struct WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842_marshaled_pinvoke : public MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8_marshaled_pinvoke
{
intptr_t ___waitHandle_3;
void* ___safeWaitHandle_4;
int32_t ___hasThreadAffinity_5;
};
// Native definition for COM marshalling of System.Threading.WaitHandle
struct WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842_marshaled_com : public MarshalByRefObject_tD4DF91B488B284F899417EC468D8E50E933306A8_marshaled_com
{
intptr_t ___waitHandle_3;
void* ___safeWaitHandle_4;
int32_t ___hasThreadAffinity_5;
};
// System.TimeSpan
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203
{
public:
// System.Int64 System.TimeSpan::_ticks
int64_t ____ticks_22;
public:
inline static int32_t get_offset_of__ticks_22() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203, ____ticks_22)); }
inline int64_t get__ticks_22() const { return ____ticks_22; }
inline int64_t* get_address_of__ticks_22() { return &____ticks_22; }
inline void set__ticks_22(int64_t value)
{
____ticks_22 = value;
}
};
struct TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields
{
public:
// System.TimeSpan System.TimeSpan::Zero
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___Zero_19;
// System.TimeSpan System.TimeSpan::MaxValue
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___MaxValue_20;
// System.TimeSpan System.TimeSpan::MinValue
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___MinValue_21;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyConfigChecked
bool ____legacyConfigChecked_23;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyMode
bool ____legacyMode_24;
public:
inline static int32_t get_offset_of_Zero_19() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___Zero_19)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_Zero_19() const { return ___Zero_19; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_Zero_19() { return &___Zero_19; }
inline void set_Zero_19(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___Zero_19 = value;
}
inline static int32_t get_offset_of_MaxValue_20() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___MaxValue_20)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_MaxValue_20() const { return ___MaxValue_20; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_MaxValue_20() { return &___MaxValue_20; }
inline void set_MaxValue_20(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___MaxValue_20 = value;
}
inline static int32_t get_offset_of_MinValue_21() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ___MinValue_21)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_MinValue_21() const { return ___MinValue_21; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_MinValue_21() { return &___MinValue_21; }
inline void set_MinValue_21(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___MinValue_21 = value;
}
inline static int32_t get_offset_of__legacyConfigChecked_23() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ____legacyConfigChecked_23)); }
inline bool get__legacyConfigChecked_23() const { return ____legacyConfigChecked_23; }
inline bool* get_address_of__legacyConfigChecked_23() { return &____legacyConfigChecked_23; }
inline void set__legacyConfigChecked_23(bool value)
{
____legacyConfigChecked_23 = value;
}
inline static int32_t get_offset_of__legacyMode_24() { return static_cast<int32_t>(offsetof(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203_StaticFields, ____legacyMode_24)); }
inline bool get__legacyMode_24() const { return ____legacyMode_24; }
inline bool* get_address_of__legacyMode_24() { return &____legacyMode_24; }
inline void set__legacyMode_24(bool value)
{
____legacyMode_24 = value;
}
};
// Unity.Profiling.ProfilerMarker_AutoScope
struct AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D
{
public:
// System.IntPtr Unity.Profiling.ProfilerMarker_AutoScope::m_Ptr
intptr_t ___m_Ptr_0;
public:
inline static int32_t get_offset_of_m_Ptr_0() { return static_cast<int32_t>(offsetof(AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D, ___m_Ptr_0)); }
inline intptr_t get_m_Ptr_0() const { return ___m_Ptr_0; }
inline intptr_t* get_address_of_m_Ptr_0() { return &___m_Ptr_0; }
inline void set_m_Ptr_0(intptr_t value)
{
___m_Ptr_0 = value;
}
};
// UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass12_0
struct U3CU3Ec__DisplayClass12_0_tC029C4F11E384EFEF6FD86B7BEC83D295D098769 : public RuntimeObject
{
public:
// System.Guid UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass12_0::messageId
Guid_t ___messageId_0;
public:
inline static int32_t get_offset_of_messageId_0() { return static_cast<int32_t>(offsetof(U3CU3Ec__DisplayClass12_0_tC029C4F11E384EFEF6FD86B7BEC83D295D098769, ___messageId_0)); }
inline Guid_t get_messageId_0() const { return ___messageId_0; }
inline Guid_t * get_address_of_messageId_0() { return &___messageId_0; }
inline void set_messageId_0(Guid_t value)
{
___messageId_0 = value;
}
};
// UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass13_0
struct U3CU3Ec__DisplayClass13_0_t1A8EBE4E3370D09549DE4FD59077B3A7AEAD0C54 : public RuntimeObject
{
public:
// System.Guid UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass13_0::messageId
Guid_t ___messageId_0;
public:
inline static int32_t get_offset_of_messageId_0() { return static_cast<int32_t>(offsetof(U3CU3Ec__DisplayClass13_0_t1A8EBE4E3370D09549DE4FD59077B3A7AEAD0C54, ___messageId_0)); }
inline Guid_t get_messageId_0() const { return ___messageId_0; }
inline Guid_t * get_address_of_messageId_0() { return &___messageId_0; }
inline void set_messageId_0(Guid_t value)
{
___messageId_0 = value;
}
};
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass6_0
struct U3CU3Ec__DisplayClass6_0_t96633FB6A2AE351A4A3FCDF89D10891DA07AD54F : public RuntimeObject
{
public:
// System.Guid UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass6_0::messageId
Guid_t ___messageId_0;
public:
inline static int32_t get_offset_of_messageId_0() { return static_cast<int32_t>(offsetof(U3CU3Ec__DisplayClass6_0_t96633FB6A2AE351A4A3FCDF89D10891DA07AD54F, ___messageId_0)); }
inline Guid_t get_messageId_0() const { return ___messageId_0; }
inline Guid_t * get_address_of_messageId_0() { return &___messageId_0; }
inline void set_messageId_0(Guid_t value)
{
___messageId_0 = value;
}
};
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass7_0
struct U3CU3Ec__DisplayClass7_0_t7C625D285CBB757F88C0232D12D88EDABF06EB60 : public RuntimeObject
{
public:
// System.Guid UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass7_0::messageId
Guid_t ___messageId_0;
public:
inline static int32_t get_offset_of_messageId_0() { return static_cast<int32_t>(offsetof(U3CU3Ec__DisplayClass7_0_t7C625D285CBB757F88C0232D12D88EDABF06EB60, ___messageId_0)); }
inline Guid_t get_messageId_0() const { return ___messageId_0; }
inline Guid_t * get_address_of_messageId_0() { return &___messageId_0; }
inline void set_messageId_0(Guid_t value)
{
___messageId_0 = value;
}
};
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass8_0
struct U3CU3Ec__DisplayClass8_0_tE64E7CAC5415DCD425D14A6062600087CC872B93 : public RuntimeObject
{
public:
// System.Guid UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass8_0::messageId
Guid_t ___messageId_0;
public:
inline static int32_t get_offset_of_messageId_0() { return static_cast<int32_t>(offsetof(U3CU3Ec__DisplayClass8_0_tE64E7CAC5415DCD425D14A6062600087CC872B93, ___messageId_0)); }
inline Guid_t get_messageId_0() const { return ___messageId_0; }
inline Guid_t * get_address_of_messageId_0() { return &___messageId_0; }
inline void set_messageId_0(Guid_t value)
{
___messageId_0 = value;
}
};
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_ConnectionChangeEvent
struct ConnectionChangeEvent_tCA1C8C14171C72EC394EF45450D69C1585067BDF : public UnityEvent_1_tB235B5DAD099AC425DC059D10DEB8B97A35E2BBF
{
public:
public:
};
// UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageEvent
struct MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B : public UnityEvent_1_t5380899C55F3CD7FD1CD64F13EE5E1E4B11D602B
{
public:
public:
};
// UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Object::m_CachedPtr
intptr_t ___m_CachedPtr_0;
public:
inline static int32_t get_offset_of_m_CachedPtr_0() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A, ___m_CachedPtr_0)); }
inline intptr_t get_m_CachedPtr_0() const { return ___m_CachedPtr_0; }
inline intptr_t* get_address_of_m_CachedPtr_0() { return &___m_CachedPtr_0; }
inline void set_m_CachedPtr_0(intptr_t value)
{
___m_CachedPtr_0 = value;
}
};
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields
{
public:
// System.Int32 UnityEngine.Object::OffsetOfInstanceIDInCPlusPlusObject
int32_t ___OffsetOfInstanceIDInCPlusPlusObject_1;
public:
inline static int32_t get_offset_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return static_cast<int32_t>(offsetof(Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_StaticFields, ___OffsetOfInstanceIDInCPlusPlusObject_1)); }
inline int32_t get_OffsetOfInstanceIDInCPlusPlusObject_1() const { return ___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline int32_t* get_address_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return &___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline void set_OffsetOfInstanceIDInCPlusPlusObject_1(int32_t value)
{
___OffsetOfInstanceIDInCPlusPlusObject_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_pinvoke
{
intptr_t ___m_CachedPtr_0;
};
// Native definition for COM marshalling of UnityEngine.Object
struct Object_tF2F3778131EFF286AF62B7B013A170F95A91571A_marshaled_com
{
intptr_t ___m_CachedPtr_0;
};
// UnityEngine.Playables.PlayableGraph
struct PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A
{
public:
// System.IntPtr UnityEngine.Playables.PlayableGraph::m_Handle
intptr_t ___m_Handle_0;
// System.UInt32 UnityEngine.Playables.PlayableGraph::m_Version
uint32_t ___m_Version_1;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A, ___m_Handle_0)); }
inline intptr_t get_m_Handle_0() const { return ___m_Handle_0; }
inline intptr_t* get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(intptr_t value)
{
___m_Handle_0 = value;
}
inline static int32_t get_offset_of_m_Version_1() { return static_cast<int32_t>(offsetof(PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A, ___m_Version_1)); }
inline uint32_t get_m_Version_1() const { return ___m_Version_1; }
inline uint32_t* get_address_of_m_Version_1() { return &___m_Version_1; }
inline void set_m_Version_1(uint32_t value)
{
___m_Version_1 = value;
}
};
// UnityEngine.Playables.PlayableOutputHandle
struct PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1
{
public:
// System.IntPtr UnityEngine.Playables.PlayableOutputHandle::m_Handle
intptr_t ___m_Handle_0;
// System.UInt32 UnityEngine.Playables.PlayableOutputHandle::m_Version
uint32_t ___m_Version_1;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1, ___m_Handle_0)); }
inline intptr_t get_m_Handle_0() const { return ___m_Handle_0; }
inline intptr_t* get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(intptr_t value)
{
___m_Handle_0 = value;
}
inline static int32_t get_offset_of_m_Version_1() { return static_cast<int32_t>(offsetof(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1, ___m_Version_1)); }
inline uint32_t get_m_Version_1() const { return ___m_Version_1; }
inline uint32_t* get_address_of_m_Version_1() { return &___m_Version_1; }
inline void set_m_Version_1(uint32_t value)
{
___m_Version_1 = value;
}
};
struct PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1_StaticFields
{
public:
// UnityEngine.Playables.PlayableOutputHandle UnityEngine.Playables.PlayableOutputHandle::m_Null
PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 ___m_Null_2;
public:
inline static int32_t get_offset_of_m_Null_2() { return static_cast<int32_t>(offsetof(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1_StaticFields, ___m_Null_2)); }
inline PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 get_m_Null_2() const { return ___m_Null_2; }
inline PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 * get_address_of_m_Null_2() { return &___m_Null_2; }
inline void set_m_Null_2(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 value)
{
___m_Null_2 = value;
}
};
// UnityEngine.RectTransform_Axis
struct Axis_t8881AF0DB9EDF3F36FE049AA194D0206695EBF83
{
public:
// System.Int32 UnityEngine.RectTransform_Axis::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Axis_t8881AF0DB9EDF3F36FE049AA194D0206695EBF83, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.ReflectionProbe_ReflectionProbeEvent
struct ReflectionProbeEvent_tA90347B5A1B5256D229969ADF158978AF137003A
{
public:
// System.Int32 UnityEngine.ReflectionProbe_ReflectionProbeEvent::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ReflectionProbeEvent_tA90347B5A1B5256D229969ADF158978AF137003A, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Rendering.SupportedRenderingFeatures_LightmapMixedBakeModes
struct LightmapMixedBakeModes_t517152ED1576E98EFCB29D358676919D88844F75
{
public:
// System.Int32 UnityEngine.Rendering.SupportedRenderingFeatures_LightmapMixedBakeModes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(LightmapMixedBakeModes_t517152ED1576E98EFCB29D358676919D88844F75, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Rendering.SupportedRenderingFeatures_ReflectionProbeModes
struct ReflectionProbeModes_tBE15DD8892571EBC569B7FCD5D918B0588F8EA4A
{
public:
// System.Int32 UnityEngine.Rendering.SupportedRenderingFeatures_ReflectionProbeModes::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ReflectionProbeModes_tBE15DD8892571EBC569B7FCD5D918B0588F8EA4A, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.TouchScreenKeyboard_Status
struct Status_tCF9D837EDAD10412CECD4A306BCD7CA936720FEF
{
public:
// System.Int32 UnityEngine.TouchScreenKeyboard_Status::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Status_tCF9D837EDAD10412CECD4A306BCD7CA936720FEF, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Windows.Speech.ConfidenceLevel
struct ConfidenceLevel_t1961445160E273E8B221599F4596C7B1A56CACE3
{
public:
// System.Int32 UnityEngine.Windows.Speech.ConfidenceLevel::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(ConfidenceLevel_t1961445160E273E8B221599F4596C7B1A56CACE3, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Windows.Speech.SpeechError
struct SpeechError_t3B8EC653706113444C6077B380A8FD5DF407EC8F
{
public:
// System.Int32 UnityEngine.Windows.Speech.SpeechError::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SpeechError_t3B8EC653706113444C6077B380A8FD5DF407EC8F, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Windows.Speech.SpeechSystemStatus
struct SpeechSystemStatus_t9D1FF73360901F27A8117402D1F5BCC7E1309BF5
{
public:
// System.Int32 UnityEngine.Windows.Speech.SpeechSystemStatus::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(SpeechSystemStatus_t9D1FF73360901F27A8117402D1F5BCC7E1309BF5, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Windows.WebCam.PhotoCapture_CaptureResultType
struct CaptureResultType_tA7FDF613D8AE80F99DDF89D102A04C4F5D00768F
{
public:
// System.Int32 UnityEngine.Windows.WebCam.PhotoCapture_CaptureResultType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(CaptureResultType_tA7FDF613D8AE80F99DDF89D102A04C4F5D00768F, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.Windows.WebCam.VideoCapture
struct VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Windows.WebCam.VideoCapture::m_NativePtr
intptr_t ___m_NativePtr_0;
public:
inline static int32_t get_offset_of_m_NativePtr_0() { return static_cast<int32_t>(offsetof(VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91, ___m_NativePtr_0)); }
inline intptr_t get_m_NativePtr_0() const { return ___m_NativePtr_0; }
inline intptr_t* get_address_of_m_NativePtr_0() { return &___m_NativePtr_0; }
inline void set_m_NativePtr_0(intptr_t value)
{
___m_NativePtr_0 = value;
}
};
struct VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_StaticFields
{
public:
// System.Int64 UnityEngine.Windows.WebCam.VideoCapture::HR_SUCCESS
int64_t ___HR_SUCCESS_1;
public:
inline static int32_t get_offset_of_HR_SUCCESS_1() { return static_cast<int32_t>(offsetof(VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_StaticFields, ___HR_SUCCESS_1)); }
inline int64_t get_HR_SUCCESS_1() const { return ___HR_SUCCESS_1; }
inline int64_t* get_address_of_HR_SUCCESS_1() { return &___HR_SUCCESS_1; }
inline void set_HR_SUCCESS_1(int64_t value)
{
___HR_SUCCESS_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Windows.WebCam.VideoCapture
struct VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshaled_pinvoke
{
intptr_t ___m_NativePtr_0;
};
// Native definition for COM marshalling of UnityEngine.Windows.WebCam.VideoCapture
struct VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshaled_com
{
intptr_t ___m_NativePtr_0;
};
// UnityEngine.Windows.WebCam.VideoCapture_CaptureResultType
struct CaptureResultType_t07E1CBF204003EAAE49E9E0402FEA91FACAE2925
{
public:
// System.Int32 UnityEngine.Windows.WebCam.VideoCapture_CaptureResultType::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(CaptureResultType_t07E1CBF204003EAAE49E9E0402FEA91FACAE2925, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.MulticastDelegate
struct MulticastDelegate_t : public Delegate_t
{
public:
// System.Delegate[] System.MulticastDelegate::delegates
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* ___delegates_11;
public:
inline static int32_t get_offset_of_delegates_11() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___delegates_11)); }
inline DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* get_delegates_11() const { return ___delegates_11; }
inline DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8** get_address_of_delegates_11() { return &___delegates_11; }
inline void set_delegates_11(DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* value)
{
___delegates_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___delegates_11), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_pinvoke : public Delegate_t_marshaled_pinvoke
{
Delegate_t_marshaled_pinvoke** ___delegates_11;
};
// Native definition for COM marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_com : public Delegate_t_marshaled_com
{
Delegate_t_marshaled_com** ___delegates_11;
};
// System.Threading.EventWaitHandle
struct EventWaitHandle_t80CDEB33529EF7549E7D3E3B689D8272B9F37F3C : public WaitHandle_t1D7DD8480FD5DA4E3AF92F569890FB972D9B1842
{
public:
public:
};
// UnityEngine.Component
struct Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684 : public Object_tF2F3778131EFF286AF62B7B013A170F95A91571A
{
public:
public:
};
// UnityEngine.Playables.PlayableOutput
struct PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82
{
public:
// UnityEngine.Playables.PlayableOutputHandle UnityEngine.Playables.PlayableOutput::m_Handle
PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 ___m_Handle_0;
public:
inline static int32_t get_offset_of_m_Handle_0() { return static_cast<int32_t>(offsetof(PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82, ___m_Handle_0)); }
inline PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 get_m_Handle_0() const { return ___m_Handle_0; }
inline PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 * get_address_of_m_Handle_0() { return &___m_Handle_0; }
inline void set_m_Handle_0(PlayableOutputHandle_t8C84BCDB2AECFEDBCF0E7CC7CDBADD517D148CD1 value)
{
___m_Handle_0 = value;
}
};
struct PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82_StaticFields
{
public:
// UnityEngine.Playables.PlayableOutput UnityEngine.Playables.PlayableOutput::m_NullPlayableOutput
PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 ___m_NullPlayableOutput_1;
public:
inline static int32_t get_offset_of_m_NullPlayableOutput_1() { return static_cast<int32_t>(offsetof(PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82_StaticFields, ___m_NullPlayableOutput_1)); }
inline PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 get_m_NullPlayableOutput_1() const { return ___m_NullPlayableOutput_1; }
inline PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 * get_address_of_m_NullPlayableOutput_1() { return &___m_NullPlayableOutput_1; }
inline void set_m_NullPlayableOutput_1(PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 value)
{
___m_NullPlayableOutput_1 = value;
}
};
// UnityEngine.Windows.Speech.PhraseRecognizedEventArgs
struct PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF
{
public:
// UnityEngine.Windows.Speech.ConfidenceLevel UnityEngine.Windows.Speech.PhraseRecognizedEventArgs::confidence
int32_t ___confidence_0;
// UnityEngine.Windows.Speech.SemanticMeaning[] UnityEngine.Windows.Speech.PhraseRecognizedEventArgs::semanticMeanings
SemanticMeaningU5BU5D_t7BA8135E11B4D0C1065824DA86D4B3DB63A5B4DD* ___semanticMeanings_1;
// System.String UnityEngine.Windows.Speech.PhraseRecognizedEventArgs::text
String_t* ___text_2;
// System.DateTime UnityEngine.Windows.Speech.PhraseRecognizedEventArgs::phraseStartTime
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___phraseStartTime_3;
// System.TimeSpan UnityEngine.Windows.Speech.PhraseRecognizedEventArgs::phraseDuration
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___phraseDuration_4;
public:
inline static int32_t get_offset_of_confidence_0() { return static_cast<int32_t>(offsetof(PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF, ___confidence_0)); }
inline int32_t get_confidence_0() const { return ___confidence_0; }
inline int32_t* get_address_of_confidence_0() { return &___confidence_0; }
inline void set_confidence_0(int32_t value)
{
___confidence_0 = value;
}
inline static int32_t get_offset_of_semanticMeanings_1() { return static_cast<int32_t>(offsetof(PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF, ___semanticMeanings_1)); }
inline SemanticMeaningU5BU5D_t7BA8135E11B4D0C1065824DA86D4B3DB63A5B4DD* get_semanticMeanings_1() const { return ___semanticMeanings_1; }
inline SemanticMeaningU5BU5D_t7BA8135E11B4D0C1065824DA86D4B3DB63A5B4DD** get_address_of_semanticMeanings_1() { return &___semanticMeanings_1; }
inline void set_semanticMeanings_1(SemanticMeaningU5BU5D_t7BA8135E11B4D0C1065824DA86D4B3DB63A5B4DD* value)
{
___semanticMeanings_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___semanticMeanings_1), (void*)value);
}
inline static int32_t get_offset_of_text_2() { return static_cast<int32_t>(offsetof(PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF, ___text_2)); }
inline String_t* get_text_2() const { return ___text_2; }
inline String_t** get_address_of_text_2() { return &___text_2; }
inline void set_text_2(String_t* value)
{
___text_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___text_2), (void*)value);
}
inline static int32_t get_offset_of_phraseStartTime_3() { return static_cast<int32_t>(offsetof(PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF, ___phraseStartTime_3)); }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 get_phraseStartTime_3() const { return ___phraseStartTime_3; }
inline DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 * get_address_of_phraseStartTime_3() { return &___phraseStartTime_3; }
inline void set_phraseStartTime_3(DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 value)
{
___phraseStartTime_3 = value;
}
inline static int32_t get_offset_of_phraseDuration_4() { return static_cast<int32_t>(offsetof(PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF, ___phraseDuration_4)); }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 get_phraseDuration_4() const { return ___phraseDuration_4; }
inline TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 * get_address_of_phraseDuration_4() { return &___phraseDuration_4; }
inline void set_phraseDuration_4(TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 value)
{
___phraseDuration_4 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Windows.Speech.PhraseRecognizedEventArgs
struct PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF_marshaled_pinvoke
{
int32_t ___confidence_0;
SemanticMeaning_t5AEB02C787CA22E278A1E6D32FDA7CCA378F86E3_marshaled_pinvoke* ___semanticMeanings_1;
char* ___text_2;
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___phraseStartTime_3;
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___phraseDuration_4;
};
// Native definition for COM marshalling of UnityEngine.Windows.Speech.PhraseRecognizedEventArgs
struct PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF_marshaled_com
{
int32_t ___confidence_0;
SemanticMeaning_t5AEB02C787CA22E278A1E6D32FDA7CCA378F86E3_marshaled_com* ___semanticMeanings_1;
Il2CppChar* ___text_2;
DateTime_tEAF2CD16E071DF5441F40822E4CFE880E5245405 ___phraseStartTime_3;
TimeSpan_t4F6A0E13E703B65365CFCAB58E05EE0AF3EE6203 ___phraseDuration_4;
};
// UnityEngine.Windows.WebCam.PhotoCapture_PhotoCaptureResult
struct PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226
{
public:
// UnityEngine.Windows.WebCam.PhotoCapture_CaptureResultType UnityEngine.Windows.WebCam.PhotoCapture_PhotoCaptureResult::resultType
int32_t ___resultType_0;
// System.Int64 UnityEngine.Windows.WebCam.PhotoCapture_PhotoCaptureResult::hResult
int64_t ___hResult_1;
public:
inline static int32_t get_offset_of_resultType_0() { return static_cast<int32_t>(offsetof(PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226, ___resultType_0)); }
inline int32_t get_resultType_0() const { return ___resultType_0; }
inline int32_t* get_address_of_resultType_0() { return &___resultType_0; }
inline void set_resultType_0(int32_t value)
{
___resultType_0 = value;
}
inline static int32_t get_offset_of_hResult_1() { return static_cast<int32_t>(offsetof(PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226, ___hResult_1)); }
inline int64_t get_hResult_1() const { return ___hResult_1; }
inline int64_t* get_address_of_hResult_1() { return &___hResult_1; }
inline void set_hResult_1(int64_t value)
{
___hResult_1 = value;
}
};
// UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult
struct VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F
{
public:
// UnityEngine.Windows.WebCam.VideoCapture_CaptureResultType UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult::resultType
int32_t ___resultType_0;
// System.Int64 UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult::hResult
int64_t ___hResult_1;
public:
inline static int32_t get_offset_of_resultType_0() { return static_cast<int32_t>(offsetof(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F, ___resultType_0)); }
inline int32_t get_resultType_0() const { return ___resultType_0; }
inline int32_t* get_address_of_resultType_0() { return &___resultType_0; }
inline void set_resultType_0(int32_t value)
{
___resultType_0 = value;
}
inline static int32_t get_offset_of_hResult_1() { return static_cast<int32_t>(offsetof(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F, ___hResult_1)); }
inline int64_t get_hResult_1() const { return ___hResult_1; }
inline int64_t* get_address_of_hResult_1() { return &___hResult_1; }
inline void set_hResult_1(int64_t value)
{
___hResult_1 = value;
}
};
// System.AsyncCallback
struct AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA : public MulticastDelegate_t
{
public:
public:
};
// System.Threading.ManualResetEvent
struct ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA : public EventWaitHandle_t80CDEB33529EF7549E7D3E3B689D8272B9F37F3C
{
public:
public:
};
// System.Threading.SendOrPostCallback
struct SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.LowLevel.PlayerLoopSystem_UpdateFunction
struct UpdateFunction_tEDC2A88F61F179480CAA9443E6ADDA3F126B8AEA : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Playables.PlayableBinding_CreateOutputMethod
struct CreateOutputMethod_t7A129D00E8823B50AEDD0C9B082C9CB3DF863876 : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.RectTransform_ReapplyDrivenProperties
struct ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Transform
struct Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 : public Component_t62FBC8D2420DA4BE9037AFE430740F6B3EECA684
{
public:
public:
};
// UnityEngine.Windows.Speech.PhraseRecognitionSystem_ErrorDelegate
struct ErrorDelegate_t4E0F6E50E9C786DB72C82D69540E01FB9EFD3D9C : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Windows.Speech.PhraseRecognitionSystem_StatusDelegate
struct StatusDelegate_tD751E0623EDFECE1A8492E9DB58E762EFC0D2528 : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Windows.Speech.PhraseRecognizer_PhraseRecognizedDelegate
struct PhraseRecognizedDelegate_t13C88401D803DCE6F7A0250C3C86F0FF1FD8662F : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStartedCallback
struct OnPhotoModeStartedCallback_t21FCF86FB7933100968EE01A7B4BFB751F53EF92 : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStoppedCallback
struct OnPhotoModeStoppedCallback_tF6A2F039E1A8DB64BD4CF25675BED44F74E5B1F6 : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Windows.WebCam.VideoCapture_OnStartedRecordingVideoCallback
struct OnStartedRecordingVideoCallback_tF42862BD94B6DEE3AFBAEC068CB93D2B35E366A9 : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Windows.WebCam.VideoCapture_OnStoppedRecordingVideoCallback
struct OnStoppedRecordingVideoCallback_t2D7EC27C8904AE0EE068D13F918E42EECF965DD6 : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Windows.WebCam.VideoCapture_OnVideoCaptureResourceCreatedCallback
struct OnVideoCaptureResourceCreatedCallback_t3699FD2DE7FEF286A229B548E358133211BBA956 : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStartedCallback
struct OnVideoModeStartedCallback_t201EBB65059DA254ED2A4B24D365C4F6EAE9DF75 : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStoppedCallback
struct OnVideoModeStoppedCallback_tA0921FEE66B3EDE3E01E8D6526CF5203ED3C273C : public MulticastDelegate_t
{
public:
public:
};
// UnityEngine.RectTransform
struct RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 : public Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1
{
public:
public:
};
struct RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_StaticFields
{
public:
// UnityEngine.RectTransform_ReapplyDrivenProperties UnityEngine.RectTransform::reapplyDrivenProperties
ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * ___reapplyDrivenProperties_4;
public:
inline static int32_t get_offset_of_reapplyDrivenProperties_4() { return static_cast<int32_t>(offsetof(RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072_StaticFields, ___reapplyDrivenProperties_4)); }
inline ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * get_reapplyDrivenProperties_4() const { return ___reapplyDrivenProperties_4; }
inline ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE ** get_address_of_reapplyDrivenProperties_4() { return &___reapplyDrivenProperties_4; }
inline void set_reapplyDrivenProperties_4(ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * value)
{
___reapplyDrivenProperties_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___reapplyDrivenProperties_4), (void*)value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// System.Delegate[]
struct DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Delegate_t * m_Items[1];
public:
inline Delegate_t * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Delegate_t ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Delegate_t * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline Delegate_t * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Delegate_t ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Delegate_t * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Byte[],System.Text.Encoding>[]
struct KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7 : public RuntimeArray
{
public:
ALIGN_FIELD (8) KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B m_Items[1];
public:
inline KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B * GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___key_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___value_1), (void*)NULL);
#endif
}
inline KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B * GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___key_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___value_1), (void*)NULL);
#endif
}
};
// System.Byte[]
struct ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726 : public RuntimeArray
{
public:
ALIGN_FIELD (8) uint8_t m_Items[1];
public:
inline uint8_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint8_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint8_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint8_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint8_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint8_t value)
{
m_Items[index] = value;
}
};
IL2CPP_EXTERN_C void VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshal_pinvoke(const VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91& unmarshaled, VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshaled_pinvoke& marshaled);
IL2CPP_EXTERN_C void VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshal_pinvoke_back(const VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshaled_pinvoke& marshaled, VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91& unmarshaled);
IL2CPP_EXTERN_C void VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshal_pinvoke_cleanup(VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshaled_pinvoke& marshaled);
// System.Void UnityEngine.Events.UnityEvent`1<System.Int32>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnityEvent_1__ctor_m30F443398054B5E3666B3C86E64A5C0FF97D93FF_gshared (UnityEvent_1_tB235B5DAD099AC425DC059D10DEB8B97A35E2BBF * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Events.UnityEvent`1<System.Object>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnityEvent_1__ctor_mD87552C18A41196B69A62A366C8238FC246B151A_gshared (UnityEvent_1_t32063FE815890FF672DF76288FAC4ABE089B899F * __this, const RuntimeMethod* method);
// System.Void System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>::.ctor(!0,!1)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void KeyValuePair_2__ctor_m74B9EB9E16A0CC0F80B0AB74B8E1E91C16E6998E_gshared (KeyValuePair_2_tFB6A066C69E28C6ACA5FC5E24D969BFADC5FA625 * __this, RuntimeObject * ___key0, RuntimeObject * ___value1, const RuntimeMethod* method);
// System.Void System.Object::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405 (RuntimeObject * __this, const RuntimeMethod* method);
// System.Guid UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageTypeSubscribers::get_MessageTypeId()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Guid_t MessageTypeSubscribers_get_MessageTypeId_m5A873C55E97728BD12BA52B5DB72FFA366992DD9 (MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * __this, const RuntimeMethod* method);
// System.Boolean System.Guid::op_Equality(System.Guid,System.Guid)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Guid_op_Equality_m4C2AA9C31D173525E381965A7246814B4C74D5B0 (Guid_t ___a0, Guid_t ___b1, const RuntimeMethod* method);
// System.Void UnityEngine.Events.UnityEvent`1<System.Int32>::.ctor()
inline void UnityEvent_1__ctor_m30F443398054B5E3666B3C86E64A5C0FF97D93FF (UnityEvent_1_tB235B5DAD099AC425DC059D10DEB8B97A35E2BBF * __this, const RuntimeMethod* method)
{
(( void (*) (UnityEvent_1_tB235B5DAD099AC425DC059D10DEB8B97A35E2BBF *, const RuntimeMethod*))UnityEvent_1__ctor_m30F443398054B5E3666B3C86E64A5C0FF97D93FF_gshared)(__this, method);
}
// System.Void UnityEngine.Events.UnityEvent`1<UnityEngine.Networking.PlayerConnection.MessageEventArgs>::.ctor()
inline void UnityEvent_1__ctor_mC7E63F58C7EFC8E8747E3619B7564A7325F03D3B (UnityEvent_1_t5380899C55F3CD7FD1CD64F13EE5E1E4B11D602B * __this, const RuntimeMethod* method)
{
(( void (*) (UnityEvent_1_t5380899C55F3CD7FD1CD64F13EE5E1E4B11D602B *, const RuntimeMethod*))UnityEvent_1__ctor_mD87552C18A41196B69A62A366C8238FC246B151A_gshared)(__this, method);
}
// System.Void System.Guid::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Guid__ctor_mF80313305B9CD2AD39B621E1CEC5C7DFDFFBDE66 (Guid_t * __this, String_t* ___g0, const RuntimeMethod* method);
// System.String System.Guid::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Guid_ToString_mA3AB7742FB0E04808F580868E82BDEB93187FB75 (Guid_t * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents/MessageEvent::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void MessageEvent__ctor_mE4D70D8837C51E422C9A40C3F8F34ACB9AB572BB (MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B * __this, const RuntimeMethod* method);
// System.Void Unity.Profiling.LowLevel.Unsafe.ProfilerUnsafeUtility::BeginSample(System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ProfilerUnsafeUtility_BeginSample_m1B2CAD1BC7C7C390514317A8D51FB798D4622AE4 (intptr_t ___markerPtr0, const RuntimeMethod* method);
// System.Void Unity.Profiling.ProfilerMarker/AutoScope::.ctor(System.IntPtr)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void AutoScope__ctor_m4131730A501F687FF95B2963EABAC7844C6B9859_inline (AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D * __this, intptr_t ___markerPtr0, const RuntimeMethod* method);
// System.Void Unity.Profiling.LowLevel.Unsafe.ProfilerUnsafeUtility::EndSample(System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ProfilerUnsafeUtility_EndSample_m0435B2EE7963614F3D154A83D44269FE4D1A85B0 (intptr_t ___markerPtr0, const RuntimeMethod* method);
// System.Void Unity.Profiling.ProfilerMarker/AutoScope::Dispose()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void AutoScope_Dispose_m5CDDCDA2B8769738BB695661EC4AC55DD7A0D7CA_inline (AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D * __this, const RuntimeMethod* method);
// System.Text.Encoding System.Text.Encoding::get_UTF8()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * Encoding_get_UTF8_mC877FB3137BBD566AEE7B15F9BF61DC4EF8F5E5E (const RuntimeMethod* method);
// System.Void System.Text.EncoderReplacementFallback::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EncoderReplacementFallback__ctor_m07299910DC3D3F6B9F8F37A4ADD40A500F97D1D4 (EncoderReplacementFallback_t61E36A507D7FA8034B49F86DBE560EC77A6A8418 * __this, String_t* ___replacement0, const RuntimeMethod* method);
// System.Void System.Text.DecoderReplacementFallback::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void DecoderReplacementFallback__ctor_m7E6C273B2682E373C787568EB0BB0B2E4B6C2253 (DecoderReplacementFallback_t8DA345EC4EF3A35A2667365F691EE69408A62130 * __this, String_t* ___replacement0, const RuntimeMethod* method);
// System.Text.Encoding System.Text.Encoding::GetEncoding(System.Int32,System.Text.EncoderFallback,System.Text.DecoderFallback)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * Encoding_GetEncoding_m4DC46FF0C923994EDEE21980037198E27A75E4F2 (int32_t ___codepage0, EncoderFallback_t02AC990075E17EB09F0D7E4831C3B3F264025CC4 * ___encoderFallback1, DecoderFallback_tF86D337D6576E81E5DA285E5673183EBC66DEF8D * ___decoderFallback2, const RuntimeMethod* method);
// System.Void System.Text.UTF32Encoding::.ctor(System.Boolean,System.Boolean,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UTF32Encoding__ctor_mCC6CB31807AE3B57FAF941B59D72D7BA10CFB1FD (UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014 * __this, bool ___bigEndian0, bool ___byteOrderMark1, bool ___throwOnInvalidCharacters2, const RuntimeMethod* method);
// System.Void System.Text.UnicodeEncoding::.ctor(System.Boolean,System.Boolean,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnicodeEncoding__ctor_m8D0BFF0DBB175D7E590674E31343E8C72701FC7C (UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68 * __this, bool ___bigEndian0, bool ___byteOrderMark1, bool ___throwOnInvalidBytes2, const RuntimeMethod* method);
// System.Void System.Text.UTF8Encoding::.ctor(System.Boolean,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UTF8Encoding__ctor_mD752778085A353529AF03841383E5603FE556449 (UTF8Encoding_t6EE88BC62116B5328F6CF4E39C9CC49EED2ED282 * __this, bool ___encoderShouldEmitUTF8Identifier0, bool ___throwOnInvalidBytes1, const RuntimeMethod* method);
// System.Void System.Collections.Generic.KeyValuePair`2<System.Byte[],System.Text.Encoding>::.ctor(!0,!1)
inline void KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E (KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B * __this, ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* ___key0, Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * ___value1, const RuntimeMethod* method)
{
(( void (*) (KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B *, ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726*, Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 *, const RuntimeMethod*))KeyValuePair_2__ctor_m74B9EB9E16A0CC0F80B0AB74B8E1E91C16E6998E_gshared)(__this, ___key0, ___value1, method);
}
// UnityEngine.Transform UnityEngine.Transform::GetChild(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * Transform_GetChild_mA7D94BEFF0144F76561D9B8FED61C5C939EC1F1C (Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * __this, int32_t ___index0, const RuntimeMethod* method);
// System.Int32 UnityEngine.Transform::get_childCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Transform_get_childCount_mCBED4F6D3F6A7386C4D97C2C3FD25C383A0BCD05 (Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.UnhandledExceptionHandler/<>c::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__ctor_mB628041C94E761F86F2A26819A038D6BC59E324D (U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF * __this, const RuntimeMethod* method);
// System.Object System.UnhandledExceptionEventArgs::get_ExceptionObject()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR RuntimeObject * UnhandledExceptionEventArgs_get_ExceptionObject_mCC83AA77B4F250C371EEE194025341F757724E90_inline (UnhandledExceptionEventArgs_tFA66D5AA8F6337DEF8E2B494B3B8C377C9FDB885 * __this, const RuntimeMethod* method);
// System.Void UnityEngine.Debug::LogException(System.Exception)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Debug_LogException_m1BE957624F4DD291B1B4265D4A55A34EFAA8D7BA (Exception_t * ___exception0, const RuntimeMethod* method);
// System.Void UnityEngine.UnitySynchronizationContext/WorkRequest::.ctor(System.Threading.SendOrPostCallback,System.Object,System.Threading.ManualResetEvent)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WorkRequest__ctor_m13C7B4A89E47F4B97ED9B786DB99849DBC2B5603 (WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 * __this, SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * ___callback0, RuntimeObject * ___state1, ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___waitHandle2, const RuntimeMethod* method);
// System.Void System.Threading.SendOrPostCallback::Invoke(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SendOrPostCallback_Invoke_m352534ED0E61440A793944CC44809F666BBC1461 (SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * __this, RuntimeObject * ___state0, const RuntimeMethod* method);
// System.Boolean System.Threading.EventWaitHandle::Set()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EventWaitHandle_Set_m81764C887F38A1153224557B26CD688B59987B38 (EventWaitHandle_t80CDEB33529EF7549E7D3E3B689D8272B9F37F3C * __this, const RuntimeMethod* method);
// System.Void UnityEngine.UnitySynchronizationContext/WorkRequest::Invoke()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WorkRequest_Invoke_m1C292B7297918C5F2DBE70971895FE8D5C33AA20 (WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 * __this, const RuntimeMethod* method);
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_OnPhotoModeStartedCallback_t21FCF86FB7933100968EE01A7B4BFB751F53EF92 (OnPhotoModeStartedCallback_t21FCF86FB7933100968EE01A7B4BFB751F53EF92 * __this, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 ___result0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)(PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 );
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Native function invocation
il2cppPInvokeFunc(___result0);
}
// System.Void UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStartedCallback::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnPhotoModeStartedCallback__ctor_mD122FA9A03DF5DD7A950ADD2DE0E1061779415B8 (OnPhotoModeStartedCallback_t21FCF86FB7933100968EE01A7B4BFB751F53EF92 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStartedCallback::Invoke(UnityEngine.Windows.WebCam.PhotoCapture_PhotoCaptureResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnPhotoModeStartedCallback_Invoke_m243CF5632026C05A11143C2A52CEA80A8B46AAB3 (OnPhotoModeStartedCallback_t21FCF86FB7933100968EE01A7B4BFB751F53EF92 * __this, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 ___result0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 >::Invoke(targetMethod, targetThis, ___result0);
else
GenericVirtActionInvoker1< PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 >::Invoke(targetMethod, targetThis, ___result0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___result0);
else
VirtActionInvoker1< PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___result0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___result0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStartedCallback::BeginInvoke(UnityEngine.Windows.WebCam.PhotoCapture_PhotoCaptureResult,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* OnPhotoModeStartedCallback_BeginInvoke_m4AB861825C43FBA4BB652B26EF01085FEF25B0CD (OnPhotoModeStartedCallback_t21FCF86FB7933100968EE01A7B4BFB751F53EF92 * __this, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 ___result0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (OnPhotoModeStartedCallback_BeginInvoke_m4AB861825C43FBA4BB652B26EF01085FEF25B0CD_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226_il2cpp_TypeInfo_var, &___result0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStartedCallback::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnPhotoModeStartedCallback_EndInvoke_m0FA93D4397AEC6F2EA56B65863308AD72B017B0B (OnPhotoModeStartedCallback_t21FCF86FB7933100968EE01A7B4BFB751F53EF92 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_OnPhotoModeStoppedCallback_tF6A2F039E1A8DB64BD4CF25675BED44F74E5B1F6 (OnPhotoModeStoppedCallback_tF6A2F039E1A8DB64BD4CF25675BED44F74E5B1F6 * __this, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 ___result0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)(PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 );
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Native function invocation
il2cppPInvokeFunc(___result0);
}
// System.Void UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStoppedCallback::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnPhotoModeStoppedCallback__ctor_mF8240EE3B1A20732ED29A0CF0D1CCE30CD838E6B (OnPhotoModeStoppedCallback_tF6A2F039E1A8DB64BD4CF25675BED44F74E5B1F6 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStoppedCallback::Invoke(UnityEngine.Windows.WebCam.PhotoCapture_PhotoCaptureResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnPhotoModeStoppedCallback_Invoke_mC55D72686C2EE6D124859D426C76835DD3CDAAF6 (OnPhotoModeStoppedCallback_tF6A2F039E1A8DB64BD4CF25675BED44F74E5B1F6 * __this, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 ___result0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 >::Invoke(targetMethod, targetThis, ___result0);
else
GenericVirtActionInvoker1< PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 >::Invoke(targetMethod, targetThis, ___result0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___result0);
else
VirtActionInvoker1< PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___result0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___result0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStoppedCallback::BeginInvoke(UnityEngine.Windows.WebCam.PhotoCapture_PhotoCaptureResult,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* OnPhotoModeStoppedCallback_BeginInvoke_m70BAC41BE079FC59B70B141F732DCE97FA7BC5AA (OnPhotoModeStoppedCallback_tF6A2F039E1A8DB64BD4CF25675BED44F74E5B1F6 * __this, PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226 ___result0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (OnPhotoModeStoppedCallback_BeginInvoke_m70BAC41BE079FC59B70B141F732DCE97FA7BC5AA_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(PhotoCaptureResult_t52FACAF7EF0D013BFE3E7DA93629702818507226_il2cpp_TypeInfo_var, &___result0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.WebCam.PhotoCapture_OnPhotoModeStoppedCallback::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnPhotoModeStoppedCallback_EndInvoke_m1DCAE195481843479432344016A8E634D6023E07 (OnPhotoModeStoppedCallback_tF6A2F039E1A8DB64BD4CF25675BED44F74E5B1F6 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_ErrorDelegate_t4E0F6E50E9C786DB72C82D69540E01FB9EFD3D9C (ErrorDelegate_t4E0F6E50E9C786DB72C82D69540E01FB9EFD3D9C * __this, int32_t ___errorCode0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)(int32_t);
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Native function invocation
il2cppPInvokeFunc(___errorCode0);
}
// System.Void UnityEngine.Windows.Speech.PhraseRecognitionSystem_ErrorDelegate::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ErrorDelegate__ctor_m2F691DE208DD6430077E3C17D4A5293AA9002FF4 (ErrorDelegate_t4E0F6E50E9C786DB72C82D69540E01FB9EFD3D9C * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.Speech.PhraseRecognitionSystem_ErrorDelegate::Invoke(UnityEngine.Windows.Speech.SpeechError)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ErrorDelegate_Invoke_m46CECD81317CD9717E11456CA73E6B14B88E6724 (ErrorDelegate_t4E0F6E50E9C786DB72C82D69540E01FB9EFD3D9C * __this, int32_t ___errorCode0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___errorCode0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___errorCode0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___errorCode0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< int32_t >::Invoke(targetMethod, targetThis, ___errorCode0);
else
GenericVirtActionInvoker1< int32_t >::Invoke(targetMethod, targetThis, ___errorCode0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___errorCode0);
else
VirtActionInvoker1< int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___errorCode0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___errorCode0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___errorCode0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.Speech.PhraseRecognitionSystem_ErrorDelegate::BeginInvoke(UnityEngine.Windows.Speech.SpeechError,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* ErrorDelegate_BeginInvoke_mD2A98805D514FF2FE986EAB635AECA18A6CB42F8 (ErrorDelegate_t4E0F6E50E9C786DB72C82D69540E01FB9EFD3D9C * __this, int32_t ___errorCode0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ErrorDelegate_BeginInvoke_mD2A98805D514FF2FE986EAB635AECA18A6CB42F8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(SpeechError_t3B8EC653706113444C6077B380A8FD5DF407EC8F_il2cpp_TypeInfo_var, &___errorCode0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.Speech.PhraseRecognitionSystem_ErrorDelegate::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ErrorDelegate_EndInvoke_mBA12D5FE7D6C9A5615AF473703969C011EDCCA3B (ErrorDelegate_t4E0F6E50E9C786DB72C82D69540E01FB9EFD3D9C * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_StatusDelegate_tD751E0623EDFECE1A8492E9DB58E762EFC0D2528 (StatusDelegate_tD751E0623EDFECE1A8492E9DB58E762EFC0D2528 * __this, int32_t ___status0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)(int32_t);
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Native function invocation
il2cppPInvokeFunc(___status0);
}
// System.Void UnityEngine.Windows.Speech.PhraseRecognitionSystem_StatusDelegate::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StatusDelegate__ctor_m8D463CDB5084EA78077004167A884277C11C8580 (StatusDelegate_tD751E0623EDFECE1A8492E9DB58E762EFC0D2528 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.Speech.PhraseRecognitionSystem_StatusDelegate::Invoke(UnityEngine.Windows.Speech.SpeechSystemStatus)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StatusDelegate_Invoke_m04916521B4B6FD2EAFF4A9DF96628F8C34E0C8E2 (StatusDelegate_tD751E0623EDFECE1A8492E9DB58E762EFC0D2528 * __this, int32_t ___status0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___status0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___status0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___status0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< int32_t >::Invoke(targetMethod, targetThis, ___status0);
else
GenericVirtActionInvoker1< int32_t >::Invoke(targetMethod, targetThis, ___status0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___status0);
else
VirtActionInvoker1< int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___status0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___status0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___status0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.Speech.PhraseRecognitionSystem_StatusDelegate::BeginInvoke(UnityEngine.Windows.Speech.SpeechSystemStatus,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* StatusDelegate_BeginInvoke_m5E20320BB35F9113700B3DA0DFAEF01DEE14DAC8 (StatusDelegate_tD751E0623EDFECE1A8492E9DB58E762EFC0D2528 * __this, int32_t ___status0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (StatusDelegate_BeginInvoke_m5E20320BB35F9113700B3DA0DFAEF01DEE14DAC8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(SpeechSystemStatus_t9D1FF73360901F27A8117402D1F5BCC7E1309BF5_il2cpp_TypeInfo_var, &___status0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.Speech.PhraseRecognitionSystem_StatusDelegate::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StatusDelegate_EndInvoke_mADE8C786A44A85CB58AEA7976CFC6E5B9E95078F (StatusDelegate_tD751E0623EDFECE1A8492E9DB58E762EFC0D2528 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Windows.Speech.PhraseRecognizer_PhraseRecognizedDelegate::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void PhraseRecognizedDelegate__ctor_m01A9360909C670C8869C24BB40DC38C2EFCAA03C (PhraseRecognizedDelegate_t13C88401D803DCE6F7A0250C3C86F0FF1FD8662F * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.Speech.PhraseRecognizer_PhraseRecognizedDelegate::Invoke(UnityEngine.Windows.Speech.PhraseRecognizedEventArgs)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void PhraseRecognizedDelegate_Invoke_m492CAE6A50A50603EFFC20E55A5E600B3F44567E (PhraseRecognizedDelegate_t13C88401D803DCE6F7A0250C3C86F0FF1FD8662F * __this, PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF ___args0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___args0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___args0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___args0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF >::Invoke(targetMethod, targetThis, ___args0);
else
GenericVirtActionInvoker1< PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF >::Invoke(targetMethod, targetThis, ___args0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___args0);
else
VirtActionInvoker1< PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___args0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___args0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___args0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.Speech.PhraseRecognizer_PhraseRecognizedDelegate::BeginInvoke(UnityEngine.Windows.Speech.PhraseRecognizedEventArgs,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* PhraseRecognizedDelegate_BeginInvoke_m7AA286808D7E2C74F4ABA0C33D494837575D1056 (PhraseRecognizedDelegate_t13C88401D803DCE6F7A0250C3C86F0FF1FD8662F * __this, PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF ___args0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (PhraseRecognizedDelegate_BeginInvoke_m7AA286808D7E2C74F4ABA0C33D494837575D1056_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(PhraseRecognizedEventArgs_tC5746BBD42781AC39F1A02EACCF7CF8950AE6BEF_il2cpp_TypeInfo_var, &___args0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.Speech.PhraseRecognizer_PhraseRecognizedDelegate::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void PhraseRecognizedDelegate_EndInvoke_m1807091CC1EADD5595504824A06518F6E93045DE (PhraseRecognizedDelegate_t13C88401D803DCE6F7A0250C3C86F0FF1FD8662F * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 DelegatePInvokeWrapper_CreateOutputMethod_t7A129D00E8823B50AEDD0C9B082C9CB3DF863876 (CreateOutputMethod_t7A129D00E8823B50AEDD0C9B082C9CB3DF863876 * __this, PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A ___graph0, String_t* ___name1, const RuntimeMethod* method)
{
typedef PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 (DEFAULT_CALL *PInvokeFunc)(PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A , char*);
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Marshaling of parameter '___name1' to native representation
char* ____name1_marshaled = NULL;
____name1_marshaled = il2cpp_codegen_marshal_string(___name1);
// Native function invocation
PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 returnValue = il2cppPInvokeFunc(___graph0, ____name1_marshaled);
// Marshaling cleanup of parameter '___name1' native representation
il2cpp_codegen_marshal_free(____name1_marshaled);
____name1_marshaled = NULL;
return returnValue;
}
// System.Void UnityEngine.Playables.PlayableBinding_CreateOutputMethod::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CreateOutputMethod__ctor_m944A1B790F35F52E108EF2CC13BA02BD8DE62EB3 (CreateOutputMethod_t7A129D00E8823B50AEDD0C9B082C9CB3DF863876 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// UnityEngine.Playables.PlayableOutput UnityEngine.Playables.PlayableBinding_CreateOutputMethod::Invoke(UnityEngine.Playables.PlayableGraph,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 CreateOutputMethod_Invoke_mFD551E15D9A6FD8B2C70A2CC96AAD0D2D9D3D109 (CreateOutputMethod_t7A129D00E8823B50AEDD0C9B082C9CB3DF863876 * __this, PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A ___graph0, String_t* ___name1, const RuntimeMethod* method)
{
PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 result;
memset((&result), 0, sizeof(result));
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 2)
{
// open
typedef PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 (*FunctionPointerType) (PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A , String_t*, const RuntimeMethod*);
result = ((FunctionPointerType)targetMethodPointer)(___graph0, ___name1, targetMethod);
}
else
{
// closed
typedef PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 (*FunctionPointerType) (void*, PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A , String_t*, const RuntimeMethod*);
result = ((FunctionPointerType)targetMethodPointer)(targetThis, ___graph0, ___name1, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 (*FunctionPointerType) (PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A , String_t*, const RuntimeMethod*);
result = ((FunctionPointerType)targetMethodPointer)(___graph0, ___name1, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
result = GenericInterfaceFuncInvoker2< PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 , PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A , String_t* >::Invoke(targetMethod, targetThis, ___graph0, ___name1);
else
result = GenericVirtFuncInvoker2< PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 , PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A , String_t* >::Invoke(targetMethod, targetThis, ___graph0, ___name1);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
result = InterfaceFuncInvoker2< PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 , PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A , String_t* >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___graph0, ___name1);
else
result = VirtFuncInvoker2< PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 , PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A , String_t* >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___graph0, ___name1);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 (*FunctionPointerType) (RuntimeObject*, String_t*, const RuntimeMethod*);
result = ((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___graph0) - 1), ___name1, targetMethod);
}
else
{
typedef PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 (*FunctionPointerType) (void*, PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A , String_t*, const RuntimeMethod*);
result = ((FunctionPointerType)targetMethodPointer)(targetThis, ___graph0, ___name1, targetMethod);
}
}
}
}
return result;
}
// System.IAsyncResult UnityEngine.Playables.PlayableBinding_CreateOutputMethod::BeginInvoke(UnityEngine.Playables.PlayableGraph,System.String,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* CreateOutputMethod_BeginInvoke_m082AE47F9DFBF0C1787081D2D628E0E5CECCBFF1 (CreateOutputMethod_t7A129D00E8823B50AEDD0C9B082C9CB3DF863876 * __this, PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A ___graph0, String_t* ___name1, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (CreateOutputMethod_BeginInvoke_m082AE47F9DFBF0C1787081D2D628E0E5CECCBFF1_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = Box(PlayableGraph_t2D5083CFACB413FA1BB13FF054BE09A5A55A205A_il2cpp_TypeInfo_var, &___graph0);
__d_args[1] = ___name1;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// UnityEngine.Playables.PlayableOutput UnityEngine.Playables.PlayableBinding_CreateOutputMethod::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 CreateOutputMethod_EndInvoke_mAA7AE5BF9E6A38C081A972827A16497ACA9FA9CE (CreateOutputMethod_t7A129D00E8823B50AEDD0C9B082C9CB3DF863876 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
RuntimeObject *__result = il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
return *(PlayableOutput_tE735DC774F014DB1711310988F2F914C66520F82 *)UnBox ((RuntimeObject*)__result);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass12_0::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__DisplayClass12_0__ctor_m66E5B9C72A27F0645F9854522ACE087CE32A5EEE (U3CU3Ec__DisplayClass12_0_tC029C4F11E384EFEF6FD86B7BEC83D295D098769 * __this, const RuntimeMethod* method)
{
{
Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405(__this, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass12_0::<Register>b__0(UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool U3CU3Ec__DisplayClass12_0_U3CRegisterU3Eb__0_m27C1416BAD7AF0A1BF83339C8A03865A6487B234 (U3CU3Ec__DisplayClass12_0_tC029C4F11E384EFEF6FD86B7BEC83D295D098769 * __this, MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * ___x0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (U3CU3Ec__DisplayClass12_0_U3CRegisterU3Eb__0_m27C1416BAD7AF0A1BF83339C8A03865A6487B234_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * L_0 = ___x0;
NullCheck(L_0);
Guid_t L_1 = MessageTypeSubscribers_get_MessageTypeId_m5A873C55E97728BD12BA52B5DB72FFA366992DD9(L_0, /*hidden argument*/NULL);
Guid_t L_2 = __this->get_messageId_0();
IL2CPP_RUNTIME_CLASS_INIT(Guid_t_il2cpp_TypeInfo_var);
bool L_3 = Guid_op_Equality_m4C2AA9C31D173525E381965A7246814B4C74D5B0(L_1, L_2, /*hidden argument*/NULL);
return L_3;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass13_0::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__DisplayClass13_0__ctor_m75A8930EBA7C6BF81519358930656DAA2FBDDEDB (U3CU3Ec__DisplayClass13_0_t1A8EBE4E3370D09549DE4FD59077B3A7AEAD0C54 * __this, const RuntimeMethod* method)
{
{
Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405(__this, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass13_0::<Unregister>b__0(UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool U3CU3Ec__DisplayClass13_0_U3CUnregisterU3Eb__0_mBA34804D7BB1B4FFE45D077BBB07BFA81C8DCB00 (U3CU3Ec__DisplayClass13_0_t1A8EBE4E3370D09549DE4FD59077B3A7AEAD0C54 * __this, MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * ___x0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (U3CU3Ec__DisplayClass13_0_U3CUnregisterU3Eb__0_mBA34804D7BB1B4FFE45D077BBB07BFA81C8DCB00_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * L_0 = ___x0;
NullCheck(L_0);
Guid_t L_1 = MessageTypeSubscribers_get_MessageTypeId_m5A873C55E97728BD12BA52B5DB72FFA366992DD9(L_0, /*hidden argument*/NULL);
Guid_t L_2 = __this->get_messageId_0();
IL2CPP_RUNTIME_CLASS_INIT(Guid_t_il2cpp_TypeInfo_var);
bool L_3 = Guid_op_Equality_m4C2AA9C31D173525E381965A7246814B4C74D5B0(L_1, L_2, /*hidden argument*/NULL);
return L_3;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass20_0::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__DisplayClass20_0__ctor_m2B215926A23E33037D754DFAFDF8459D82243683 (U3CU3Ec__DisplayClass20_0_tEA47E236E3FCEC75772DAF52911B35E8F14766DD * __this, const RuntimeMethod* method)
{
{
Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerConnection_<>c__DisplayClass20_0::<BlockUntilRecvMsg>b__0(UnityEngine.Networking.PlayerConnection.MessageEventArgs)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__DisplayClass20_0_U3CBlockUntilRecvMsgU3Eb__0_m1D6C3976419CFCE0B612D04C135A985707C215E2 (U3CU3Ec__DisplayClass20_0_tEA47E236E3FCEC75772DAF52911B35E8F14766DD * __this, MessageEventArgs_t6905F6AA12A37C5A38BBCB907E9215622364DCCA * ___args0, const RuntimeMethod* method)
{
{
__this->set_msgReceived_0((bool)1);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass6_0::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__DisplayClass6_0__ctor_mEB8DB2BFDA9F6F083E77F1EC1CE3F4861CD1815A (U3CU3Ec__DisplayClass6_0_t96633FB6A2AE351A4A3FCDF89D10891DA07AD54F * __this, const RuntimeMethod* method)
{
{
Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405(__this, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass6_0::<InvokeMessageIdSubscribers>b__0(UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool U3CU3Ec__DisplayClass6_0_U3CInvokeMessageIdSubscribersU3Eb__0_mEF5D5DFC8F7C2CEC86378AC3BBD40E80A1D9C615 (U3CU3Ec__DisplayClass6_0_t96633FB6A2AE351A4A3FCDF89D10891DA07AD54F * __this, MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * ___x0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (U3CU3Ec__DisplayClass6_0_U3CInvokeMessageIdSubscribersU3Eb__0_mEF5D5DFC8F7C2CEC86378AC3BBD40E80A1D9C615_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * L_0 = ___x0;
NullCheck(L_0);
Guid_t L_1 = MessageTypeSubscribers_get_MessageTypeId_m5A873C55E97728BD12BA52B5DB72FFA366992DD9(L_0, /*hidden argument*/NULL);
Guid_t L_2 = __this->get_messageId_0();
IL2CPP_RUNTIME_CLASS_INIT(Guid_t_il2cpp_TypeInfo_var);
bool L_3 = Guid_op_Equality_m4C2AA9C31D173525E381965A7246814B4C74D5B0(L_1, L_2, /*hidden argument*/NULL);
return L_3;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass7_0::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__DisplayClass7_0__ctor_m97B67DA8AA306A160A790CCDD869669878DDB7F3 (U3CU3Ec__DisplayClass7_0_t7C625D285CBB757F88C0232D12D88EDABF06EB60 * __this, const RuntimeMethod* method)
{
{
Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405(__this, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass7_0::<AddAndCreate>b__0(UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool U3CU3Ec__DisplayClass7_0_U3CAddAndCreateU3Eb__0_mAA3D205F35F7BE200A5DDD14099F56312FBED909 (U3CU3Ec__DisplayClass7_0_t7C625D285CBB757F88C0232D12D88EDABF06EB60 * __this, MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * ___x0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (U3CU3Ec__DisplayClass7_0_U3CAddAndCreateU3Eb__0_mAA3D205F35F7BE200A5DDD14099F56312FBED909_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * L_0 = ___x0;
NullCheck(L_0);
Guid_t L_1 = MessageTypeSubscribers_get_MessageTypeId_m5A873C55E97728BD12BA52B5DB72FFA366992DD9(L_0, /*hidden argument*/NULL);
Guid_t L_2 = __this->get_messageId_0();
IL2CPP_RUNTIME_CLASS_INIT(Guid_t_il2cpp_TypeInfo_var);
bool L_3 = Guid_op_Equality_m4C2AA9C31D173525E381965A7246814B4C74D5B0(L_1, L_2, /*hidden argument*/NULL);
return L_3;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass8_0::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__DisplayClass8_0__ctor_m18AC0B2825D7BB04F59DC800DFF74D45921A28FA (U3CU3Ec__DisplayClass8_0_tE64E7CAC5415DCD425D14A6062600087CC872B93 * __this, const RuntimeMethod* method)
{
{
Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405(__this, /*hidden argument*/NULL);
return;
}
}
// System.Boolean UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_<>c__DisplayClass8_0::<UnregisterManagedCallback>b__0(UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool U3CU3Ec__DisplayClass8_0_U3CUnregisterManagedCallbackU3Eb__0_m70805C4CE0F8DD258CC3975A8C90313A0A609BE3 (U3CU3Ec__DisplayClass8_0_tE64E7CAC5415DCD425D14A6062600087CC872B93 * __this, MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * ___x0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (U3CU3Ec__DisplayClass8_0_U3CUnregisterManagedCallbackU3Eb__0_m70805C4CE0F8DD258CC3975A8C90313A0A609BE3_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * L_0 = ___x0;
NullCheck(L_0);
Guid_t L_1 = MessageTypeSubscribers_get_MessageTypeId_m5A873C55E97728BD12BA52B5DB72FFA366992DD9(L_0, /*hidden argument*/NULL);
Guid_t L_2 = __this->get_messageId_0();
IL2CPP_RUNTIME_CLASS_INIT(Guid_t_il2cpp_TypeInfo_var);
bool L_3 = Guid_op_Equality_m4C2AA9C31D173525E381965A7246814B4C74D5B0(L_1, L_2, /*hidden argument*/NULL);
return L_3;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_ConnectionChangeEvent::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ConnectionChangeEvent__ctor_m95EBD8B5EA1C4A14A5F2B71CEE1A2C18C73DB0A1 (ConnectionChangeEvent_tCA1C8C14171C72EC394EF45450D69C1585067BDF * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ConnectionChangeEvent__ctor_m95EBD8B5EA1C4A14A5F2B71CEE1A2C18C73DB0A1_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
UnityEvent_1__ctor_m30F443398054B5E3666B3C86E64A5C0FF97D93FF(__this, /*hidden argument*/UnityEvent_1__ctor_m30F443398054B5E3666B3C86E64A5C0FF97D93FF_RuntimeMethod_var);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageEvent::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void MessageEvent__ctor_mE4D70D8837C51E422C9A40C3F8F34ACB9AB572BB (MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (MessageEvent__ctor_mE4D70D8837C51E422C9A40C3F8F34ACB9AB572BB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
UnityEvent_1__ctor_mC7E63F58C7EFC8E8747E3619B7564A7325F03D3B(__this, /*hidden argument*/UnityEvent_1__ctor_mC7E63F58C7EFC8E8747E3619B7564A7325F03D3B_RuntimeMethod_var);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Guid UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers::get_MessageTypeId()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Guid_t MessageTypeSubscribers_get_MessageTypeId_m5A873C55E97728BD12BA52B5DB72FFA366992DD9 (MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * __this, const RuntimeMethod* method)
{
Guid_t V_0;
memset((&V_0), 0, sizeof(V_0));
{
String_t* L_0 = __this->get_m_messageTypeId_0();
Guid_t L_1;
memset((&L_1), 0, sizeof(L_1));
Guid__ctor_mF80313305B9CD2AD39B621E1CEC5C7DFDFFBDE66((&L_1), L_0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_000f;
}
IL_000f:
{
Guid_t L_2 = V_0;
return L_2;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers::set_MessageTypeId(System.Guid)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void MessageTypeSubscribers_set_MessageTypeId_m7125FF3E71F4E678644F056A4DC5C29EFB749762 (MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * __this, Guid_t ___value0, const RuntimeMethod* method)
{
{
String_t* L_0 = Guid_ToString_mA3AB7742FB0E04808F580868E82BDEB93187FB75((Guid_t *)(&___value0), /*hidden argument*/NULL);
__this->set_m_messageTypeId_0(L_0);
return;
}
}
// System.Void UnityEngine.Networking.PlayerConnection.PlayerEditorConnectionEvents_MessageTypeSubscribers::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void MessageTypeSubscribers__ctor_mA51A6D3E38DBAA5B8237BAB1688F669F24982F29 (MessageTypeSubscribers_t7A69A1D132BF9A354D94F9E490E148BBB81A508F * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (MessageTypeSubscribers__ctor_mA51A6D3E38DBAA5B8237BAB1688F669F24982F29_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
__this->set_subscriberCount_1(0);
MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B * L_0 = (MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B *)il2cpp_codegen_object_new(MessageEvent_tF0C632D7EBE9C4B2B91E20F2AA4B593D1B55469B_il2cpp_TypeInfo_var);
MessageEvent__ctor_mE4D70D8837C51E422C9A40C3F8F34ACB9AB572BB(L_0, /*hidden argument*/NULL);
__this->set_messageCallback_2(L_0);
Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405(__this, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_UpdateFunction_tEDC2A88F61F179480CAA9443E6ADDA3F126B8AEA (UpdateFunction_tEDC2A88F61F179480CAA9443E6ADDA3F126B8AEA * __this, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)();
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Native function invocation
il2cppPInvokeFunc();
}
// System.Void UnityEngine.LowLevel.PlayerLoopSystem_UpdateFunction::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UpdateFunction__ctor_mB10AB83A3F547AC95FF726E8A7B5FF9C16EC1319 (UpdateFunction_tEDC2A88F61F179480CAA9443E6ADDA3F126B8AEA * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.LowLevel.PlayerLoopSystem_UpdateFunction::Invoke()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UpdateFunction_Invoke_mB17C55B92FAECE51078028F59A9F1EAC2016B1AD (UpdateFunction_tEDC2A88F61F179480CAA9443E6ADDA3F126B8AEA * __this, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 0)
{
// open
typedef void (*FunctionPointerType) (const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker0::Invoke(targetMethod, targetThis);
else
GenericVirtActionInvoker0::Invoke(targetMethod, targetThis);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis);
else
VirtActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis);
}
}
else
{
typedef void (*FunctionPointerType) (void*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, targetMethod);
}
}
}
}
// System.IAsyncResult UnityEngine.LowLevel.PlayerLoopSystem_UpdateFunction::BeginInvoke(System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* UpdateFunction_BeginInvoke_m1EB0935AB72A286D153ACEBD0E5D66BB38BD6799 (UpdateFunction_tEDC2A88F61F179480CAA9443E6ADDA3F126B8AEA * __this, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback0, RuntimeObject * ___object1, const RuntimeMethod* method)
{
void *__d_args[1] = {0};
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback0, (RuntimeObject*)___object1);
}
// System.Void UnityEngine.LowLevel.PlayerLoopSystem_UpdateFunction::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UpdateFunction_EndInvoke_mB4BC0AA40E9C83274116DF6467D72DD4902DA624 (UpdateFunction_tEDC2A88F61F179480CAA9443E6ADDA3F126B8AEA * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void Unity.Profiling.ProfilerMarker_AutoScope::.ctor(System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AutoScope__ctor_m4131730A501F687FF95B2963EABAC7844C6B9859 (AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D * __this, intptr_t ___markerPtr0, const RuntimeMethod* method)
{
{
intptr_t L_0 = ___markerPtr0;
__this->set_m_Ptr_0((intptr_t)L_0);
intptr_t L_1 = ___markerPtr0;
ProfilerUnsafeUtility_BeginSample_m1B2CAD1BC7C7C390514317A8D51FB798D4622AE4((intptr_t)L_1, /*hidden argument*/NULL);
return;
}
}
IL2CPP_EXTERN_C void AutoScope__ctor_m4131730A501F687FF95B2963EABAC7844C6B9859_AdjustorThunk (RuntimeObject * __this, intptr_t ___markerPtr0, const RuntimeMethod* method)
{
int32_t _offset = 1;
AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D * _thisAdjusted = reinterpret_cast<AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D *>(__this + _offset);
AutoScope__ctor_m4131730A501F687FF95B2963EABAC7844C6B9859_inline(_thisAdjusted, ___markerPtr0, method);
}
// System.Void Unity.Profiling.ProfilerMarker_AutoScope::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AutoScope_Dispose_m5CDDCDA2B8769738BB695661EC4AC55DD7A0D7CA (AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D * __this, const RuntimeMethod* method)
{
{
intptr_t L_0 = __this->get_m_Ptr_0();
ProfilerUnsafeUtility_EndSample_m0435B2EE7963614F3D154A83D44269FE4D1A85B0((intptr_t)L_0, /*hidden argument*/NULL);
return;
}
}
IL2CPP_EXTERN_C void AutoScope_Dispose_m5CDDCDA2B8769738BB695661EC4AC55DD7A0D7CA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D * _thisAdjusted = reinterpret_cast<AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D *>(__this + _offset);
AutoScope_Dispose_m5CDDCDA2B8769738BB695661EC4AC55DD7A0D7CA_inline(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.RectTransform_ReapplyDrivenProperties::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReapplyDrivenProperties__ctor_mD584B5E4A07E3D025352EA0BAE9B10FE5C13A583 (ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.RectTransform_ReapplyDrivenProperties::Invoke(UnityEngine.RectTransform)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReapplyDrivenProperties_Invoke_m5B39EC5205C3910AC09DCF378EAA2D8E99391636 (ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * __this, RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 * ___driven0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___driven0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___driven0, targetMethod);
}
}
else if (___parameterCount != 1)
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker0::Invoke(targetMethod, ___driven0);
else
GenericVirtActionInvoker0::Invoke(targetMethod, ___driven0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___driven0);
else
VirtActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___driven0);
}
}
else
{
typedef void (*FunctionPointerType) (RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___driven0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___driven0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 * >::Invoke(targetMethod, targetThis, ___driven0);
else
GenericVirtActionInvoker1< RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 * >::Invoke(targetMethod, targetThis, ___driven0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___driven0);
else
VirtActionInvoker1< RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___driven0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___driven0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___driven0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.RectTransform_ReapplyDrivenProperties::BeginInvoke(UnityEngine.RectTransform,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* ReapplyDrivenProperties_BeginInvoke_mC7625A8FDFF392D73C7828526490DCB88FD87232 (ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * __this, RectTransform_t8A6A306FB29A6C8C22010CF9040E319753571072 * ___driven0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
void *__d_args[2] = {0};
__d_args[0] = ___driven0;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.RectTransform_ReapplyDrivenProperties::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReapplyDrivenProperties_EndInvoke_m89A593999C130CA23515BF8A9C02DDE5B39ECF67 (ReapplyDrivenProperties_t1441259DADA8FE33A95334AC24C017DFA3DEB4CE * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.TextAsset_EncodingUtility::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EncodingUtility__cctor_m6BADEB7670563CC438C10AF259028A7FF06AD65F (const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EncodingUtility__cctor_m6BADEB7670563CC438C10AF259028A7FF06AD65F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * V_0 = NULL;
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * V_1 = NULL;
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * V_2 = NULL;
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * V_3 = NULL;
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * V_4 = NULL;
{
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_0 = Encoding_get_UTF8_mC877FB3137BBD566AEE7B15F9BF61DC4EF8F5E5E(/*hidden argument*/NULL);
NullCheck(L_0);
int32_t L_1 = VirtFuncInvoker0< int32_t >::Invoke(36 /* System.Int32 System.Text.Encoding::get_CodePage() */, L_0);
EncoderReplacementFallback_t61E36A507D7FA8034B49F86DBE560EC77A6A8418 * L_2 = (EncoderReplacementFallback_t61E36A507D7FA8034B49F86DBE560EC77A6A8418 *)il2cpp_codegen_object_new(EncoderReplacementFallback_t61E36A507D7FA8034B49F86DBE560EC77A6A8418_il2cpp_TypeInfo_var);
EncoderReplacementFallback__ctor_m07299910DC3D3F6B9F8F37A4ADD40A500F97D1D4(L_2, _stringLiteralB8F710F417E2D96E747683BF53A8CA9BB6B9648C, /*hidden argument*/NULL);
DecoderReplacementFallback_t8DA345EC4EF3A35A2667365F691EE69408A62130 * L_3 = (DecoderReplacementFallback_t8DA345EC4EF3A35A2667365F691EE69408A62130 *)il2cpp_codegen_object_new(DecoderReplacementFallback_t8DA345EC4EF3A35A2667365F691EE69408A62130_il2cpp_TypeInfo_var);
DecoderReplacementFallback__ctor_m7E6C273B2682E373C787568EB0BB0B2E4B6C2253(L_3, _stringLiteralB8F710F417E2D96E747683BF53A8CA9BB6B9648C, /*hidden argument*/NULL);
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_4 = Encoding_GetEncoding_m4DC46FF0C923994EDEE21980037198E27A75E4F2(L_1, L_2, L_3, /*hidden argument*/NULL);
((EncodingUtility_tF25232B383AA56BB15E7955C1C9FC356F9770983_StaticFields*)il2cpp_codegen_static_fields_for(EncodingUtility_tF25232B383AA56BB15E7955C1C9FC356F9770983_il2cpp_TypeInfo_var))->set_targetEncoding_1(L_4);
UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014 * L_5 = (UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014 *)il2cpp_codegen_object_new(UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014_il2cpp_TypeInfo_var);
UTF32Encoding__ctor_mCC6CB31807AE3B57FAF941B59D72D7BA10CFB1FD(L_5, (bool)1, (bool)1, (bool)1, /*hidden argument*/NULL);
V_0 = L_5;
UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014 * L_6 = (UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014 *)il2cpp_codegen_object_new(UTF32Encoding_t54B51C8FAC5B2EAB4BDFACBBA06DB6117A38D014_il2cpp_TypeInfo_var);
UTF32Encoding__ctor_mCC6CB31807AE3B57FAF941B59D72D7BA10CFB1FD(L_6, (bool)0, (bool)1, (bool)1, /*hidden argument*/NULL);
V_1 = L_6;
UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68 * L_7 = (UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68 *)il2cpp_codegen_object_new(UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68_il2cpp_TypeInfo_var);
UnicodeEncoding__ctor_m8D0BFF0DBB175D7E590674E31343E8C72701FC7C(L_7, (bool)1, (bool)1, (bool)1, /*hidden argument*/NULL);
V_2 = L_7;
UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68 * L_8 = (UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68 *)il2cpp_codegen_object_new(UnicodeEncoding_tBB60B97AFC49D6246F28BF16D3E09822FCCACC68_il2cpp_TypeInfo_var);
UnicodeEncoding__ctor_m8D0BFF0DBB175D7E590674E31343E8C72701FC7C(L_8, (bool)0, (bool)1, (bool)1, /*hidden argument*/NULL);
V_3 = L_8;
UTF8Encoding_t6EE88BC62116B5328F6CF4E39C9CC49EED2ED282 * L_9 = (UTF8Encoding_t6EE88BC62116B5328F6CF4E39C9CC49EED2ED282 *)il2cpp_codegen_object_new(UTF8Encoding_t6EE88BC62116B5328F6CF4E39C9CC49EED2ED282_il2cpp_TypeInfo_var);
UTF8Encoding__ctor_mD752778085A353529AF03841383E5603FE556449(L_9, (bool)1, (bool)1, /*hidden argument*/NULL);
V_4 = L_9;
KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7* L_10 = (KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7*)(KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7*)SZArrayNew(KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7_il2cpp_TypeInfo_var, (uint32_t)5);
KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7* L_11 = L_10;
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_12 = V_0;
NullCheck(L_12);
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* L_13 = VirtFuncInvoker0< ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* >::Invoke(6 /* System.Byte[] System.Text.Encoding::GetPreamble() */, L_12);
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_14 = V_0;
KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B L_15;
memset((&L_15), 0, sizeof(L_15));
KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E((&L_15), L_13, L_14, /*hidden argument*/KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E_RuntimeMethod_var);
NullCheck(L_11);
(L_11)->SetAt(static_cast<il2cpp_array_size_t>(0), (KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B )L_15);
KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7* L_16 = L_11;
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_17 = V_1;
NullCheck(L_17);
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* L_18 = VirtFuncInvoker0< ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* >::Invoke(6 /* System.Byte[] System.Text.Encoding::GetPreamble() */, L_17);
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_19 = V_1;
KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B L_20;
memset((&L_20), 0, sizeof(L_20));
KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E((&L_20), L_18, L_19, /*hidden argument*/KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E_RuntimeMethod_var);
NullCheck(L_16);
(L_16)->SetAt(static_cast<il2cpp_array_size_t>(1), (KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B )L_20);
KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7* L_21 = L_16;
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_22 = V_2;
NullCheck(L_22);
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* L_23 = VirtFuncInvoker0< ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* >::Invoke(6 /* System.Byte[] System.Text.Encoding::GetPreamble() */, L_22);
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_24 = V_2;
KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B L_25;
memset((&L_25), 0, sizeof(L_25));
KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E((&L_25), L_23, L_24, /*hidden argument*/KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E_RuntimeMethod_var);
NullCheck(L_21);
(L_21)->SetAt(static_cast<il2cpp_array_size_t>(2), (KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B )L_25);
KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7* L_26 = L_21;
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_27 = V_3;
NullCheck(L_27);
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* L_28 = VirtFuncInvoker0< ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* >::Invoke(6 /* System.Byte[] System.Text.Encoding::GetPreamble() */, L_27);
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_29 = V_3;
KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B L_30;
memset((&L_30), 0, sizeof(L_30));
KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E((&L_30), L_28, L_29, /*hidden argument*/KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E_RuntimeMethod_var);
NullCheck(L_26);
(L_26)->SetAt(static_cast<il2cpp_array_size_t>(3), (KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B )L_30);
KeyValuePair_2U5BU5D_t256F162571C05521448AA203E8C620697614CAE7* L_31 = L_26;
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_32 = V_4;
NullCheck(L_32);
ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* L_33 = VirtFuncInvoker0< ByteU5BU5D_tDBBEB0E8362242FA7223000D978B0DD19D4B0726* >::Invoke(6 /* System.Byte[] System.Text.Encoding::GetPreamble() */, L_32);
Encoding_tE901442411E2E70039D2A4AE77FB81C3D6064827 * L_34 = V_4;
KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B L_35;
memset((&L_35), 0, sizeof(L_35));
KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E((&L_35), L_33, L_34, /*hidden argument*/KeyValuePair_2__ctor_mDCF2A49BD99EBDA9819EAB356D5E65CA66F8754E_RuntimeMethod_var);
NullCheck(L_31);
(L_31)->SetAt(static_cast<il2cpp_array_size_t>(4), (KeyValuePair_2_t3A7CB634D4B37FBC5AD1F3511F36FC672A31B11B )L_35);
((EncodingUtility_tF25232B383AA56BB15E7955C1C9FC356F9770983_StaticFields*)il2cpp_codegen_static_fields_for(EncodingUtility_tF25232B383AA56BB15E7955C1C9FC356F9770983_il2cpp_TypeInfo_var))->set_encodingLookup_0(L_31);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.Transform_Enumerator::.ctor(UnityEngine.Transform)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Enumerator__ctor_m052C22273F1D789E58A09606D5EE5E87ABC2C91B (Enumerator_t8A0B2200373BC9628C065322A1BA07AAA47E0259 * __this, Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * ___outer0, const RuntimeMethod* method)
{
{
__this->set_currentIndex_1((-1));
Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405(__this, /*hidden argument*/NULL);
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * L_0 = ___outer0;
__this->set_outer_0(L_0);
return;
}
}
// System.Object UnityEngine.Transform_Enumerator::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * Enumerator_get_Current_m1CFECBB7AC3EACD05A11CC6848AE7A94A8123E9F (Enumerator_t8A0B2200373BC9628C065322A1BA07AAA47E0259 * __this, const RuntimeMethod* method)
{
RuntimeObject * V_0 = NULL;
{
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * L_0 = __this->get_outer_0();
int32_t L_1 = __this->get_currentIndex_1();
NullCheck(L_0);
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * L_2 = Transform_GetChild_mA7D94BEFF0144F76561D9B8FED61C5C939EC1F1C(L_0, L_1, /*hidden argument*/NULL);
V_0 = L_2;
goto IL_0015;
}
IL_0015:
{
RuntimeObject * L_3 = V_0;
return L_3;
}
}
// System.Boolean UnityEngine.Transform_Enumerator::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Enumerator_MoveNext_m346F9A121D9E89ADBA8296E6A7EF8763C5B58A14 (Enumerator_t8A0B2200373BC9628C065322A1BA07AAA47E0259 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
int32_t V_1 = 0;
bool V_2 = false;
{
Transform_tA8193BB29D4D2C7EC04918F3ED1816345186C3F1 * L_0 = __this->get_outer_0();
NullCheck(L_0);
int32_t L_1 = Transform_get_childCount_mCBED4F6D3F6A7386C4D97C2C3FD25C383A0BCD05(L_0, /*hidden argument*/NULL);
V_0 = L_1;
int32_t L_2 = __this->get_currentIndex_1();
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_2, (int32_t)1));
int32_t L_3 = V_1;
__this->set_currentIndex_1(L_3);
int32_t L_4 = V_1;
int32_t L_5 = V_0;
V_2 = (bool)((((int32_t)L_4) < ((int32_t)L_5))? 1 : 0);
goto IL_0024;
}
IL_0024:
{
bool L_6 = V_2;
return L_6;
}
}
// System.Void UnityEngine.Transform_Enumerator::Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Enumerator_Reset_mFA289646E280C94D82CC223C024E0B615F811C8E (Enumerator_t8A0B2200373BC9628C065322A1BA07AAA47E0259 * __this, const RuntimeMethod* method)
{
{
__this->set_currentIndex_1((-1));
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void UnityEngine.UnhandledExceptionHandler_<>c::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__cctor_m5B3F5B8A2DD74DC42F3E777C1FDD1C880EFA95BA (const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (U3CU3Ec__cctor_m5B3F5B8A2DD74DC42F3E777C1FDD1C880EFA95BA_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF * L_0 = (U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF *)il2cpp_codegen_object_new(U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF_il2cpp_TypeInfo_var);
U3CU3Ec__ctor_mB628041C94E761F86F2A26819A038D6BC59E324D(L_0, /*hidden argument*/NULL);
((U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF_StaticFields*)il2cpp_codegen_static_fields_for(U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF_il2cpp_TypeInfo_var))->set_U3CU3E9_0(L_0);
return;
}
}
// System.Void UnityEngine.UnhandledExceptionHandler_<>c::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec__ctor_mB628041C94E761F86F2A26819A038D6BC59E324D (U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF * __this, const RuntimeMethod* method)
{
{
Object__ctor_m88880E0413421D13FD95325EDCE231707CE1F405(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void UnityEngine.UnhandledExceptionHandler_<>c::<RegisterUECatcher>b__0_0(System.Object,System.UnhandledExceptionEventArgs)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ec_U3CRegisterUECatcherU3Eb__0_0_mB2E6DD6B9C72FA3D5DB8D311DB281F272A587278 (U3CU3Ec_t2E3508EBEE2B43EC58CD7343CEBA1A7D59A4BFFF * __this, RuntimeObject * ___sender0, UnhandledExceptionEventArgs_tFA66D5AA8F6337DEF8E2B494B3B8C377C9FDB885 * ___e1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (U3CU3Ec_U3CRegisterUECatcherU3Eb__0_0_mB2E6DD6B9C72FA3D5DB8D311DB281F272A587278_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
UnhandledExceptionEventArgs_tFA66D5AA8F6337DEF8E2B494B3B8C377C9FDB885 * L_0 = ___e1;
NullCheck(L_0);
RuntimeObject * L_1 = UnhandledExceptionEventArgs_get_ExceptionObject_mCC83AA77B4F250C371EEE194025341F757724E90_inline(L_0, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(Debug_tEB68BCBEB8EFD60F8043C67146DC05E7F50F374B_il2cpp_TypeInfo_var);
Debug_LogException_m1BE957624F4DD291B1B4265D4A55A34EFAA8D7BA(((Exception_t *)IsInstClass((RuntimeObject*)L_1, Exception_t_il2cpp_TypeInfo_var)), /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Conversion methods for marshalling of: UnityEngine.UnitySynchronizationContext/WorkRequest
IL2CPP_EXTERN_C void WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshal_pinvoke(const WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393& unmarshaled, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_pinvoke& marshaled)
{
Exception_t* ___m_WaitHandle_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_WaitHandle' of type 'WorkRequest': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_WaitHandle_2Exception, NULL);
}
IL2CPP_EXTERN_C void WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshal_pinvoke_back(const WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_pinvoke& marshaled, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393& unmarshaled)
{
Exception_t* ___m_WaitHandle_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_WaitHandle' of type 'WorkRequest': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_WaitHandle_2Exception, NULL);
}
// Conversion method for clean up from marshalling of: UnityEngine.UnitySynchronizationContext/WorkRequest
IL2CPP_EXTERN_C void WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshal_pinvoke_cleanup(WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_pinvoke& marshaled)
{
}
// Conversion methods for marshalling of: UnityEngine.UnitySynchronizationContext/WorkRequest
IL2CPP_EXTERN_C void WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshal_com(const WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393& unmarshaled, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_com& marshaled)
{
Exception_t* ___m_WaitHandle_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_WaitHandle' of type 'WorkRequest': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_WaitHandle_2Exception, NULL);
}
IL2CPP_EXTERN_C void WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshal_com_back(const WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_com& marshaled, WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393& unmarshaled)
{
Exception_t* ___m_WaitHandle_2Exception = il2cpp_codegen_get_marshal_directive_exception("Cannot marshal field 'm_WaitHandle' of type 'WorkRequest': Reference type field marshaling is not supported.");
IL2CPP_RAISE_MANAGED_EXCEPTION(___m_WaitHandle_2Exception, NULL);
}
// Conversion method for clean up from marshalling of: UnityEngine.UnitySynchronizationContext/WorkRequest
IL2CPP_EXTERN_C void WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshal_com_cleanup(WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393_marshaled_com& marshaled)
{
}
// System.Void UnityEngine.UnitySynchronizationContext_WorkRequest::.ctor(System.Threading.SendOrPostCallback,System.Object,System.Threading.ManualResetEvent)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WorkRequest__ctor_m13C7B4A89E47F4B97ED9B786DB99849DBC2B5603 (WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 * __this, SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * ___callback0, RuntimeObject * ___state1, ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___waitHandle2, const RuntimeMethod* method)
{
{
SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * L_0 = ___callback0;
__this->set_m_DelagateCallback_0(L_0);
RuntimeObject * L_1 = ___state1;
__this->set_m_DelagateState_1(L_1);
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * L_2 = ___waitHandle2;
__this->set_m_WaitHandle_2(L_2);
return;
}
}
IL2CPP_EXTERN_C void WorkRequest__ctor_m13C7B4A89E47F4B97ED9B786DB99849DBC2B5603_AdjustorThunk (RuntimeObject * __this, SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * ___callback0, RuntimeObject * ___state1, ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * ___waitHandle2, const RuntimeMethod* method)
{
int32_t _offset = 1;
WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 * _thisAdjusted = reinterpret_cast<WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 *>(__this + _offset);
WorkRequest__ctor_m13C7B4A89E47F4B97ED9B786DB99849DBC2B5603(_thisAdjusted, ___callback0, ___state1, ___waitHandle2, method);
}
// System.Void UnityEngine.UnitySynchronizationContext_WorkRequest::Invoke()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void WorkRequest_Invoke_m1C292B7297918C5F2DBE70971895FE8D5C33AA20 (WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (WorkRequest_Invoke_m1C292B7297918C5F2DBE70971895FE8D5C33AA20_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Exception_t * V_0 = NULL;
bool V_1 = false;
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
void* __leave_targets_storage = alloca(sizeof(int32_t) * 2);
il2cpp::utils::LeaveTargetStack __leave_targets(__leave_targets_storage);
NO_UNUSED_WARNING (__leave_targets);
{
}
IL_0001:
try
{ // begin try (depth: 1)
SendOrPostCallback_t6B7334CE017AF595535507519400AC02D688DC3C * L_0 = __this->get_m_DelagateCallback_0();
RuntimeObject * L_1 = __this->get_m_DelagateState_1();
NullCheck(L_0);
SendOrPostCallback_Invoke_m352534ED0E61440A793944CC44809F666BBC1461(L_0, L_1, /*hidden argument*/NULL);
goto IL_0023;
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__exception_local = (Exception_t *)e.ex;
if(il2cpp_codegen_class_is_assignable_from (Exception_t_il2cpp_TypeInfo_var, il2cpp_codegen_object_class(e.ex)))
goto CATCH_0017;
throw e;
}
CATCH_0017:
{ // begin catch(System.Exception)
V_0 = ((Exception_t *)__exception_local);
Exception_t * L_2 = V_0;
IL2CPP_RUNTIME_CLASS_INIT(Debug_tEB68BCBEB8EFD60F8043C67146DC05E7F50F374B_il2cpp_TypeInfo_var);
Debug_LogException_m1BE957624F4DD291B1B4265D4A55A34EFAA8D7BA(L_2, /*hidden argument*/NULL);
goto IL_0023;
} // end catch (depth: 1)
IL_0023:
{
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * L_3 = __this->get_m_WaitHandle_2();
V_1 = (bool)((!(((RuntimeObject*)(ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA *)L_3) <= ((RuntimeObject*)(RuntimeObject *)NULL)))? 1 : 0);
bool L_4 = V_1;
if (!L_4)
{
goto IL_003c;
}
}
{
ManualResetEvent_t9E2ED486907E3A16122ED4E946534E4DD6B5A7BA * L_5 = __this->get_m_WaitHandle_2();
NullCheck(L_5);
EventWaitHandle_Set_m81764C887F38A1153224557B26CD688B59987B38(L_5, /*hidden argument*/NULL);
}
IL_003c:
{
return;
}
}
IL2CPP_EXTERN_C void WorkRequest_Invoke_m1C292B7297918C5F2DBE70971895FE8D5C33AA20_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 * _thisAdjusted = reinterpret_cast<WorkRequest_tA19FD4D1269D8EE2EA886AAF036C4F7F09154393 *>(__this + _offset);
WorkRequest_Invoke_m1C292B7297918C5F2DBE70971895FE8D5C33AA20(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_OnStartedRecordingVideoCallback_tF42862BD94B6DEE3AFBAEC068CB93D2B35E366A9 (OnStartedRecordingVideoCallback_tF42862BD94B6DEE3AFBAEC068CB93D2B35E366A9 * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F );
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Native function invocation
il2cppPInvokeFunc(___result0);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnStartedRecordingVideoCallback::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnStartedRecordingVideoCallback__ctor_m2742271349A83A30DE2116DE61A29174E4186C15 (OnStartedRecordingVideoCallback_tF42862BD94B6DEE3AFBAEC068CB93D2B35E366A9 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnStartedRecordingVideoCallback::Invoke(UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnStartedRecordingVideoCallback_Invoke_mA36E25A3C9AE663053A004D216FFCEF82AEF3790 (OnStartedRecordingVideoCallback_tF42862BD94B6DEE3AFBAEC068CB93D2B35E366A9 * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(targetMethod, targetThis, ___result0);
else
GenericVirtActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(targetMethod, targetThis, ___result0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___result0);
else
VirtActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___result0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___result0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.WebCam.VideoCapture_OnStartedRecordingVideoCallback::BeginInvoke(UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* OnStartedRecordingVideoCallback_BeginInvoke_m1E4D58E53791FAACD887CFB36445C5FEA8F7CD06 (OnStartedRecordingVideoCallback_tF42862BD94B6DEE3AFBAEC068CB93D2B35E366A9 * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (OnStartedRecordingVideoCallback_BeginInvoke_m1E4D58E53791FAACD887CFB36445C5FEA8F7CD06_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F_il2cpp_TypeInfo_var, &___result0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnStartedRecordingVideoCallback::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnStartedRecordingVideoCallback_EndInvoke_m2941925C6B4AFEC5855E18BA32423C56EE0FA2A3 (OnStartedRecordingVideoCallback_tF42862BD94B6DEE3AFBAEC068CB93D2B35E366A9 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_OnStoppedRecordingVideoCallback_t2D7EC27C8904AE0EE068D13F918E42EECF965DD6 (OnStoppedRecordingVideoCallback_t2D7EC27C8904AE0EE068D13F918E42EECF965DD6 * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F );
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Native function invocation
il2cppPInvokeFunc(___result0);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnStoppedRecordingVideoCallback::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnStoppedRecordingVideoCallback__ctor_mDED3B288194CBA9478D42A22F5FA3E20A8FC4D79 (OnStoppedRecordingVideoCallback_t2D7EC27C8904AE0EE068D13F918E42EECF965DD6 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnStoppedRecordingVideoCallback::Invoke(UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnStoppedRecordingVideoCallback_Invoke_m0CB497020C4935AE90335928C7AB897789C91F16 (OnStoppedRecordingVideoCallback_t2D7EC27C8904AE0EE068D13F918E42EECF965DD6 * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(targetMethod, targetThis, ___result0);
else
GenericVirtActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(targetMethod, targetThis, ___result0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___result0);
else
VirtActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___result0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___result0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.WebCam.VideoCapture_OnStoppedRecordingVideoCallback::BeginInvoke(UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* OnStoppedRecordingVideoCallback_BeginInvoke_mA92F3961C471FBD5E16F95840A8CB912E20C54BC (OnStoppedRecordingVideoCallback_t2D7EC27C8904AE0EE068D13F918E42EECF965DD6 * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (OnStoppedRecordingVideoCallback_BeginInvoke_mA92F3961C471FBD5E16F95840A8CB912E20C54BC_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F_il2cpp_TypeInfo_var, &___result0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnStoppedRecordingVideoCallback::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnStoppedRecordingVideoCallback_EndInvoke_m01C378DD8A73D83471A084E63276028C5317D7E2 (OnStoppedRecordingVideoCallback_t2D7EC27C8904AE0EE068D13F918E42EECF965DD6 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_OnVideoCaptureResourceCreatedCallback_t3699FD2DE7FEF286A229B548E358133211BBA956 (OnVideoCaptureResourceCreatedCallback_t3699FD2DE7FEF286A229B548E358133211BBA956 * __this, VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 * ___captureObject0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)(VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshaled_pinvoke*);
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Marshaling of parameter '___captureObject0' to native representation
VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshaled_pinvoke ____captureObject0_marshaled = {};
if (___captureObject0 != NULL)
{
VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshal_pinvoke(*___captureObject0, ____captureObject0_marshaled);
}
// Native function invocation
il2cppPInvokeFunc(___captureObject0 != NULL ? (&____captureObject0_marshaled) : NULL);
// Marshaling of parameter '___captureObject0' back from native representation
if (___captureObject0 != NULL)
{
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_missing_method_exception("A parameterless constructor is required for type 'UnityEngine.Windows.WebCam.VideoCapture'."), NULL);
VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshal_pinvoke_back(____captureObject0_marshaled, *___captureObject0);
}
// Marshaling cleanup of parameter '___captureObject0' native representation
if ((&____captureObject0_marshaled) != NULL)
{
VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91_marshal_pinvoke_cleanup(____captureObject0_marshaled);
}
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnVideoCaptureResourceCreatedCallback::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnVideoCaptureResourceCreatedCallback__ctor_m367E31CF82FCBA5320647F05C0DA9CA047752B59 (OnVideoCaptureResourceCreatedCallback_t3699FD2DE7FEF286A229B548E358133211BBA956 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnVideoCaptureResourceCreatedCallback::Invoke(UnityEngine.Windows.WebCam.VideoCapture)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnVideoCaptureResourceCreatedCallback_Invoke_m57F41946F7DA79E150143DD5882473FA61C84E07 (OnVideoCaptureResourceCreatedCallback_t3699FD2DE7FEF286A229B548E358133211BBA956 * __this, VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 * ___captureObject0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___captureObject0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___captureObject0, targetMethod);
}
}
else if (___parameterCount != 1)
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker0::Invoke(targetMethod, ___captureObject0);
else
GenericVirtActionInvoker0::Invoke(targetMethod, ___captureObject0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___captureObject0);
else
VirtActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___captureObject0);
}
}
else
{
typedef void (*FunctionPointerType) (VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___captureObject0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___captureObject0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 * >::Invoke(targetMethod, targetThis, ___captureObject0);
else
GenericVirtActionInvoker1< VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 * >::Invoke(targetMethod, targetThis, ___captureObject0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___captureObject0);
else
VirtActionInvoker1< VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___captureObject0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___captureObject0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___captureObject0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.WebCam.VideoCapture_OnVideoCaptureResourceCreatedCallback::BeginInvoke(UnityEngine.Windows.WebCam.VideoCapture,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* OnVideoCaptureResourceCreatedCallback_BeginInvoke_mE36CE2C8E021A4FF484DBC059B46F8DC1841483A (OnVideoCaptureResourceCreatedCallback_t3699FD2DE7FEF286A229B548E358133211BBA956 * __this, VideoCapture_tD1E122C49208E6DCCEF7FDE2A2C91DD47D010C91 * ___captureObject0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
void *__d_args[2] = {0};
__d_args[0] = ___captureObject0;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnVideoCaptureResourceCreatedCallback::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnVideoCaptureResourceCreatedCallback_EndInvoke_m91AF83FB7BD99EF34F87DF6CC07DDF0DB9CF815D (OnVideoCaptureResourceCreatedCallback_t3699FD2DE7FEF286A229B548E358133211BBA956 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_OnVideoModeStartedCallback_t201EBB65059DA254ED2A4B24D365C4F6EAE9DF75 (OnVideoModeStartedCallback_t201EBB65059DA254ED2A4B24D365C4F6EAE9DF75 * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F );
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Native function invocation
il2cppPInvokeFunc(___result0);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStartedCallback::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnVideoModeStartedCallback__ctor_mD6DC7A8AD853556AD0D66C32339A735D72B09C47 (OnVideoModeStartedCallback_t201EBB65059DA254ED2A4B24D365C4F6EAE9DF75 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStartedCallback::Invoke(UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnVideoModeStartedCallback_Invoke_m13337457016034DE08D05247F064B9EECC351B2E (OnVideoModeStartedCallback_t201EBB65059DA254ED2A4B24D365C4F6EAE9DF75 * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(targetMethod, targetThis, ___result0);
else
GenericVirtActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(targetMethod, targetThis, ___result0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___result0);
else
VirtActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___result0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___result0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStartedCallback::BeginInvoke(UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* OnVideoModeStartedCallback_BeginInvoke_m4A3CEBB5158BB4DCB0F8DD884D88A53CE484CEFB (OnVideoModeStartedCallback_t201EBB65059DA254ED2A4B24D365C4F6EAE9DF75 * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (OnVideoModeStartedCallback_BeginInvoke_m4A3CEBB5158BB4DCB0F8DD884D88A53CE484CEFB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F_il2cpp_TypeInfo_var, &___result0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStartedCallback::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnVideoModeStartedCallback_EndInvoke_mF9B72E6808B95E4DC060B1401CDF180A4030B5A8 (OnVideoModeStartedCallback_t201EBB65059DA254ED2A4B24D365C4F6EAE9DF75 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
IL2CPP_EXTERN_C void DelegatePInvokeWrapper_OnVideoModeStoppedCallback_tA0921FEE66B3EDE3E01E8D6526CF5203ED3C273C (OnVideoModeStoppedCallback_tA0921FEE66B3EDE3E01E8D6526CF5203ED3C273C * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, const RuntimeMethod* method)
{
typedef void (DEFAULT_CALL *PInvokeFunc)(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F );
PInvokeFunc il2cppPInvokeFunc = reinterpret_cast<PInvokeFunc>(il2cpp_codegen_get_method_pointer(((RuntimeDelegate*)__this)->method));
// Native function invocation
il2cppPInvokeFunc(___result0);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStoppedCallback::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnVideoModeStoppedCallback__ctor_m833B3FF3AD7E58E090CB6238684518693AAF1A97 (OnVideoModeStoppedCallback_tA0921FEE66B3EDE3E01E8D6526CF5203ED3C273C * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStoppedCallback::Invoke(UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnVideoModeStoppedCallback_Invoke_mD5CACF758DA742BCDC3FB7B27A648BAB02340498 (OnVideoModeStoppedCallback_tA0921FEE66B3EDE3E01E8D6526CF5203ED3C273C * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, const RuntimeMethod* method)
{
DelegateU5BU5D_t677D8FE08A5F99E8EE49150B73966CD6E9BF7DB8* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___result0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(targetMethod, targetThis, ___result0);
else
GenericVirtActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(targetMethod, targetThis, ___result0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___result0);
else
VirtActionInvoker1< VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___result0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___result0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___result0, targetMethod);
}
}
}
}
}
// System.IAsyncResult UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStoppedCallback::BeginInvoke(UnityEngine.Windows.WebCam.VideoCapture_VideoCaptureResult,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* OnVideoModeStoppedCallback_BeginInvoke_mDBF06C8C08B108AB38F91C075A660AFA1D40876C (OnVideoModeStoppedCallback_tA0921FEE66B3EDE3E01E8D6526CF5203ED3C273C * __this, VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F ___result0, AsyncCallback_tA7921BEF974919C46FF8F9D9867C567B200BB0EA * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (OnVideoModeStoppedCallback_BeginInvoke_mDBF06C8C08B108AB38F91C075A660AFA1D40876C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(VideoCaptureResult_t5BF55234CB867212E469D31EFF679AD20524991F_il2cpp_TypeInfo_var, &___result0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void UnityEngine.Windows.WebCam.VideoCapture_OnVideoModeStoppedCallback::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void OnVideoModeStoppedCallback_EndInvoke_m97E26F948C10C4E3C76FF735248FADEE7E3D8398 (OnVideoModeStoppedCallback_tA0921FEE66B3EDE3E01E8D6526CF5203ED3C273C * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void AutoScope__ctor_m4131730A501F687FF95B2963EABAC7844C6B9859_inline (AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D * __this, intptr_t ___markerPtr0, const RuntimeMethod* method)
{
{
intptr_t L_0 = ___markerPtr0;
__this->set_m_Ptr_0((intptr_t)L_0);
intptr_t L_1 = ___markerPtr0;
ProfilerUnsafeUtility_BeginSample_m1B2CAD1BC7C7C390514317A8D51FB798D4622AE4((intptr_t)L_1, /*hidden argument*/NULL);
return;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void AutoScope_Dispose_m5CDDCDA2B8769738BB695661EC4AC55DD7A0D7CA_inline (AutoScope_tEB00834B4CEE8558238837BA3A36B64020E48F8D * __this, const RuntimeMethod* method)
{
{
intptr_t L_0 = __this->get_m_Ptr_0();
ProfilerUnsafeUtility_EndSample_m0435B2EE7963614F3D154A83D44269FE4D1A85B0((intptr_t)L_0, /*hidden argument*/NULL);
return;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR RuntimeObject * UnhandledExceptionEventArgs_get_ExceptionObject_mCC83AA77B4F250C371EEE194025341F757724E90_inline (UnhandledExceptionEventArgs_tFA66D5AA8F6337DEF8E2B494B3B8C377C9FDB885 * __this, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = __this->get__Exception_1();
return L_0;
}
}
| [
"[email protected]"
] | |
b22ae4ca4a4b7123b1715243234ebce756b83f63 | 17554c4666f40759074dbe204aca6f9b5373d207 | /tensorflow/compiler/xla/service/hlo_ordering.cc | 1b24d8da9e832e6847cb6f405e15af3c455f695a | [
"Apache-2.0"
] | permissive | PACELab/tensorflow-1 | ef92f70c5e5ff4cb3bda9254b8ef66b45f124566 | fff95ee576e266eae9ccf23688849303aa146a3d | refs/heads/master | 2021-01-25T14:34:10.574775 | 2018-03-03T18:14:50 | 2018-03-03T18:14:50 | 123,713,012 | 0 | 1 | Apache-2.0 | 2018-03-03T17:03:35 | 2018-03-03T17:03:35 | null | UTF-8 | C++ | false | false | 15,226 | cc | /* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/compiler/xla/service/hlo_ordering.h"
#include <utility>
#include <vector>
#include "tensorflow/compiler/xla/service/hlo_computation.h"
#include "tensorflow/compiler/xla/service/liveness_util.h"
#include "tensorflow/compiler/xla/shape_util.h"
#include "tensorflow/compiler/xla/status_macros.h"
#include "tensorflow/compiler/xla/statusor.h"
#include "tensorflow/compiler/xla/types.h"
#include "tensorflow/compiler/xla/util.h"
#include "tensorflow/core/lib/core/errors.h"
#include "tensorflow/core/lib/strings/str_util.h"
#include "tensorflow/core/lib/strings/stringprintf.h"
#include "tensorflow/core/platform/logging.h"
namespace xla {
bool HloOrdering::ExecutesBefore(const HloInstruction* a,
const HloInstruction* b) const {
// 'a' and 'b' may be in different computations. In this case, find the
// callgraph ancestor instructions which call (potentially transitively) the
// computations containing 'a' and 'b' and use these ancestor instructions to
// compare order.
const HloInstruction* a_ancestor;
const HloInstruction* b_ancestor;
std::tie(a_ancestor, b_ancestor) =
call_graph_->NearestAncestorsInSameComputation(
const_cast<HloInstruction*>(a), const_cast<HloInstruction*>(b));
if (a_ancestor == nullptr) {
// Ancestors in a common computation could not be found so consider the
// instructions 'a' and 'b' to be unordered.
return false;
}
// a_ancestor and b_ancestor must be either both null or both non-null.
CHECK_NE(b_ancestor, nullptr);
CHECK_EQ(a_ancestor->parent(), b_ancestor->parent());
// If the common ancestor is a while instruction there is an additional
// ordering criteria which may apply. The condition computation is considered
// to execute before the body computation so if 'a' is in the condition and
// 'b' is in the body, then 'a' executes before 'b'.
if (a_ancestor == b_ancestor && a_ancestor->opcode() == HloOpcode::kWhile) {
const HloComputation* body = a_ancestor->while_body();
const HloComputation* condition = a_ancestor->while_condition();
if (call_graph_->InstructionIsNestedIn(a, condition) &&
call_graph_->InstructionIsNestedIn(b, body)) {
return true;
}
}
return ExecutesBeforeInSameComputation(a_ancestor, b_ancestor);
}
bool HloOrdering::IsDefinedBefore(const HloValue& a, const HloValue& b) const {
// If 'b' is an entry param then 'a' cannot be defined before 'b' because 'b'
// is live into the module.
const HloModule* module = b.defining_instruction()->parent()->parent();
if (b.defining_instruction()->parent() == module->entry_computation() &&
b.defining_instruction()->opcode() == HloOpcode::kParameter) {
return false;
}
// Phi values require special handling. Because XLA does not have a phi
// instruction, the definition instruction of the phis values are
// placeholders: either the subcomputation parameter (body or condition) or
// the while instruction. However, the program point where these values are
// logically defined does not necessarily coincide exactly with program point
// of these place-holder instructions. So we explicitly define the following
// order for phi values:
//
// body/condition parameter phi:
// Defined before all values defined in its computation excepting other
// phis.
//
// while phi:
// defined after all values defined in the condition or body.
//
auto is_body_or_condition_phi = [](const HloValue& v) {
return v.is_phi() &&
v.defining_instruction()->opcode() == HloOpcode::kParameter;
};
if (is_body_or_condition_phi(a) && !is_body_or_condition_phi(b) &&
call_graph_->InstructionIsNestedIn(b.defining_instruction(),
a.defining_instruction()->parent())) {
return true;
}
if (is_body_or_condition_phi(b) &&
call_graph_->InstructionIsNestedIn(a.defining_instruction(),
b.defining_instruction()->parent())) {
return false;
}
// If 'b' is a while phi and 'a' is in the body or condition, then 'a'
// executes before 'b'.
if (b.is_phi() && b.defining_instruction()->opcode() == HloOpcode::kWhile &&
(call_graph_->InstructionIsNestedIn(
a.defining_instruction(), b.defining_instruction()->while_body()) ||
call_graph_->InstructionIsNestedIn(
a.defining_instruction(),
b.defining_instruction()->while_condition()))) {
return true;
}
return ExecutesBefore(a.defining_instruction(), b.defining_instruction());
}
/* static */
bool HloOrdering::UseIsBeforeValueDefinition(
const HloUse& use, const HloValue& value,
const HloDataflowAnalysis& dataflow) const {
VLOG(4) << "UseIsBeforeValueDefinition(use=" << use
<< ", value=" << value.ToShortString() << ")";
if (ExecutesBefore(use.instruction, value.defining_instruction())) {
VLOG(4) << " use instruction executes before value-defining instruction";
return true;
}
// If the use is at the instruction where the value is defined, then the use
// is before the def if the instruction allows buffer sharing (in place
// computation).
if (use.instruction == value.defining_instruction() &&
CanShareOperandBufferWithUser(
use.instruction->mutable_operand(use.operand_number),
use.operand_index, value.defining_instruction(),
value.defining_index(), dataflow)) {
VLOG(4) << " use is value def, and instruction can share use buffer";
return true;
}
// The use at a while is an input to a phi, and logically occurs before values
// are defined in the body or condition computations.
if (use.instruction->opcode() == HloOpcode::kWhile) {
const HloInstruction* xla_while = use.instruction;
if (call_graph_->InstructionIsNestedIn(value.defining_instruction(),
xla_while->while_body()) ||
call_graph_->InstructionIsNestedIn(value.defining_instruction(),
xla_while->while_condition())) {
VLOG(4) << " use is while " << use.instruction->name()
<< " and def is in condition or body";
return true;
}
}
// Similarly if the value is defined at a while, it logically occurs after any
// uses in the body or condition computations.
if (value.defining_instruction()->opcode() == HloOpcode::kWhile) {
CHECK(value.is_phi());
const HloInstruction* xla_while = value.defining_instruction();
if (call_graph_->InstructionIsNestedIn(use.instruction,
xla_while->while_body()) ||
call_graph_->InstructionIsNestedIn(use.instruction,
xla_while->while_condition())) {
VLOG(4) << " value is while " << value.defining_instruction()->name()
<< " and use is in condition or body";
return true;
}
}
// The use at a call occurs before values that are defined in the called
// computation.
if (use.instruction->opcode() == HloOpcode::kCall) {
const HloInstruction* call = use.instruction;
if (call_graph_->InstructionIsNestedIn(value.defining_instruction(),
call->to_apply())) {
VLOG(4) << " use is call " << use.instruction->name()
<< " and def is in called computation";
return true;
}
}
if (use.instruction->opcode() == HloOpcode::kConditional) {
const HloInstruction* conditional = use.instruction;
if (call_graph_->InstructionIsNestedIn(value.defining_instruction(),
conditional->true_computation())) {
VLOG(4) << " use is conditional " << use.instruction->name()
<< " and def is in TRUE computation";
return true;
}
if (call_graph_->InstructionIsNestedIn(value.defining_instruction(),
conditional->false_computation())) {
VLOG(4) << " use is conditional " << use.instruction->name()
<< " and def is in FALSE computation";
return true;
}
}
VLOG(4) << " use is not before value";
return false;
}
bool HloOrdering::LiveRangeStrictlyBefore(
const HloValue& a, const HloValue& b,
const HloDataflowAnalysis& dataflow) const {
VLOG(4) << "LiveRangeStrictlyBefore(a = " << a.ToShortString()
<< ", b = " << b.ToShortString() << ")";
if (!IsDefinedBefore(a, b)) {
VLOG(4) << "a not defined before b";
return false;
}
// All uses of 'a' must be before 'b' is defined.
for (const HloUse& use : a.uses()) {
if (!UseIsBeforeValueDefinition(use, b, dataflow)) {
VLOG(4) << "use of a (" << use << ") not before b is defined";
return false;
}
}
return true;
}
bool HloOrdering::MayInterfere(const HloValue& a, const HloValue& b,
const HloDataflowAnalysis& dataflow) const {
// Buffers without disjoint liveness may interfere.
return !LiveRangeStrictlyBefore(a, b, dataflow) &&
!LiveRangeStrictlyBefore(b, a, dataflow);
}
HloOrderingProto HloOrdering::ToProto() const {
HloOrderingProto proto;
for (const auto& computation : module_->computations()) {
const std::vector<const HloInstruction*>* sequence =
SequentialOrder(*computation);
if (sequence != nullptr) {
HloOrderingProto::SequentialComputation* proto_computation =
proto.add_sequential_computations();
proto_computation->set_computation_name(computation->name());
for (const HloInstruction* instruction : *sequence) {
*proto_computation->add_instruction_names() = instruction->name();
}
}
}
return proto;
}
PredecessorHloOrdering::PredecessorHloOrdering(const HloModule* module)
: HloOrdering(module) {}
bool PredecessorHloOrdering::ExecutesBeforeInSameComputation(
const HloInstruction* a, const HloInstruction* b) const {
CHECK_EQ(a->parent(), b->parent());
// 'a' executes before 'b' if 'a' is in the strict predecessor set of 'b'.
return a != b && predecessors_.at(a->parent())->IsReachable(a, b);
}
string PredecessorHloOrdering::ToStringHelper(const string& name) const {
std::vector<string> pieces;
pieces.push_back(name);
for (auto* computation : module_->MakeNonfusionComputations()) {
pieces.push_back(tensorflow::strings::Printf("computation %s:",
computation->name().c_str()));
const auto all = computation->MakeInstructionPostOrder();
for (auto instruction : all) {
pieces.push_back(tensorflow::strings::Printf(
" %s predecessors:", instruction->name().c_str()));
for (auto predecessor : all) {
if (predecessors_.at(computation)
->IsReachable(predecessor, instruction)) {
pieces.push_back(
tensorflow::strings::Printf(" %s", predecessor->name().c_str()));
}
}
}
}
return tensorflow::str_util::Join(pieces, "\n");
}
DependencyHloOrdering::DependencyHloOrdering(const HloModule* module)
: PredecessorHloOrdering(module) {
// Compute predecessor relationships between all instructions to determine
// ordering based on dependencies. ExecutesBefore will return true iff there
// exists a path in the HLO computation graph from 'a' to 'b'.
for (auto* computation : module->MakeNonfusionComputations()) {
predecessors_.emplace(computation, computation->ComputeReachability());
}
}
string DependencyHloOrdering::ToString() const {
return ToStringHelper("DependencyHloOrdering");
}
SequentialHloOrdering::SequentialHloOrdering(
const HloModule* module, const HloModuleSequence& module_sequence)
: HloOrdering(module), module_sequence_(module_sequence) {
// Create a map from instruction to its order position.
for (auto computation_order : module_sequence_) {
const std::vector<const HloInstruction*>& order = computation_order.second;
for (int i = 0; i < order.size(); ++i) {
DCHECK_EQ(0, order_position_.count(order[i]));
order_position_.emplace(order[i], i);
}
}
}
bool SequentialHloOrdering::ExecutesBeforeInSameComputation(
const HloInstruction* a, const HloInstruction* b) const {
CHECK_EQ(a->parent(), b->parent());
// If either instruction is not in the order, then 'a' and 'b' are unordered.
if (order_position_.count(a) == 0 || order_position_.count(b) == 0) {
return false;
}
return order_position_.at(a) < order_position_.at(b);
}
const std::vector<const HloInstruction*>*
SequentialHloOrdering::SequentialOrder(
const HloComputation& computation) const {
auto find_it = module_sequence_.find(&computation);
return find_it == module_sequence_.end() ? nullptr : &find_it->second;
}
string SequentialHloOrdering::ToString() const {
std::vector<string> pieces;
pieces.push_back("SequentialHloOrdering");
for (auto* computation : module_->computations()) {
pieces.push_back(tensorflow::strings::Printf("computation %s order:",
computation->name().c_str()));
// Gather all instructions in the module sequence for this computation and
// sort them by their position.
std::vector<const HloInstruction*> instructions;
for (auto& instruction_position : order_position_) {
const HloInstruction* instruction = instruction_position.first;
if (instruction->parent() == computation) {
instructions.push_back(instruction);
}
}
std::sort(instructions.begin(), instructions.end(),
[this](const HloInstruction* a, const HloInstruction* b) {
return order_position_.at(a) < order_position_.at(b);
});
for (auto instruction : instructions) {
pieces.push_back(
tensorflow::strings::Printf(" %s", instruction->name().c_str()));
}
}
return tensorflow::str_util::Join(pieces, "\n");
}
std::ostream& operator<<(
std::ostream& out,
const SequentialHloOrdering::HloModuleSequence& module_sequence) {
for (auto computation_pair : module_sequence) {
const HloComputation* computation = computation_pair.first;
const std::vector<const HloInstruction*>& computation_sequence =
computation_pair.second;
out << "Computation " << computation->name() << ":\n";
for (auto* instruction : computation_sequence) {
out << " " << instruction->name() << "\n";
}
}
return out;
}
} // namespace xla
| [
"[email protected]"
] | |
b527d48536a5e325406810113a9586f1bfdcb9ea | 6ba1205193d8d03bbe3368b8a5af13650bb1f031 | /ring_count.cpp | 4e6d75a70821101c3b7a95a4a24fcdce565c6a6e | [] | no_license | sjhalayka/opencv_ring_count | bfaa154f3ea170f77f261eb4d257e0b17d1a2f4e | 784c246aa1635251126861ca5be55f81683dace1 | refs/heads/master | 2021-09-02T02:49:57.401226 | 2017-12-29T21:15:43 | 2017-12-29T21:15:43 | 115,754,495 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,317 | cpp | #include <opencv2/opencv.hpp>
using namespace cv;
#pragma comment(lib, "opencv_world340.lib")
#include <iostream>
using namespace std;
int main(void)
{
Mat frame = imread("rings.jpg");
if (frame.empty())
{
cout << "Error loading image file" << endl;
return -1;
}
cvtColor(frame, frame, CV_BGR2GRAY);
adaptiveThreshold(frame, frame, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 11, 2);
// Use centre column
int column_index = frame.cols / 2;
int ring_count_vertical = 0;
// Start with the second row
for (int i = 1; i < frame.rows; i++)
{
// If this pixel is white and the previous pixel is black
if (255 == frame.at<unsigned char>(i, column_index) && 0 == frame.at<unsigned char>(i - 1, column_index))
ring_count_vertical++;
}
// Use centre row
int row_index = frame.rows / 2;
int ring_count_horizontal = 0;
// Start with the second column
for (int i = 1; i < frame.cols; i++)
{
// If this pixel is white and the previous pixel is black
if (255 == frame.at<unsigned char>(row_index, i) && 0 == frame.at<unsigned char>(row_index, i - 1))
ring_count_horizontal++;
}
if (ring_count_vertical > ring_count_horizontal)
cout << ring_count_vertical << endl;
else
cout << ring_count_horizontal << endl;
return 1;
} | [
"[email protected]"
] | |
22a94823cfb2d4d85e6e7a4512d231b9c0b89b82 | 956e9c2785db1aaa1f56ef3a0e6b84aff44a51f1 | /odyssey-r155188-1.23/BAL/Widgets/WebCore/Generic/BCContextMenuGeneric.h | d116450b2be6cf8c74ef9220d02555ffa9040ce9 | [] | no_license | kas1e/Odyssey | d452826d2648280390e4d6ff1c8df5c228d095ad | 947cc7a10be2599d3ed3145ab2af4a445df6d462 | refs/heads/master | 2023-02-23T15:21:53.806910 | 2022-06-26T13:47:07 | 2022-06-26T13:47:07 | 243,821,888 | 10 | 9 | null | 2023-02-07T20:04:56 | 2020-02-28T17:48:33 | C++ | UTF-8 | C++ | false | false | 2,878 | h | /*
* Copyright (C) 2008 Pleyo. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Pleyo nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY PLEYO AND ITS CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL PLEYO OR ITS CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef ContextMenu_h
#define ContextMenu_h
#include <wtf/Noncopyable.h>
#include "ContextMenuItem.h"
#include "HitTestResult.h"
#include "PlatformMenuDescription.h"
#include "PlatformString.h"
namespace WebCore {
class MenuEventProxy;
class ContextMenuController;
class ContextMenu : public Noncopyable
{
public:
ContextMenu(const HitTestResult&);
ContextMenu(const HitTestResult&, const PlatformMenuDescription);
~ContextMenu();
void populate();
void addInspectElementItem();
void checkOrEnableIfNeeded(ContextMenuItem&) const;
void insertItem(unsigned position, ContextMenuItem&);
void appendItem(ContextMenuItem&);
ContextMenuItem* itemWithAction(unsigned);
ContextMenuItem* itemAtIndex(unsigned, const PlatformMenuDescription);
unsigned itemCount() const;
HitTestResult hitTestResult() const { return m_hitTestResult; }
ContextMenuController* controller() const;
PlatformMenuDescription platformDescription() const;
void setPlatformDescription(PlatformMenuDescription);
PlatformMenuDescription releasePlatformDescription();
private:
HitTestResult m_hitTestResult;
PlatformMenuDescription m_platformDescription;
};
}
#endif // ContextMenu_h
| [
"[email protected]"
] | |
85186ab2df795f1784ce7df2526c50f3ac114ec2 | 269ad6c0007666167804886ffa3fa675350d292e | /URI_Beginner/URI_1847.cpp | 0fa1e7d4ce8dae1e0313db271fb96f80fd1b9222 | [] | no_license | Subangkar/URI-Solved-Problems | 6e934e30d250df7fd4f27e1aa00b876298362bc5 | 0240a57faf34833f77d9255846f42c1f9cea040e | refs/heads/master | 2020-04-08T15:39:23.201095 | 2018-11-28T11:55:08 | 2018-11-28T11:55:08 | 159,486,880 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 177 | cpp | #include <stdio.h>
void main()
{
int a ,b ,c ;
scanf("%d %d %d" , &a , &b , &c) ;
if ( ( b<=c ) ||
)
{
printf(":)\n") ;
}
else
{
printf(":(\n") ;
}
} | [
"[email protected]"
] | |
f7d9994e2ee88865b178fb625fea7d61db401905 | 493ac26ce835200f4844e78d8319156eae5b21f4 | /flow_simulation/ideal_flow/processor1/0.92/U | f1a7d629d8b7748e3354d7a0d1a6fc56c78b6113 | [] | no_license | mohan-padmanabha/worm_project | 46f65090b06a2659a49b77cbde3844410c978954 | 7a39f9384034e381d5f71191122457a740de3ff0 | refs/heads/master | 2022-12-14T14:41:21.237400 | 2020-08-21T13:33:10 | 2020-08-21T13:33:10 | 289,277,792 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 48,759 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1912 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
location "0.92";
object U;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 -1 0 0 0 0];
internalField nonuniform List<vector>
1466
(
(2.7174 -0.199621 -1.78104e-16)
(4.72993 -0.108405 -3.19917e-19)
(-2.80235 -0.180963 4.85959e-16)
(0.048503 9.32693 -3.77791e-17)
(-0.411433 -0.870016 -6.43559e-16)
(-2.1293 0.113524 -9.00815e-16)
(-0.877641 0.306399 2.15083e-16)
(3.24053 -0.361866 1.31076e-16)
(7.37242 0.11082 -8.82717e-19)
(4.82731 -0.171158 1.34459e-16)
(5.90611 -0.229203 -1.82588e-16)
(5.05772 -0.511656 0)
(8.38516 0.0645365 0)
(-0.0995881 -1.38247 -1.49818e-16)
(-1.21423 0.13697 0)
(4.5715 -0.496434 1.4122e-16)
(2.41201 -1.52192 -8.66272e-17)
(0.0306075 5.26713 -2.50757e-17)
(0.917768 5.58921 -8.0044e-17)
(-0.0761286 7.48184 1.3362e-16)
(0.104422 7.55359 5.87296e-17)
(-2.14489 0.0437338 5.35951e-18)
(0.016153 6.19081 -5.58973e-17)
(-0.113585 7.23058 -1.44748e-17)
(8.26523 0.142067 7.35369e-17)
(-0.324715 0.0674914 -2.76803e-16)
(-1.40507 0.578788 -1.22712e-16)
(-0.104655 7.67039 0)
(-1.71429 -0.0381149 0)
(4.75255 2.36313 5.08255e-17)
(6.03972 -0.63459 1.21286e-16)
(-0.47175 -0.0413674 1.67911e-16)
(-0.707123 -0.966016 2.13453e-16)
(-0.372865 6.45377 1.37892e-16)
(4.25834 -0.204624 9.3533e-17)
(-0.92712 1.02123 2.27262e-16)
(-0.299247 5.79932 0)
(2.25096 -0.663397 -2.5336e-16)
(5.21677 0.179132 -2.65856e-16)
(-1.48746 -0.0898379 -3.6688e-16)
(-1.76563 -0.0236055 -1.40343e-16)
(-2.97908 0.0204728 -3.02907e-16)
(-3.10524 -0.0971409 1.65391e-16)
(-1.76791 -0.13564 1.24626e-18)
(-0.697465 -0.301569 -4.18926e-18)
(3.09157 -0.000674895 0)
(6.14844 0.10359 6.86015e-18)
(1.53224 -0.0943343 0)
(-1.87602 -0.327734 1.25502e-16)
(0.606974 -0.238146 0)
(-1.23107 0.298636 -1.01263e-16)
(4.63242 -0.0691879 -3.43696e-16)
(-2.27177 -0.0867842 6.00258e-16)
(0.175663 -0.450072 6.31079e-16)
(-1.26631 -0.551775 -9.63808e-17)
(6.39718 -0.0465235 1.22705e-16)
(3.08433 -0.0713004 -1.85113e-17)
(5.80851 0.0073733 0)
(-0.193502 -0.0936858 1.15718e-17)
(4.76625 0.022392 0)
(0.338599 -0.0369517 2.12993e-19)
(-1.16521 0.121717 -1.13397e-16)
(-0.96854 -0.311416 1.80927e-16)
(4.11825 -0.195106 1.33366e-16)
(1.41166 5.6155 -1.75528e-16)
(2.00001 0.555987 2.18856e-16)
(-0.347154 1.97447 0)
(-0.0326807 5.27468 2.72008e-17)
(7.26766 0.511952 2.89085e-17)
(-2.09684 0.117954 -1.58444e-16)
(1.20095 0.81763 1.17618e-15)
(-0.116879 5.98794 0)
(-0.032743 5.89516 0)
(8.17553 0.212632 -1.51347e-16)
(0.063338 -0.356736 2.92324e-16)
(5.92978 -0.0596967 -1.13057e-16)
(-1.22147 0.0640578 9.78494e-17)
(-0.77732 -0.531076 -1.0319e-16)
(-1.34892 -0.162862 0)
(3.76927 0.783128 0)
(4.35289 0.0130997 -1.24964e-16)
(4.80188 -0.369832 -1.72053e-16)
(-1.75533 1.23931 -2.44871e-16)
(0.91891 3.29133 2.58655e-16)
(-0.12451 5.28666 1.14276e-16)
(0.582082 5.79873 4.20616e-17)
(-0.437413 7.73709 0)
(3.55843 0.265076 1.6535e-18)
(4.99377 0.102758 2.46968e-16)
(-0.17413 0.487607 -3.07029e-16)
(-0.0911004 0.0620088 -9.86574e-17)
(-2.07522 0.378771 -2.19612e-16)
(0.162796 7.11181 -4.17825e-17)
(1.74191 -0.810378 -1.95132e-16)
(1.71902 -0.451577 0)
(-2.12273 -0.352379 -3.23816e-16)
(4.51135 -0.128813 3.01071e-16)
(6.19339 -0.0347243 -7.12465e-18)
(6.56603 -0.125432 3.06654e-16)
(-0.90099 -0.407615 9.25012e-17)
(-1.83344 0.254117 4.97115e-16)
(-0.608014 0.0202897 0)
(1.51995 -0.0285381 3.69064e-16)
(-1.06994 -0.525932 3.26904e-16)
(-3.02078 -0.151532 -1.23799e-16)
(3.59121 0.171581 6.09852e-17)
(-2.35236 -0.166014 -2.26769e-17)
(1.00907 -0.306594 0)
(5.22071 -0.42409 1.73956e-16)
(2.75814 -0.00309367 6.59063e-17)
(0.192774 -0.00363618 -2.7627e-16)
(4.6837 -0.0868111 3.69249e-17)
(2.1252 -0.414321 -3.29942e-17)
(-3.23312 -0.00926851 -3.8131e-17)
(4.25319 -0.339796 0)
(0.509723 0.065254 8.97466e-17)
(-2.79824 0.16498 1.40637e-16)
(3.78785 -0.022793 0)
(-1.24724 0.180401 1.52973e-16)
(-1.23128 0.0974105 -6.26088e-16)
(-0.253722 9.08677 -2.93982e-17)
(-0.348198 -0.356803 3.12912e-16)
(0.233346 -1.0023 -1.10466e-15)
(-1.56416 -0.240619 0)
(-0.0647875 -0.200898 -8.25321e-16)
(-1.1918 1.06287 -5.97527e-19)
(6.41191 0.958165 4.66281e-17)
(-0.246937 5.80086 -6.11623e-17)
(-0.0767312 7.07969 2.28485e-17)
(0.855025 0.474112 1.76378e-16)
(5.04928 -0.0315731 2.03338e-17)
(-2.43008 0.182054 0)
(-0.15205 6.32042 3.86096e-17)
(-0.144984 7.28229 3.03221e-17)
(-0.0233839 -0.031276 -1.6002e-17)
(-1.41999 0.0615128 0)
(-1.38658 0.0437873 0)
(0.683399 -0.541569 -1.00813e-17)
(-1.63682 0.0605632 -9.49788e-17)
(-1.54437 -0.00643417 1.98035e-16)
(-0.172214 -0.321728 0)
(-0.0467549 7.68141 -5.77499e-17)
(-0.110247 6.54182 -2.70655e-17)
(0.360053 5.24619 -2.22707e-18)
(-1.56938 -0.497863 -2.22736e-16)
(0.942369 6.49335 8.85662e-17)
(-0.472866 -0.0483816 -2.88315e-16)
(0.541416 0.0704173 -4.4862e-16)
(1.53417 0.70673 -6.96277e-17)
(-1.01262 -1.04719 1.14274e-15)
(0.0112814 0.0384058 1.84108e-16)
(3.39636 -0.124916 -5.31803e-20)
(6.85775 0.82214 -1.37881e-19)
(0.813321 0.13438 0)
(1.57958 0.698747 0)
(-2.08883 0.13448 2.08063e-16)
(-0.196828 7.542 -1.40338e-17)
(-0.448485 8.52923 -1.30531e-16)
(-0.201732 0.0085764 1.08486e-15)
(5.46662 3.7268 6.67596e-17)
(-0.45769 -0.00614473 1.26987e-16)
(5.33691 1.29202 0)
(0.569352 3.04383 7.36656e-17)
(-0.170061 6.81826 5.16686e-19)
(2.59403 2.62029 0)
(-2.67249 -0.228665 1.39294e-16)
(-0.0916801 6.60027 0)
(-0.20653 4.89394 1.87335e-16)
(-0.14138 6.58385 -2.84837e-17)
(2.02994 8.82354 5.62906e-17)
(-0.10385 6.75198 1.92222e-16)
(-0.409162 0.0778075 -1.21741e-16)
(0.970062 -0.107263 4.80324e-17)
(7.17518 0.666771 -1.50992e-17)
(3.87891 -0.00659795 -2.35188e-16)
(7.67341 0.139034 -2.91939e-16)
(5.10624 2.93377 1.62099e-16)
(3.60691 1.6523 -7.42117e-17)
(0.0521208 0.0252116 -3.74134e-16)
(0.93337 1.1395 -2.45436e-16)
(8.64704 0.162932 3.58268e-16)
(3.95841 -0.133432 -2.4304e-17)
(-0.0768919 4.81497 -1.78661e-16)
(0.940317 0.244111 2.84571e-16)
(3.81944 0.181587 -4.18557e-17)
(0.188797 5.51968 -2.85639e-18)
(-0.130328 5.20772 -1.1266e-16)
(2.00456 4.58215 -1.42936e-16)
(7.11073 0.339573 7.14767e-17)
(-1.44519 -0.0694687 3.86726e-16)
(-0.0510182 6.8746 -1.29229e-16)
(0.380564 -0.0940621 1.66575e-19)
(0.586379 4.12292 6.67721e-18)
(0.771688 6.15327 2.29981e-16)
(5.84633 3.26131 -3.95194e-17)
(0.318116 0.10476 0)
(-1.52582 0.250889 3.27006e-18)
(3.45496 1.19127 -3.54967e-16)
(1.30384 2.29841 -2.60221e-16)
(1.68856 5.85159 -4.66866e-16)
(0.363228 3.19529 0)
(1.16183 0.554535 0)
(5.34861 2.16374 -4.92084e-21)
(0.326528 2.26643 0)
(1.36251 0.606197 2.05711e-16)
(1.66625 1.84348 -1.85541e-16)
(0.582211 6.87059 -1.03309e-16)
(6.74764 3.60168 0)
(-0.0477549 0.0808506 1.38442e-16)
(-0.0573723 7.372 2.23902e-19)
(0.549593 5.99718 7.48118e-17)
(-0.0778386 5.34488 -1.07278e-16)
(-0.240536 2.37595 0)
(-0.149286 7.175 1.4112e-16)
(0.248597 7.33727 -3.63773e-17)
(-0.154433 6.56947 2.45007e-19)
(-0.000872782 5.52902 2.94878e-18)
(-0.132507 5.04488 -9.86371e-17)
(3.59952 4.1326 1.4377e-16)
(-0.11341 6.9325 2.09475e-16)
(-0.273645 5.42755 -1.41839e-16)
(0.550503 0.0107197 -1.25497e-16)
(-0.132251 6.38346 -2.11583e-16)
(0.571369 0.15147 2.49082e-16)
(-0.146121 6.45617 9.09046e-17)
(3.5313 3.60862 -1.51485e-16)
(-0.850252 -1.36972 4.92689e-16)
(0.779365 0.662978 -2.71279e-16)
(0.0134759 0.0736202 -3.02112e-16)
(0.519051 -0.0242081 -3.3853e-20)
(0.691927 0.355271 -6.26418e-16)
(4.09836 0.0853015 2.25695e-16)
(1.00688 5.02802 1.14644e-16)
(0.557762 3.28851 2.0663e-16)
(-0.928778 0.778704 5.4931e-17)
(2.08547 1.35524 -7.40896e-16)
(-0.0992439 6.53912 3.97325e-17)
(0.0189058 5.03924 1.7808e-17)
(0.61304 0.270081 2.47756e-16)
(-0.0515456 6.54452 2.45673e-17)
(0.189608 1.81103 0)
(4.16255 0.725594 4.74105e-17)
(5.6933 3.09283 8.63287e-17)
(2.30663 4.358 2.11152e-16)
(0.142386 0.19955 0)
(5.75436 1.18586 0)
(-0.433741 -0.0272884 0)
(8.57343 0.333348 0)
(2.8898 0.805021 -1.24382e-16)
(5.95665 3.55675 -7.83962e-17)
(-0.0496086 6.16142 -5.36158e-17)
(1.20954 6.06097 -2.49334e-16)
(6.93793 4.2006 3.33394e-18)
(3.66306 -0.885964 -1.0959e-16)
(-0.489971 0.0460216 3.10216e-16)
(0.373872 0.00798616 -2.79574e-16)
(-0.251849 7.67647 0)
(8.94243 3.95526 -1.84404e-16)
(-0.0323457 3.86357 -7.35164e-17)
(-0.0910354 2.43585 1.13431e-16)
(-0.00171346 -0.5694 0)
(-0.195636 6.43064 -2.44872e-17)
(-0.132336 7.24663 -3.8645e-17)
(0.548785 -0.063659 1.79363e-21)
(4.28958 3.79707 1.05901e-17)
(0.805857 0.0196824 -3.09007e-16)
(4.07306 -0.0745351 2.39594e-16)
(1.55312 0.770353 -1.23165e-16)
(0.494192 6.70441 -1.87573e-17)
(9.27511 3.57898 -8.86263e-17)
(1.77649 4.15481 -1.23611e-16)
(-0.0648416 3.82312 0)
(-0.281306 -0.639245 7.07253e-18)
(0.0113042 0.101483 -1.77825e-16)
(-0.110322 -0.0173865 -4.03485e-16)
(0.736976 0.217141 4.7997e-16)
(0.246472 0.0867881 -2.59808e-16)
(2.69944 5.24428 -1.27872e-16)
(-0.172704 6.21809 -1.27951e-16)
(1.99072 0.847358 1.89616e-16)
(0.397611 -0.0528545 2.25527e-16)
(1.96207 -1.09518 2.51782e-17)
(2.44795 3.67717 0)
(5.213 0.51498 -4.24259e-17)
(0.179075 -1.64569 4.87908e-16)
(0.556202 -0.48035 -1.75383e-16)
(2.61005 1.26404 0)
(2.68257 1.24233 -3.42604e-16)
(-0.170504 -0.201128 0)
(7.84975 4.05465 -2.9336e-16)
(7.61439 1.17208 1.50638e-16)
(2.06288 -0.143457 -1.40542e-18)
(8.57201 0.125038 -3.75899e-16)
(-0.50764 -0.120715 0)
(3.85814 5.76907 1.1091e-16)
(1.01871 2.44668 -3.91071e-16)
(-0.0638764 3.51975 1.3392e-16)
(0.504569 -0.666424 4.39736e-17)
(2.52867 1.21851 8.42611e-17)
(0.360057 -0.0452195 -2.75486e-16)
(0.252072 -1.19242 0)
(-0.800436 -0.0423413 1.93272e-16)
(-0.440599 -0.212456 0)
(8.75627 0.394682 -2.26474e-16)
(-0.387079 8.39432 0)
(0.357791 0.504989 1.05138e-16)
(0.379836 -0.934309 1.50979e-16)
(0.195898 -1.37963 -2.4787e-17)
(3.25439 8.42008 -2.809e-17)
(-0.241999 7.30339 7.03588e-17)
(7.00431 1.87753 1.64326e-16)
(-0.385186 4.41367 0)
(-0.0984568 6.58904 -1.8817e-19)
(3.06556 0.343255 -1.51063e-16)
(3.81684 1.85181 -2.00923e-16)
(4.83739 2.85798 -3.02364e-16)
(-0.162074 -0.0136656 0)
(5.30212 3.5269 2.27169e-16)
(-0.0464334 -0.993411 0)
(-0.63976 0.174704 3.20177e-16)
(0.0163506 -1.33001 0)
(-0.078236 3.72247 -1.40308e-16)
(0.0714287 1.92157 -7.04041e-17)
(0.251813 -0.0265866 3.53108e-16)
(-0.316526 8.7409 -2.02517e-17)
(7.83761 5.23667 -9.16613e-17)
(0.713261 -0.342511 -8.93582e-17)
(4.85234 3.72708 -2.27154e-16)
(-0.0306706 -0.0499474 -2.92667e-16)
(3.07407 0.123509 1.82274e-16)
(0.0540282 5.76868 1.00445e-16)
(7.89799 4.64277 5.56269e-16)
(-1.65151 -0.904698 -3.76685e-16)
(3.57303 7.15611 2.3945e-17)
(2.35516 2.67164 -1.66676e-16)
(7.16096 1.75276 6.83201e-17)
(2.42686 1.41687 -4.34539e-16)
(0.651065 0.163524 4.32347e-16)
(0.805581 -0.527481 -2.45183e-16)
(-0.618474 -0.765313 -2.12817e-16)
(0.419235 -0.575561 3.31246e-19)
(6.50248 3.15312 7.31667e-17)
(1.3236 -1.45825 4.18661e-17)
(3.23244 3.27033 -3.57746e-17)
(1.62195 8.76222 -6.10003e-17)
(-0.639477 -0.129849 -9.818e-17)
(5.46703 0.415434 -1.99403e-17)
(3.91328 6.09857 -8.34053e-17)
(6.80819 0.214399 2.65873e-17)
(2.80493 2.24041 1.80952e-16)
(6.28272 4.55491 -2.1413e-18)
(8.59488 2.74617 -5.1921e-17)
(-0.0290078 10.4074 -6.35465e-17)
(0.819267 0.88898 1.33539e-17)
(-0.837565 -0.95763 0)
(0.94583 1.56734 2.36892e-16)
(-0.428776 3.57482 -2.27497e-16)
(3.53851 0.444827 6.52413e-18)
(9.53911 2.4979 0)
(3.5497 7.40402 2.51315e-17)
(-0.392265 -0.348346 0)
(1.34083 2.85161 1.11063e-16)
(1.93694 4.89145 1.13836e-16)
(0.048844 2.5302 0)
(-0.283165 -0.641296 -3.10285e-16)
(-0.00762641 2.02845 4.45283e-19)
(7.08248 2.94265 5.83914e-17)
(7.2683 2.50739 5.06244e-17)
(-1.03417 -2.03514 1.69905e-16)
(2.82215 6.85263 4.10126e-18)
(3.06916 8.91212 0)
(0.757918 2.36066 1.18011e-16)
(1.38037 2.93748 -3.47222e-17)
(3.05263 8.39898 -3.31734e-18)
(-0.15393 -1.507 5.9311e-16)
(-0.226365 4.43163 4.15775e-17)
(3.09354 -0.526125 -2.66036e-17)
(1.2365 5.36631 7.70174e-17)
(1.29494 -0.961325 6.04008e-16)
(4.03274 4.59343 -8.99972e-17)
(0.146963 1.62869 1.07385e-16)
(0.227756 1.47682 -3.50206e-16)
(0.100413 2.14549 -2.04405e-16)
(0.0405761 2.55858 2.85266e-16)
(0.0607449 2.07481 0)
(0.138942 1.82446 1.65338e-16)
(0.740238 -1.96789 -2.04183e-17)
(0.314184 -2.21697 -2.03556e-16)
(0.0248943 -1.59458 1.75495e-16)
(0.166512 -1.1917 -4.64945e-17)
(0.0754564 -0.082865 2.19868e-17)
(0.126006 1.11985 5.1651e-17)
(-0.0203187 1.45797 -6.55816e-17)
(0.0842597 0.995701 -6.11054e-17)
(-0.039972 -0.099662 1.94352e-19)
(0.019091 -0.708966 1.49922e-16)
(0.0635746 -0.688338 -5.98912e-17)
(1.23544 7.09511 -3.10606e-17)
(-0.0034436 -0.0933256 8.30295e-17)
(-0.0971412 -0.782603 0)
(0.252306 0.043621 -2.16922e-16)
(0.590764 0.120668 2.42929e-16)
(1.60806 8.96974 0)
(-0.907782 -0.622944 2.7388e-16)
(1.19562 9.74098 -2.05901e-17)
(-0.0388096 -0.143713 6.24624e-19)
(1.64157 7.77151 -3.25577e-16)
(-0.22722 0.510087 -1.2359e-16)
(2.31503 -0.355216 0)
(1.55441 -0.0989561 1.08044e-16)
(-0.0150882 0.392228 -1.49482e-16)
(1.39181 6.88996 -1.45817e-16)
(1.09848 3.56505 2.62468e-16)
(0.769656 -0.151867 6.1354e-16)
(2.90778 1.48298 -1.16861e-16)
(-0.614487 -1.4175 0)
(-1.2154 -0.89468 0)
(1.01433 0.959666 1.35715e-16)
(0.212389 0.170512 0)
(0.970762 -0.0160805 0)
(0.234166 0.156573 -1.83429e-16)
(-0.52664 0.0849055 4.04307e-16)
(0.62673 0.0439303 0)
(1.03756 4.58604 1.071e-16)
(0.00269482 0.169912 1.52939e-16)
(0.169812 -0.0782906 -6.35334e-20)
(-0.281514 0.561221 4.45369e-16)
(2.07194 0.443904 2.74442e-17)
(-0.331516 0.24943 -8.30126e-16)
(-0.219676 0.152246 4.37719e-16)
(0.643628 -0.107654 0)
(0.0477501 -0.465503 -3.80433e-20)
(-0.423167 -1.04234 5.76199e-16)
(-1.67288 10.2955 1.89676e-17)
(2.17095 -0.0338102 -5.08975e-16)
(-0.00244838 -0.729038 -4.35232e-16)
(-0.508042 -0.691107 7.87355e-17)
(-0.0606696 -0.75899 -8.12416e-17)
(0.0137779 -1.14313 3.36465e-16)
(0.0279128 -0.140907 -3.75787e-16)
(-0.150359 -0.0509055 4.90876e-17)
(0.23015 -0.440006 -1.02695e-16)
(0.905412 -0.283439 2.77375e-16)
(-1.13611 -0.558619 0)
(1.35053 -0.0292439 -3.07142e-16)
(1.00202 -0.317491 1.69146e-16)
(8.56728 0.0938007 7.99765e-17)
(2.19481 -0.0953971 0)
(1.14713 -0.539976 -1.00767e-16)
(1.71465 -0.42278 1.63471e-16)
(2.56447 -0.141079 8.8358e-21)
(1.72574 -0.744533 -1.24989e-16)
(0.0446092 -0.177649 -5.24805e-17)
(8.7537 0.136701 3.64365e-17)
(0.069748 0.383099 -2.26948e-18)
(0.00668506 -0.356302 6.34433e-18)
(0.443494 1.09192 0)
(-0.920955 1.86719 0)
(0.0185577 -0.331623 0)
(1.47725 -0.085936 2.70862e-16)
(-0.328256 -1.50694 -4.78436e-16)
(0.018101 -0.0485356 -2.7796e-17)
(-0.33506 1.46001 -1.978e-16)
(-0.527715 2.35575 5.59718e-16)
(1.07866 -0.992859 2.21798e-16)
(0.951058 -0.906601 -1.60081e-16)
(0.112384 1.42835 -1.22973e-16)
(0.069819 -0.0164724 -4.21737e-17)
(0.27318 0.133838 -8.43059e-17)
(0.210333 1.27232 6.60792e-17)
(0.141028 0.0662745 1.74886e-16)
(0.310562 1.41899 -1.48463e-18)
(-0.497725 -1.36502 -6.21081e-16)
(0.459296 0.706167 7.43968e-19)
(1.07966 -0.08912 1.56398e-16)
(0.306134 -0.916155 9.48198e-19)
(0.515494 -0.67352 -2.52249e-16)
(0.465923 2.83706 0)
(0.565975 2.36478 0)
(1.4163 1.20589 -9.42814e-18)
(2.54093 7.49412 -9.1106e-17)
(-0.200043 4.89448 1.88809e-16)
(-0.11676 8.34906 -1.27769e-16)
(0.508174 2.7804 8.16692e-17)
(0.938192 1.5943 -3.23519e-17)
(6.85703 4.75173 -1.80974e-16)
(0.322136 -1.17587 -1.77187e-16)
(0.509517 -0.362668 2.3708e-16)
(0.57449 2.41378 -1.11551e-16)
(1.57447 5.12214 1.06249e-16)
(0.884227 1.09041 1.39778e-16)
(-0.110193 7.72804 3.63336e-17)
(1.06749 -1.8702 -1.8589e-16)
(0.0505539 1.51709 1.18282e-16)
(0.568681 2.21012 0)
(0.0159665 1.76001 2.7348e-17)
(-0.175608 3.6326 0)
(0.00224395 2.21512 6.42305e-18)
(4.54047 2.74789 0)
(-0.0393965 2.30401 6.32063e-17)
(-0.0215112 2.95077 0)
(-0.119347 3.95994 0)
(-0.374354 2.80067 -1.45973e-18)
(-0.0545801 -1.30275 2.61982e-16)
(0.0244338 1.31973 -2.55112e-16)
(0.034756 3.50371 0)
(2.3225 8.07571 0)
(2.00094 -0.0665754 2.25574e-16)
(0.93678 -1.07229 1.22332e-16)
(-0.089122 2.68559 0)
(1.75969 -0.0547814 2.83696e-16)
(0.863557 2.09695 -1.50462e-17)
(0.156876 2.34831 5.44491e-17)
(-0.695676 9.31437 -6.62049e-17)
(-0.204669 3.64845 -8.74165e-17)
(-0.0228774 2.52404 -9.81976e-17)
(0.0955404 0.397299 -2.63345e-17)
(8.81098 0.141564 -3.38618e-16)
(8.1659 0.248543 8.5122e-18)
(2.06832 -1.05462 5.72111e-16)
(-0.0792227 3.07958 -4.97522e-18)
(0.533207 0.174109 3.14047e-16)
(0.105861 4.36032 6.27518e-18)
(5.7855 4.8367 0)
(0.678763 2.52866 0)
(0.220204 0.816108 4.07056e-17)
(0.325079 0.381345 0)
(0.213249 -0.958555 -4.31718e-16)
(0.118823 0.882464 -5.41232e-17)
(0.391381 3.195 -1.06125e-16)
(0.38564 -0.477077 2.07941e-16)
(-1.19519 10.3126 -2.19626e-17)
(0.223417 0.775856 -2.62672e-16)
(0.00785866 1.64482 0)
(-0.0615725 2.38942 0)
(0.186562 0.409338 -5.1156e-17)
(5.25819 6.16966 0)
(2.34401 6.65565 0)
(0.0467302 0.386102 0)
(-0.035738 7.75454 -1.36774e-16)
(6.78721 5.4815 7.27778e-17)
(-0.621072 -1.11958 -2.53484e-16)
(0.172617 1.55641 -2.38432e-16)
(-0.00156046 1.44628 1.8282e-16)
(0.0597838 0.911798 6.69825e-17)
(4.50713 7.15774 -3.27679e-17)
(0.0451855 0.936024 1.97297e-18)
(6.59104 6.20661 -3.82315e-17)
(-0.221852 6.45656 -4.50964e-17)
(1.33781 -0.0118239 1.25638e-16)
(2.32178 -1.25793 2.02492e-16)
(0.522847 -1.11353 9.49924e-17)
(0.43969 0.126318 -4.63018e-17)
(-0.0391567 2.29911 -9.66987e-18)
(-0.809574 9.79949 2.68837e-17)
(-0.141997 3.17136 1.4872e-16)
(-0.10964 2.7993 -1.25822e-21)
(-0.00279676 1.51135 2.79558e-17)
(2.04717 -0.287676 1.30891e-16)
(7.48303 5.82646 -1.63013e-16)
(0.265798 3.5704 1.30672e-17)
(-0.397071 -0.53985 2.0302e-16)
(0.789439 -0.05252 2.89016e-16)
(4.37576 4.75045 2.73663e-17)
(8.23621 0.331404 -2.94419e-16)
(-0.0251256 0.578885 7.00242e-17)
(0.0135913 1.57223 7.11738e-18)
(0.00639493 4.72598 -1.20447e-17)
(2.60595 4.93647 5.97281e-17)
(-0.263578 5.33663 8.58657e-17)
(-0.299464 8.7665 1.85486e-17)
(-0.0307717 5.0535 0)
(0.810011 0.410546 0)
(3.872 1.9893 4.84204e-16)
(0.991631 1.52776 -6.46016e-18)
(-0.535855 9.07052 4.82795e-17)
(8.74711 3.56736 -3.99813e-17)
(-0.199582 4.23866 2.24937e-17)
(-0.0749432 2.51431 -1.24033e-17)
(5.0647 -0.645344 2.53902e-16)
(1.2526 1.73221 -5.43678e-17)
(-0.302317 5.5665 -3.98444e-17)
(-0.15832 3.39073 9.05404e-17)
(0.164715 3.26489 -1.50324e-16)
(0.047112 1.77917 1.99236e-16)
(0.91327 2.08311 6.22727e-17)
(-0.309025 9.29034 3.80443e-20)
(8.99116 1.83552 1.09853e-17)
(0.0147377 1.92836 -1.63568e-16)
(-0.0161786 0.640239 -1.10957e-16)
(-0.42758 7.96541 -7.60626e-17)
(5.52136 6.92664 0)
(-1.25001 -1.37513 0)
(-0.138037 3.24865 -9.49716e-17)
(0.213703 6.7394 2.30313e-19)
(-0.137415 6.65664 3.05125e-17)
(1.56692 5.45807 7.42989e-17)
(-0.503764 10.5806 5.01319e-18)
(1.58277 1.36132 2.32508e-18)
(-0.319788 8.62728 1.57993e-17)
(4.27547 2.34823 0)
(8.5546 4.69459 -5.38482e-18)
(8.32816 4.34014 -7.82523e-17)
(3.72335 8.14384 3.12099e-18)
(0.90228 3.76178 -7.04049e-17)
(-1.08358 -1.08398 -1.81267e-16)
(1.79668 -0.0340941 -2.05632e-16)
(0.811528 0.216986 -1.31007e-16)
(-0.783842 -0.937497 -1.03243e-16)
(-0.047693 3.52887 0)
(0.497916 1.348 7.28657e-18)
(0.151529 6.5867 0)
(6.35974 6.33088 0)
(5.81619 5.25919 4.10056e-17)
(-0.00556083 6.4248 0)
(5.78087 3.93903 1.0785e-16)
(4.13223 2.11646 -1.31231e-16)
(5.5557 5.8478 4.85071e-17)
(7.32824 1.34546 0)
(-0.439097 9.43283 -6.68499e-18)
(4.34734 7.68171 1.13349e-17)
(0.414862 -0.93481 3.43471e-16)
(1.09437 -0.0647938 -1.48434e-16)
(7.32349 5.42236 2.2439e-16)
(7.18317 0.11196 -5.60908e-18)
(-0.119182 3.14537 9.98436e-17)
(-0.428794 6.95017 1.00284e-16)
(-1.1714 -1.41606 1.05711e-16)
(-0.730562 -1.26575 -1.80574e-16)
(-0.2668 4.67928 0)
(1.35289 0.691295 -4.89804e-17)
(7.60844 3.49367 1.06243e-16)
(7.36484 1.67883 -1.0989e-16)
(7.64905 4.71844 6.33366e-17)
(-0.169737 4.12008 -4.84846e-17)
(9.04427 2.86752 5.68092e-17)
(-0.555621 9.36304 -9.02372e-19)
(-0.277682 8.88174 -2.14485e-17)
(2.83209 1.11406 3.8921e-16)
(-0.122799 9.07144 3.66356e-17)
(-0.226777 6.74522 4.55834e-17)
(0.520909 8.86061 2.91253e-17)
(0.133253 10.7075 5.28542e-18)
(0.645477 0.139076 2.15342e-16)
(-0.20614 5.21155 -8.18865e-17)
(8.21188 5.17629 -9.5307e-17)
(-0.716729 -1.63488 1.05353e-16)
(-0.0227837 4.57983 0)
(-0.0566497 10.8124 2.35964e-18)
(5.00696 6.86347 -2.3979e-17)
(-0.144549 4.09444 -4.60444e-17)
(8.63234 0.380524 4.12072e-16)
(4.01387 0.313737 2.47596e-19)
(0.132319 -0.964471 2.60233e-16)
(0.137689 0.382321 2.23603e-16)
(-0.150342 4.7128 1.60076e-16)
(0.843424 -0.946216 1.67175e-16)
(-0.179949 6.44442 1.17389e-16)
(-0.0298499 -0.0604968 3.68842e-16)
(9.41259 1.16451 6.79714e-17)
(0.249285 4.04427 -7.71263e-17)
(4.56544 0.00993906 4.95734e-18)
(0.136208 -0.63684 4.53234e-16)
(8.65474 4.15158 0)
(0.763224 0.570589 0)
(0.464139 0.26304 1.6524e-16)
(-0.521579 3.71082 1.05278e-18)
(1.93903 0.694 0)
(2.83187 -0.289028 0)
(1.30345 -0.963968 0)
(0.247153 -0.837238 -4.67932e-17)
(0.550995 0.132988 5.65629e-17)
(2.43752 -1.37485 0)
(0.800603 0.283597 8.62098e-16)
(-0.686945 -0.912636 -9.00386e-16)
(-0.110268 -1.62196 1.36349e-16)
(-0.255393 0.0413065 -2.7871e-16)
(-0.465408 -0.144733 2.56432e-17)
(2.68374 -0.0164143 1.06345e-16)
(8.06844 3.03531 2.64707e-16)
(-0.138643 8.74801 3.71177e-18)
(-0.446068 -1.86799 -1.90588e-17)
(-0.436346 -0.00676129 8.89166e-16)
(0.0154111 -0.558384 0)
(-0.217778 0.102094 -3.87863e-16)
(0.365946 -0.0381863 2.76484e-16)
(0.512353 0.190275 0)
(-0.665031 0.0495831 2.13187e-16)
(1.92068 0.88747 9.9093e-18)
(-0.556286 0.0451016 0)
(0.000572874 0.277532 1.16404e-16)
(8.14325 2.45183 -3.88464e-17)
(8.58446 3.63677 -1.77744e-16)
(2.02986 9.35767 -1.15894e-16)
(-0.00786678 0.124898 3.73056e-16)
(-0.722048 0.0475669 -7.38639e-16)
(1.78643 9.9067 -6.75516e-17)
(1.55422 -1.47655 -9.70464e-17)
(0.756392 0.192224 -5.63321e-18)
(0.294447 3.05528 8.19347e-17)
(-0.275247 6.56552 1.22781e-16)
(0.267892 0.15192 0)
(-0.610386 0.0467606 1.97519e-16)
(-0.0272415 -0.0470981 0)
(-0.00534091 3.02246 0)
(-0.046231 2.59635 1.1301e-16)
(1.22915 0.312825 -1.75478e-16)
(0.115367 -0.667408 9.85749e-17)
(-0.776449 0.0405617 3.57047e-16)
(0.0243593 2.45156 -9.77155e-17)
(0.233598 1.28064 0)
(0.212878 4.40256 1.00113e-18)
(1.96026 -0.469523 3.09991e-16)
(-0.180892 10.5428 1.94599e-17)
(-0.220557 6.96619 4.6557e-17)
(-0.230993 8.54106 1.16664e-16)
(4.28888 1.31172 -4.96404e-17)
(-0.0245554 3.60422 -1.622e-19)
(-0.313203 -1.32767 -1.5627e-16)
(1.65699 0.609127 -1.1801e-16)
(6.61826 -0.0651042 6.07116e-17)
(3.42209 -0.417088 -1.67866e-16)
(-0.531973 0.0948941 0)
(-0.0212726 3.57798 0)
(-0.309907 6.74506 0)
(-0.28752 6.37183 2.34272e-16)
(-0.124684 8.94689 -2.14657e-17)
(0.374608 0.66872 0)
(0.418855 -0.164024 0)
(-0.768449 -0.076301 5.84485e-17)
(0.972275 -1.63118 8.17253e-17)
(0.0110814 4.16071 1.73893e-16)
(-0.121698 -1.346 3.51969e-16)
(-0.658915 -1.24815 0)
(1.03674 -0.457108 -4.80136e-17)
(3.11282 1.97609 6.82011e-16)
(-0.115724 6.85227 -1.21323e-21)
(-0.313981 8.87181 0)
(-0.792309 0.588624 -2.45429e-16)
(-0.0850419 6.15838 4.20211e-17)
(-0.306749 5.2564 7.45395e-17)
(1.73555 -0.0189473 1.13171e-16)
(-0.174489 4.5549 0)
(-1.96906 0.0430412 1.41607e-16)
(0.24322 0.175823 6.80058e-16)
(0.114326 0.23401 3.52446e-16)
(1.50464 0.172842 0)
(0.0467899 -0.751164 2.89615e-17)
(0.0826162 1.36859 -1.23472e-16)
(6.03747 1.06696 -9.97424e-18)
(-0.121455 8.80398 -1.20243e-17)
(4.78333 -0.873671 -3.10195e-16)
(-0.341009 0.0394306 1.69253e-19)
(0.464926 0.742575 1.42099e-16)
(-0.185497 5.69859 2.30803e-16)
(2.45522 0.427531 -1.1295e-16)
(1.26949 6.08112 1.14887e-16)
(-0.126258 9.16993 0)
(8.44269 0.909615 -1.21203e-16)
(0.173807 2.65613 -8.74075e-17)
(-0.107139 5.32927 5.66721e-17)
(0.281604 -0.413556 1.9958e-16)
(1.02415 0.249258 -6.72011e-20)
(3.38898 1.30924 -4.23841e-17)
(0.493499 3.58876 -5.19181e-17)
(5.55398 2.67381 0)
(-0.131765 7.50316 -1.89847e-17)
(2.7688 3.08901 0)
(1.20625 -0.954987 0)
(-0.062448 5.34153 1.79945e-16)
(1.88383 -0.0279853 -7.716e-17)
(0.256519 0.168873 -3.32017e-20)
(0.282521 -1.05309 2.57574e-16)
(-0.0906887 -0.173442 1.95405e-16)
(-0.985059 0.364675 4.51948e-19)
(-0.107851 5.24034 -2.93196e-16)
(4.08194 1.89404 2.91695e-17)
(-0.379225 0.0755266 3.98184e-16)
(0.339112 1.01507 1.59578e-19)
(1.34996 6.44305 1.61986e-16)
(0.185849 0.442896 0)
(-0.0581638 -0.548108 3.97207e-17)
(-0.0745108 7.58976 2.48221e-17)
(1.77277 -0.157466 -2.12072e-17)
(-0.22646 -0.760537 -7.2954e-17)
(-0.244188 -1.58169 -2.23894e-16)
(0.287831 0.0763934 3.50148e-16)
(-0.257207 4.56479 0)
(-0.0545088 3.32775 5.49633e-17)
(2.3032 8.13086 -1.40105e-16)
(0.321473 1.01821 1.22747e-16)
(0.623736 0.0219379 -4.32329e-16)
(-0.12613 5.42709 0)
(0.201071 -0.411263 -4.92036e-16)
(2.84836 -0.103028 -1.0187e-17)
(8.27104 1.47556 -6.08483e-17)
(-0.440454 8.0368 7.76728e-17)
(5.86555 -0.0982058 8.38071e-18)
(-1.28868 -0.407076 -2.24322e-16)
(0.427491 0.292089 -5.47802e-17)
(-0.0190044 -1.0568 -2.85087e-16)
(-0.354482 -0.874746 -1.66407e-16)
(-0.356621 6.77437 7.91678e-17)
(-0.670177 -1.85557 -2.51499e-16)
(5.86414 2.62745 1.96748e-16)
(0.945492 -0.0615087 -3.45727e-16)
(-0.0731226 -0.64184 1.88546e-16)
(8.42231 0.505886 8.13393e-17)
(-1.61885 0.233816 3.39155e-19)
(-0.0707429 9.16022 7.57808e-17)
(-0.0649976 7.03518 4.38272e-17)
(-0.176425 8.30754 -5.7e-17)
(-0.197788 5.65709 3.7703e-18)
(-0.111244 7.09462 9.14842e-17)
(1.26702 0.41595 -1.06472e-19)
(-1.72623 -1.18955 1.93151e-16)
(1.01728 -0.230252 -7.97448e-17)
(-0.115887 7.55767 0)
(-0.115373 -0.00951719 -1.91739e-16)
(-0.481476 8.93106 -4.74108e-17)
(4.6245 0.627764 -6.85572e-17)
(-0.0255261 4.05001 2.57482e-19)
(-0.598306 0.462262 -2.72099e-16)
(2.67034 1.10107 -9.89599e-17)
(0.440526 -0.469528 1.95621e-16)
(0.283237 0.0543261 1.89299e-16)
(-0.0820152 3.55288 0)
(8.72582 1.4268 0)
(8.15789 1.05539 4.45886e-17)
(-0.0980173 5.65477 0)
(3.36177 0.827419 0)
(2.02025 0.713135 -2.09284e-16)
(0.145983 0.419319 0)
(1.55188 -0.326684 9.5797e-17)
(3.14507 0.0318734 1.57723e-16)
(0.0425903 0.692259 6.82392e-19)
(-0.908677 0.652808 -1.03419e-16)
(-0.487009 0.0568474 -4.02615e-16)
(0.159796 -0.261028 -9.28237e-20)
(0.0841075 -0.0889469 0)
(0.0287665 0.526219 -7.2572e-17)
(-0.0970919 5.41842 8.39158e-17)
(0.1644 3.88795 2.54512e-17)
(2.41546 -0.228207 -4.91013e-19)
(0.718936 -1.09754 0)
(2.09856 8.66764 2.7612e-18)
(1.71584 0.140227 -1.54054e-16)
(-0.411399 7.12701 1.44385e-16)
(4.39514 -0.0559173 0)
(-0.769385 -1.14981 -6.37476e-16)
(3.05587 -0.999864 1.67822e-16)
(5.55309 0.30759 4.08955e-17)
(0.0923892 9.48335 -4.88321e-17)
(0.124708 1.51378 0)
(0.0896316 0.0903133 1.48608e-16)
(1.21819 0.106962 6.30635e-16)
(2.68496 0.376905 -9.31687e-19)
(4.02979 0.104507 4.45811e-16)
(3.25707 0.0585007 5.8775e-17)
(-0.487305 10.4617 -9.63084e-17)
(0.571749 2.83022 -3.19517e-16)
(-0.3499 5.92758 -2.91044e-16)
(8.654 0.241075 6.43487e-19)
(0.685108 0.103923 -5.80965e-16)
(-0.211727 -0.0437645 -1.27094e-17)
(1.08755 -0.194768 1.86216e-16)
(0.0417435 9.44514 5.26581e-17)
(-0.541532 7.09394 -1.87626e-16)
(3.00874 -0.0609306 2.35548e-16)
(0.00120427 2.1431 5.29725e-17)
(0.00902144 0.737785 -8.16754e-17)
(-0.581652 0.0533103 5.28062e-16)
(-1.08314 -1.04065 -9.45654e-17)
(-0.10409 0.0454959 -6.73085e-17)
(0.549936 1.95347 -1.20652e-16)
(0.604944 0.361949 4.4544e-19)
(0.074141 4.1998 0)
(0.080267 6.204 0)
(0.0493592 6.13614 0)
(0.0649008 6.16163 -3.74141e-17)
(-0.161168 6.08169 2.23086e-17)
(0.00126551 5.99017 0)
(-0.168818 6.4905 0)
(-0.0760315 5.9544 0)
(0.0986367 7.4513 -7.79288e-17)
(0.0646631 6.14269 0)
(0.168176 5.89923 0)
(0.155779 7.14442 7.86045e-17)
(0.0199089 7.49454 0)
(-0.0425442 7.44536 -3.58175e-17)
(0.191624 6.78826 1.9176e-17)
(-0.0352294 6.18081 0)
(0.304344 5.38802 -1.01366e-16)
(0.221117 5.97081 -3.71038e-17)
(0.221303 6.39464 2.26082e-17)
(0.451783 4.6044 1.13321e-16)
(0.549075 3.61504 3.47107e-17)
(0.648132 1.83101 1.88399e-17)
(0.602236 2.68694 -2.05354e-17)
(-0.0623704 7.39061 3.7346e-17)
(-0.0615566 7.37524 0)
(-0.0496858 7.36189 0)
(0.0119016 6.08151 3.73954e-17)
(4.6796 -0.068119 4.3421e-17)
(8.35002 0.0276182 -2.39854e-18)
(-0.779718 -0.0179057 -3.07061e-16)
(-0.524072 -1.55897 -8.79783e-17)
(0.921697 0.772674 -1.84466e-16)
(-1.40502 0.579934 -2.01665e-16)
(1.35656 -0.64054 2.85733e-16)
(0.388716 -0.979269 2.44374e-16)
(-1.64672 0.00242896 0)
(-0.253395 6.72989 -1.45659e-16)
(0.210394 5.99015 -6.7309e-17)
(-0.271767 6.12358 -4.3328e-17)
(-1.33085 0.281021 -4.20538e-16)
(1.27259 0.191288 0)
(8.76761 2.18597 -1.0351e-17)
(0.452415 -0.607563 -1.50096e-16)
(0.945726 -0.123929 1.68689e-16)
(-1.26619 -1.15498 8.0533e-17)
(1.47365 -0.0617958 8.38076e-16)
(0.0550012 8.41703 1.0038e-16)
(3.14269 -0.0922861 0)
(2.34306 9.75596 3.12305e-16)
(-0.0688313 5.38166 0)
(-1.84971 -0.231479 0)
(-0.0534415 7.36667 0)
(-1.14202 -0.214481 8.00312e-17)
(-0.155687 -0.719508 1.8475e-16)
(8.93858 0.915849 -2.61759e-16)
(-0.859606 0.0358098 -2.07972e-16)
(8.78216 0.576992 -8.00975e-17)
(0.125196 1.73227 0)
(1.79235 0.0870644 0)
(-1.66299 -0.904817 -1.10647e-16)
(-0.37674 7.9048 1.64127e-16)
(-1.0667 0.897876 0)
(0.305619 0.0535126 -3.53622e-16)
(0.175261 0.209351 0)
(-1.16425 -1.21364 0)
(0.0397547 0.149106 3.7205e-17)
(4.48875 0.279951 5.77303e-19)
(-0.31898 7.65942 -3.88961e-17)
(-0.932738 0.179087 -3.93407e-16)
(-0.844904 -0.140106 2.78165e-16)
(2.72536 0.146138 -1.50792e-16)
(-0.0271508 5.34141 0)
(6.91534 0.17043 3.27631e-17)
(8.41419 1.9046 0)
(2.1373 0.915923 -3.53494e-16)
(1.61123 0.341317 -2.73769e-16)
(3.23193 1.03705 -3.19799e-16)
(0.850312 0.312094 -1.88188e-16)
(2.65608 1.01818 -1.67155e-16)
(0.97281 -1.3643 -5.53511e-16)
(-0.225237 -0.143485 -1.39882e-17)
(1.80686 -0.182774 5.59506e-17)
(3.1131 -0.0986122 -1.25016e-17)
(4.33313 0.278686 1.56618e-17)
(-0.152497 5.80667 9.03239e-17)
(4.71858 2.49076 2.70815e-16)
(-0.0636923 7.08335 1.88202e-17)
(1.87136 0.0990493 6.26241e-19)
(-0.052438 5.18214 -2.13467e-19)
(-0.507137 1.93234 -1.70045e-18)
(0.857573 0.35365 2.63347e-16)
(3.36587 -0.343239 2.23069e-16)
(0.50333 0.629129 1.50347e-16)
(-1.16285 -0.922437 -3.98655e-16)
(-1.61765 -0.319134 2.43679e-16)
(-0.132497 4.99121 3.14959e-16)
(-1.86139 -0.0849152 0)
(-0.10247 5.22136 -1.88407e-16)
(3.62829 -0.0983459 -4.37229e-16)
(4.42626 -0.134271 -2.81884e-17)
(1.10733 0.143589 -5.77775e-16)
(-0.31543 8.73546 4.82343e-17)
(2.21159 0.0607704 -1.03313e-16)
(-0.171077 -0.023346 -6.4328e-16)
(2.38593 -0.699759 1.1265e-16)
(-0.0384075 5.53629 4.62094e-17)
(-0.368997 2.50247 -2.74319e-16)
(-0.225672 5.16527 -2.34376e-17)
(8.47953 0.140114 -3.90736e-17)
(-0.0665258 7.21119 1.79518e-17)
(-0.140464 5.64355 3.4548e-17)
(4.11666 -0.163764 9.49238e-17)
(-0.571202 0.924576 2.95418e-16)
(0.0117553 4.31353 -1.91613e-16)
(-0.541959 -0.0166772 3.49927e-16)
(0.6839 -0.388546 2.87208e-17)
(-0.772086 -0.453346 0)
(2.43192 9.09436 -9.17563e-17)
(-0.0918161 4.09134 -7.28177e-17)
(0.576505 2.76333 1.40469e-16)
(3.42651 1.33792 -4.461e-16)
(-0.694631 -0.853361 2.4987e-16)
(-1.4803 -0.304246 1.6053e-18)
(-1.72326 0.611714 -5.99767e-17)
(0.184057 1.02287 -3.77632e-20)
(2.18272 -0.0936453 6.70632e-17)
(0.150486 -1.09053 2.04634e-16)
(8.44887 0.693409 -1.14568e-17)
(0.352772 -0.292113 -1.98764e-16)
(-0.616824 0.214726 4.58872e-16)
(-0.52267 0.0142157 1.62157e-16)
(1.19583 0.286492 2.7765e-16)
(-1.34931 -0.637934 6.11228e-17)
(8.03818 0.047817 -1.52904e-16)
(0.157441 2.10785 2.35381e-16)
(-0.564053 -0.603894 5.92103e-16)
(-0.732116 -0.576908 4.23493e-16)
(-0.7878 -0.0115274 2.32318e-16)
(0.319664 5.11288 -6.05835e-18)
(0.667701 0.625875 -3.34994e-16)
(-1.51253 -0.330886 -1.2986e-16)
(0.585797 -0.0686903 9.57637e-17)
(5.11341 -0.152184 -3.05087e-16)
(-0.396487 7.53487 -1.32957e-16)
(0.110442 5.35661 2.69422e-17)
(-1.17035 -0.423361 5.13765e-16)
(-1.13331 0.0236548 -2.95863e-16)
(1.70323 3.24517 0)
(-0.299534 8.7235 -9.22649e-17)
(-0.057957 5.51913 -2.72785e-17)
(-0.0167501 5.86625 1.76663e-17)
(0.249543 6.12979 -3.78475e-17)
(-0.0765066 7.26201 -5.73096e-17)
(0.033931 -0.700295 2.28857e-16)
(-0.250669 -0.0126059 -4.22044e-17)
(0.435109 7.13 1.02402e-16)
(1.88303 0.11748 0)
(-0.336922 0.0848287 -2.07485e-17)
(1.81336 0.837062 3.94769e-17)
(-1.98293 -0.466095 0)
(2.36873 0.440651 -3.95793e-16)
(-0.016865 -0.166291 0)
(1.67461 -0.622182 -2.07635e-19)
(8.65844 0.281293 1.62069e-16)
(2.53598 0.338285 2.82004e-16)
(2.16836 0.0990816 -6.81628e-17)
(-1.35116 -0.424036 0)
(0.196595 -0.406703 1.0061e-15)
(1.95904 0.0703295 -1.90856e-17)
(-0.117527 -0.796912 5.58839e-16)
(0.100689 -0.450013 1.7892e-19)
(-0.623986 -0.0170681 0)
(1.04231 1.35236 2.02295e-16)
(-0.238463 6.54456 -8.04262e-17)
(-0.282914 -0.659917 5.10584e-16)
(0.45091 -0.824151 9.07051e-16)
(-0.458166 -0.0262056 1.78478e-16)
(-0.312993 8.76196 -6.18414e-19)
(2.37117 0.0670521 -3.05874e-17)
(1.6512 -0.577325 -2.56894e-16)
(2.04965 0.0345788 0)
(1.93664 3.01071 0)
(0.0278764 -0.0266542 -2.87902e-16)
(4.40734 0.114282 3.77618e-16)
(0.880751 -0.0941472 -2.16465e-16)
(9.75857 1.76166 0)
(1.02448 0.190253 1.35059e-18)
(2.01513 0.0796994 1.54411e-16)
(-0.495226 -0.0486954 -8.01525e-17)
(-0.320176 8.42581 1.69408e-16)
(0.482824 0.42739 4.35857e-16)
(0.382391 -0.593743 -7.32034e-16)
(0.658535 -1.00794 7.5685e-16)
(-0.206759 -0.0918638 3.781e-17)
(1.76143 0.331173 -1.78226e-16)
(0.411104 0.458561 2.56709e-16)
(-0.719466 -0.02589 2.30321e-17)
(0.459501 -0.0672029 2.46706e-16)
(-0.831426 0.00778596 3.38731e-16)
(2.59195 -0.0884153 -8.49385e-17)
(9.57201 1.86675 0)
(-0.808115 0.00569559 -6.51287e-16)
(-0.854339 0.000253825 0)
(-0.153973 -1.00515 1.38676e-19)
(0.526777 -0.467967 -2.35376e-16)
(8.74173 0.145113 0)
(-0.0563434 7.0038 -7.231e-17)
(-0.769503 -0.00629139 -2.56941e-17)
(-0.795834 0.0106847 3.86177e-16)
(-0.731317 -0.0089142 0)
(-0.790385 0.00137069 -2.59821e-17)
(2.40547 0.0581201 -7.29633e-18)
(2.397 0.0258327 7.37004e-18)
(-0.895958 0.0273584 0)
(-0.90811 0.0193154 0)
(-0.898533 0.00165384 0)
(-0.880675 0.00453791 -2.08428e-17)
(1.8656 -0.0190477 7.30067e-17)
(0.358415 -0.583601 1.21656e-16)
(-1.28838 -0.836173 9.79615e-17)
(1.82388 0.218688 -3.17733e-16)
(0.410145 -0.071651 2.09047e-16)
(-0.0259794 3.25661 -8.23743e-17)
(-0.178357 5.86775 0)
(3.19907 -0.176275 -1.777e-16)
(-0.0879142 5.56495 2.25117e-17)
(0.00436927 5.81148 -5.45368e-17)
(0.179771 0.467254 -2.70059e-16)
(-0.26547 0.124148 1.83038e-16)
(-0.159958 -0.268778 -1.99419e-16)
(-0.871591 1.06291 0)
(-0.0306927 7.04955 1.37134e-16)
(4.74915 1.32434 0)
(-0.301538 7.14154 -5.52225e-17)
(0.0431673 1.15051 -2.81635e-16)
(-0.826211 0.0362357 0)
(0.448566 4.95682 7.64967e-17)
(4.6981 -0.0613215 1.56896e-16)
(1.13162 0.450151 1.40591e-16)
(0.197048 -0.506555 -2.65578e-16)
(3.91499 -0.212475 -1.82316e-16)
(4.42562 -0.112892 4.3734e-17)
(0.0973314 6.86272 0)
(-0.908466 -0.214912 -2.3667e-17)
(2.26786 4.84523 -2.1904e-16)
(0.765406 0.282716 -3.12885e-19)
(1.35709 6.36244 -1.46313e-17)
(-0.0287909 5.73562 2.16953e-17)
(-0.123706 5.75719 0)
(8.84305 1.01923 4.13503e-17)
(1.095 -0.76925 -9.64556e-17)
(-0.0328295 -0.0506554 -7.34628e-17)
(1.9725 0.428059 0)
(1.22105 0.191037 9.44257e-17)
(5.30808 0.194269 -2.18911e-16)
(3.29895 0.312758 -6.74822e-18)
(2.48387 -0.342341 -2.68729e-16)
(2.11955 -0.48991 1.64564e-16)
(0.262978 0.942402 -4.74931e-17)
(0.220022 -0.534703 0)
(0.74061 0.339911 -1.34029e-16)
(5.17789 -0.786386 -4.84325e-16)
(-0.428153 8.13511 -3.89562e-17)
(2.33249 -0.353924 -3.6087e-16)
(-0.257193 5.71837 -8.40002e-17)
(0.382852 -0.33185 -5.07476e-16)
(1.251 -0.229911 0)
(-1.6408 -0.324365 -3.08898e-17)
(4.67178 2.52395 -1.6016e-16)
(1.00202 8.37927 3.90084e-17)
(0.116295 0.541499 3.14219e-16)
(0.341026 0.00780791 0)
(-0.13113 -0.840036 3.87912e-17)
(2.6471 9.37689 1.91259e-16)
(-0.196299 5.01074 -6.4548e-17)
(2.3804 -0.00394426 -5.65403e-17)
(2.31516 -0.0328648 6.08414e-17)
(-0.342295 7.77035 -2.04933e-17)
(-0.448545 0.0570621 -3.07505e-16)
(-2.6642 0.718379 3.19751e-18)
(4.69233 0.21164 -1.69429e-16)
(4.15034 0.163945 7.84829e-19)
(3.91722 0.784159 -1.0884e-18)
(-0.32257 7.08254 1.55392e-16)
(8.43185 0.0836642 3.39676e-16)
(3.53145 2.92104 3.89637e-17)
(-0.097219 5.63497 0)
(-0.0047848 5.72536 -2.0657e-17)
(-0.149829 3.33748 0)
(0.357455 0.959026 3.71458e-16)
(6.31769 2.37875 -1.26179e-16)
(1.33076 -0.938621 -4.62321e-18)
(0.928134 6.14093 1.70396e-16)
(-0.266802 -0.399875 1.09218e-16)
(-0.441544 0.0710219 2.52434e-17)
(-0.00325909 -0.0655318 9.05904e-20)
(0.140456 1.29529 5.61697e-17)
(-1.18825 -0.487947 -9.30861e-16)
(0.372049 -0.307489 8.95919e-16)
(-0.50633 -0.816721 3.65784e-16)
(4.87315 0.601809 -3.83217e-17)
(0.987003 -0.912726 -1.86927e-16)
(2.93435 -0.459732 2.11516e-16)
(1.04813 -0.31001 7.55508e-20)
(0.480363 1.49187 -2.47803e-16)
(7.7186 0.0387875 0)
(3.69853 0.339828 -2.69605e-16)
(-0.176314 7.16635 -4.19344e-17)
(6.0038 -0.64842 2.38693e-16)
(-0.139827 2.52153 9.48067e-21)
(-0.315771 7.46631 -1.89789e-16)
(-0.153454 -1.01258 0)
(0.465221 0.15212 0)
(2.73257 -0.494243 -2.73254e-17)
(3.27306 -1.2857 4.96548e-17)
(-0.165315 0.636338 -1.0219e-17)
(0.254855 -0.696695 -1.35981e-16)
(1.64544 0.305063 2.74238e-19)
(0.522629 -0.0229978 -1.60008e-16)
(4.0223 -0.130864 -4.93687e-17)
(0.432211 9.64727 -1.03872e-17)
(8.34083 0.208623 -2.47748e-17)
(-0.103288 0.0941286 -1.09826e-19)
(-0.164061 0.0272276 4.22908e-16)
(4.48867 1.91516 1.56886e-16)
(-0.534103 0.0257846 -2.22177e-16)
(-0.984947 0.416425 3.68094e-16)
(6.18515 1.90128 -9.18851e-17)
(6.18925 2.70302 -2.06768e-19)
(0.897981 -0.0867646 0)
(1.64082 3.13038 0)
(7.62437 0.110739 -1.93315e-16)
(0.943614 0.248762 2.56707e-16)
(0.266187 0.233812 -1.22227e-16)
(0.393304 -0.0604919 -2.16039e-16)
(-0.470281 0.0321984 6.80949e-17)
(3.26344 0.790063 -9.25263e-17)
(-0.929206 -0.449649 0)
(0.102857 -0.778379 -1.98484e-16)
(9.17109 0.701452 -4.93613e-18)
(2.91517 -0.35817 1.91857e-16)
(1.8935 0.000384319 -7.38043e-17)
(0.0105707 7.89881 0)
(-0.317536 6.55512 -1.85292e-16)
(-0.0867146 4.15059 -2.8994e-16)
(-2.40751 0.111029 -1.93249e-16)
(1.23839 8.99674 1.12873e-17)
(8.98737 1.20711 -1.82998e-17)
(1.25345 0.17758 0)
(3.3854 -0.398214 1.30583e-16)
(0.112577 -0.465775 -2.2089e-17)
(0.320039 -0.386436 -4.96479e-16)
(3.81333 -0.320486 -5.65098e-16)
(-0.719996 -0.493102 -2.53418e-16)
(1.17433 -0.373116 2.09486e-16)
(2.37605 0.821556 6.71734e-16)
(0.231874 -0.0880383 -1.22973e-16)
(-0.119519 4.01259 -7.50501e-17)
(-0.373362 -0.960847 -6.12107e-16)
(0.616406 -0.121836 8.27917e-17)
(3.8586 -0.313154 8.46169e-17)
(-0.788148 0.399817 2.20202e-16)
(0.490142 -0.89649 0)
(-0.90209 -0.212323 1.19536e-16)
(0.197819 0.723575 -1.4859e-16)
(-0.296192 -0.354093 1.96523e-16)
(0.394438 0.519902 8.17881e-17)
(-0.118156 9.90814 2.17208e-16)
(-0.587624 0.0164213 4.10463e-16)
(1.27281 3.00301 0)
(-0.883763 -1.02853 -4.13029e-16)
(1.24497 0.157067 -3.76685e-16)
(-0.232229 7.54206 0)
(2.02118 0.00296815 4.51438e-17)
(8.79588 0.767683 0)
(-0.364354 6.90929 -1.2078e-16)
(-0.3864 8.69958 -3.30007e-18)
(5.05929 1.06064 2.69168e-16)
(-0.250125 7.75021 1.81736e-17)
(6.99612 0.131406 -9.31068e-17)
(1.08805 -0.438307 -4.3166e-17)
(4.94905 -0.521657 1.42033e-16)
(-0.334309 8.72221 0)
(0.316702 -0.0372604 -3.27107e-16)
(2.42654 0.442557 3.86056e-17)
(3.16679 -0.0221531 -1.78953e-16)
(-0.0193741 3.97148 1.06674e-16)
(1.9531 0.581083 3.45412e-16)
(0.911766 -0.292982 1.4631e-16)
(0.387446 3.80074 1.80387e-16)
(3.41524 -0.365786 -1.31875e-16)
(0.0742722 6.94524 -4.6922e-17)
(-0.31922 9.01095 -5.19624e-17)
(-0.409604 6.95999 9.21628e-17)
(8.49243 0.214185 -7.30215e-17)
(4.44011 -0.165627 2.82546e-16)
(2.07861 0.739733 -2.23771e-19)
(-0.878106 0.0336892 1.85222e-16)
(-0.106813 5.16729 0)
(0.922968 -0.19409 3.81604e-16)
(4.49821 0.664954 -1.88144e-19)
(-0.0619778 4.54377 3.03352e-16)
(1.73469 -0.0444876 0)
(-0.312742 3.96239 0)
(-0.0998268 6.50077 -9.64515e-20)
(9.52458 1.49598 -7.44056e-18)
(-0.120019 1.55367 1.41415e-16)
(3.3645 0.0379363 -2.7566e-16)
(-0.384791 -0.282995 0)
(7.24677 0.0752895 -3.07251e-17)
(1.17329 0.523187 -3.35753e-16)
(0.268823 0.585982 -7.79721e-18)
(-0.0812917 -0.640388 0)
(0.413128 0.549706 -1.28538e-16)
(-0.209863 6.11473 -1.19694e-16)
(-2.11978 -0.25465 1.59162e-16)
(1.98285 8.95487 -1.59927e-16)
(0.593776 -0.231318 1.26489e-17)
(-0.253652 -0.822239 -9.93006e-17)
(0.196431 5.61722 6.88848e-18)
(-0.0753306 3.13899 1.47479e-16)
(-0.170221 -0.0507148 -4.80151e-16)
(2.14847 -0.0503645 -6.65973e-17)
(0.895866 5.48044 5.36656e-17)
(-0.120316 6.59825 5.29557e-17)
(0.459039 6.65563 -5.59167e-17)
(1.62045 -0.27816 0)
(-0.261898 1.12733 -1.07945e-16)
(3.06081 -0.285456 1.11623e-16)
(8.98506 0.441934 0)
(-0.0623577 5.93554 -8.89718e-17)
(-0.449049 3.06752 0)
(-0.150936 3.13554 4.3366e-17)
(0.866551 -1.13571 8.72974e-17)
(0.0337676 -1.20156 2.4965e-16)
(0.495301 -0.0393739 2.56902e-16)
(-1.18348 -0.038671 -5.34287e-17)
(-0.438779 -0.749191 -5.08145e-17)
(1.38633 -0.107182 0)
(0.809203 -0.0506444 -3.15503e-16)
(-0.0546497 3.4247 -7.69213e-20)
(9.07269 1.51596 3.3365e-18)
(-0.667453 0.00275659 -4.65721e-16)
(3.22531 -0.817352 -7.27926e-18)
(0.820564 0.0500765 0)
(3.74015 0.217726 0)
(-0.096734 5.09486 -1.35459e-16)
(2.71562 0.146898 0)
(-0.298275 -0.316231 1.37103e-16)
(4.63809 0.0697671 1.80789e-17)
(0.13365 -0.603865 2.80335e-16)
(8.55783 0.427528 0)
(-1.09288 -0.760321 -4.50019e-16)
(-0.0853731 0.576937 0)
(-0.199607 -0.276314 3.40508e-17)
(1.59452 1.37262 1.13576e-16)
(-0.747811 -0.0091393 0)
(-0.064805 4.22974 -8.90244e-17)
(0.286201 0.762415 5.76741e-17)
(0.00981993 -0.658452 -6.8265e-17)
(-1.69799 0.534025 2.43925e-16)
(-1.38996 0.0154869 1.73529e-18)
(0.565811 6.04047 -6.62846e-17)
(0.647615 0.725824 0)
(-0.402906 -0.0419451 -3.12209e-17)
(0.0552557 2.12856 2.63461e-16)
(-0.450522 -0.0483734 0)
(3.27803 -0.744823 3.64285e-17)
(3.5503 -0.0850669 -1.30417e-16)
(-1.49231 9.27438 -9.82897e-17)
(1.70764 0.498436 2.26344e-16)
(0.697149 0.276051 0)
(2.00266 0.337725 -2.17553e-17)
(0.0769306 0.126694 -2.24592e-17)
(3.06629 -0.0534422 0)
(0.015504 -0.0581123 1.43902e-16)
(0.335067 0.188934 -1.69059e-16)
(-0.272224 9.02038 -7.09186e-17)
(-1.77834 0.421072 -4.4668e-16)
(4.27047 1.55944 -8.34353e-17)
(4.55559 0.332932 -9.89597e-17)
(3.97973 0.628482 5.34773e-16)
(2.33994 0.40217 3.78501e-18)
(1.21568 0.392293 -1.10156e-16)
(-0.250499 7.7422 4.0069e-17)
(4.31518 0.00134769 1.38753e-16)
(-0.603246 9.92951 1.05444e-17)
(-0.111478 -0.482437 -2.25554e-17)
(5.2505 1.77895 0)
(0.209289 6.00626 4.7919e-17)
(2.89751 0.00417203 4.36907e-18)
(-0.272817 -0.506835 -1.716e-16)
(-0.101488 -0.360488 -2.43895e-16)
(-0.662435 0.00334042 -3.40342e-17)
(-0.236215 0.0866851 3.08386e-16)
(-0.0118788 3.73146 0)
(3.80583 0.148111 1.34653e-16)
(2.87925 0.7025 -9.06925e-16)
(0.375875 8.20634 1.07157e-17)
(0.601326 0.865047 0)
(4.41903 -0.0774699 -4.06402e-17)
(1.36188 -0.705827 -2.71288e-17)
(3.23395 1.20423 3.3573e-18)
(5.51191 -0.357501 -1.36335e-16)
(5.91545 -0.255619 -5.30403e-20)
(0.784738 0.0979441 -1.15151e-16)
(2.05827 0.487495 -3.12448e-16)
(-0.484091 -0.139245 0)
(-0.674262 0.0592639 0)
(0.0155682 1.6968 0)
(-0.0332632 7.76413 0)
(-1.91745 0.489454 -1.55719e-16)
(1.36344 3.90236 -1.28319e-16)
(0.322224 -0.291406 1.90002e-16)
(-0.166568 7.6289 0)
(1.26402 4.85988 1.73515e-16)
(-0.111827 7.45787 -6.34396e-17)
(0.0148912 7.71077 -1.53002e-17)
(-0.0120755 7.79653 -3.28535e-17)
(4.62429 -0.0358708 -8.46968e-17)
(0.519868 6.34451 -9.94585e-18)
(0.550328 -0.223755 -2.69976e-16)
(-0.390429 -1.06927 4.95114e-16)
(-0.498234 -0.0228934 -2.02142e-16)
(0.889342 -0.612828 0)
(-1.77226 -0.156252 -1.00316e-19)
(-0.535657 0.00792011 -6.25868e-16)
(4.05773 -1.11251 -2.28606e-16)
(3.84658 0.158572 3.88693e-16)
(-0.20812 6.1833 6.96576e-17)
(-0.100707 7.10173 0)
(2.34323 3.96362 0)
(-0.164737 7.35982 -7.3784e-17)
(0.022962 7.10625 1.77762e-17)
(-0.438759 -0.044911 7.87382e-17)
(-0.321833 7.83216 1.76113e-18)
(-0.409859 -0.250816 -6.78744e-17)
(1.2374 -0.193758 -3.81568e-16)
(-3.10957 0.38086 0)
(0.605508 5.65226 -2.46472e-16)
(3.23 -0.300011 -6.2665e-20)
(2.15928 0.0195588 -2.15528e-16)
(2.47848 0.0525772 -4.79432e-17)
(3.0007 0.351828 0)
(3.86336 -0.132772 -3.2743e-16)
(1.17615 5.30491 -7.01785e-18)
(2.71062 -0.115432 -3.9868e-17)
(4.12701 0.0333495 -8.694e-17)
(-0.45532 -0.0277681 -6.50917e-17)
(8.0004 0.193597 -8.0494e-17)
(4.1175 1.26204 0)
(0.294478 6.26233 -6.154e-17)
(3.9552 -0.743403 -1.30265e-16)
(-0.107765 -0.0138129 -1.73749e-17)
(4.19414 0.67506 4.70777e-16)
(4.36336 -0.245419 9.44702e-17)
(4.24274 -0.0976718 -2.88449e-16)
(-2.42691 -0.184628 -9.61576e-17)
(7.08123 -0.0148272 1.5088e-16)
(-0.637088 -0.298336 9.86276e-16)
(3.21451 -0.1559 4.00203e-16)
(3.81536 -0.390581 -2.57641e-16)
(0.499394 -0.105047 -9.95621e-16)
(1.1834 -0.288126 -5.04859e-16)
(-0.306907 0.706894 -2.31377e-16)
(0.106212 -0.251627 -1.0158e-15)
(-0.454603 0.903795 -1.62685e-16)
(0.853381 1.76663 -6.30755e-18)
(-0.0910719 0.108901 0)
(0.23241 0.48629 0)
(4.72163 0.164271 1.14849e-16)
(-0.41532 2.25635 9.98734e-17)
(0.782475 2.39826 -9.17584e-16)
(0.108502 -0.346876 1.18694e-15)
(5.22574 0.445973 -5.23716e-17)
(4.63579 -0.115144 0)
(5.24535 0.0153104 9.36024e-17)
(6.25101 0.0287412 3.34927e-16)
(7.31592 0.0355591 -1.54108e-17)
(-1.90524 -0.0455834 1.54149e-16)
(3.06432 -0.0253668 2.18483e-17)
(-1.24991 -0.220516 1.29344e-18)
(3.86325 0.417809 0)
(-1.36525 -0.100897 1.12439e-16)
(-1.1848 0.0995043 0)
(5.04111 0.344815 -1.11763e-17)
(-2.2558 0.0642186 -2.87045e-18)
(4.93369 -0.217008 2.3423e-16)
(3.92033 0.0491654 -3.93052e-16)
(4.39755 -0.0447937 0)
)
;
boundaryField
{
frontAndBack
{
type empty;
}
wallOuter
{
type noSlip;
}
inlet
{
type fixedValue;
value nonuniform 0();
}
outlet
{
type zeroGradient;
}
wallInner
{
type noSlip;
}
procBoundary1to0
{
type processor;
value nonuniform List<vector>
29
(
(-0.875898 0.28729 -2.15487e-16)
(-0.875898 0.28729 -2.15487e-16)
(-1.30668 0.180903 0)
(-0.295023 0.318382 1.99014e-16)
(-0.327277 0.654891 -1.15262e-16)
(-2.22265 0.448648 -1.17539e-16)
(4.22391 -0.153217 2.49795e-16)
(3.18933 -0.0950101 0)
(6.31104 0.373706 0)
(0.892311 0.23193 -1.79434e-16)
(2.68354 0.0486214 -2.65872e-16)
(-2.22265 0.448648 -1.17539e-16)
(-1.30668 0.180903 0)
(-1.29095 0.194271 0)
(6.95589 0.0235538 9.61046e-17)
(8.63442 0.157749 0)
(-0.327277 0.654891 -1.15262e-16)
(0.865626 0.69533 0)
(-0.295023 0.318382 1.99014e-16)
(-0.202403 0.353315 -1.014e-18)
(8.76607 0.142174 -3.17057e-17)
(8.07686 0.0919752 -1.52254e-17)
(5.18649 0.246526 -1.33246e-16)
(6.9197 0.075425 1.81364e-16)
(6.9197 0.075425 1.81364e-16)
(5.18649 0.246526 -1.33246e-16)
(8.80303 0.0402087 -6.4746e-17)
(1.75234 0.0213756 0)
(8.80303 0.0402087 -6.4746e-17)
)
;
}
procBoundary1to2
{
type processor;
value uniform (0.958924 0.0931922 -2.05593e-16);
}
procBoundary1to3
{
type processor;
value nonuniform List<vector>
48
(
(-0.286329 5.59904 0)
(-0.225467 8.32674 -9.53114e-20)
(-0.388852 7.67706 1.08638e-16)
(-0.388852 7.67706 1.08638e-16)
(-0.0840878 5.40157 -6.71827e-17)
(-0.104823 6.24776 4.17757e-16)
(-0.104823 6.24776 4.17757e-16)
(0.369225 0.421342 0)
(-0.18292 3.50029 0)
(-0.195575 -1.24996 0)
(-0.440087 -0.0223544 -3.06146e-16)
(-0.195575 -1.24996 0)
(-0.109332 -1.63389 3.12888e-16)
(0.999571 -0.418754 2.84648e-16)
(0.731408 -0.23759 -1.82921e-16)
(-0.109332 -1.63389 3.12888e-16)
(-0.236936 -1.61227 -1.45799e-18)
(-0.236936 -1.61227 -1.45799e-18)
(-0.20197 -0.937913 0)
(-0.20197 -0.937913 0)
(0.992421 -1.07998 2.11422e-17)
(0.8509 -0.967969 1.66552e-16)
(-0.345962 -0.262986 -1.9591e-16)
(-0.323119 1.52396 8.07467e-16)
(-0.323119 1.52396 8.07467e-16)
(-0.0861177 0.588082 0)
(0.589628 -0.75242 0)
(0.589628 -0.75242 0)
(0.490356 -0.212322 4.0445e-16)
(-0.0781841 2.75074 -2.45192e-16)
(-0.374841 1.13098 -1.37443e-16)
(0.490356 -0.212322 4.0445e-16)
(0.369225 0.421342 0)
(-0.0263842 2.46302 -3.99112e-16)
(0.107352 0.154752 -1.9436e-16)
(-0.0781841 2.75074 -2.45192e-16)
(0.189454 1.20389 -2.62494e-16)
(-0.440087 -0.0223544 -3.06146e-16)
(-0.271014 4.48198 0)
(-0.160998 7.07531 1.40631e-17)
(0.760063 -0.785859 4.18349e-16)
(0.0809952 1.81078 1.91127e-16)
(-0.0263842 2.46302 -3.99112e-16)
(0.107352 0.154752 -1.9436e-16)
(0.926628 -0.0692267 7.56332e-17)
(-0.0669421 5.64024 5.67234e-21)
(-0.130144 6.62725 0)
(0.760063 -0.785859 4.18349e-16)
)
;
}
}
// ************************************************************************* //
| [
"[email protected]"
] | ||
fba637321558750263c7069a3ab47d375bc72b25 | 4cb3450b11e46b36a62f53f30a76b7b21deb61da | /CSCI_476/Lab8/ParallelGameOfLife.cc | 2c3320671165c1e54beadb5c87a6a2212de996c1 | [] | no_license | zrzuch/Various-Projects | b1ba001be04b33196e819faaa5fff025ffab9b72 | 8cdc8d43ac0a15950ccb013fa6bbf048bb0b2b9f | refs/heads/master | 2020-06-23T18:27:10.509606 | 2019-07-24T22:52:59 | 2019-07-24T22:52:59 | 198,714,668 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,483 | cc | /*
FileName : ParallelGameOfLife.cc
Author : Zachary Zuch
Course : CSCI 476
Assignment : Lab 8
Description : Parallel Game of Life Simulation
*/
/************************************************************/
// System includes
#include <cstdlib>
#include <iostream>
#include <random>
#include <vector>
#include <algorithm>
#include <thread>
#include <string>
#include <boost/thread/barrier.hpp>
/************************************************************/
// Local includes
#include "Timer.hpp"
/************************************************************/
// Using declarations
using std::cout;
using std::cin;
using std::endl;
using std::vector;
using std::string;
using std::minstd_rand;
using boost::dynamic_bitset;
/************************************************************/
// Function prototypes/global vars/typedefs
/************************************************************/
int
main(int argc, char* argv[])
{
cout << "Input file ==> ";
string file;
cin >> file;
if ( file == "n" )
{
cout << endl << "N ==> ";
unsigned N;
cin >> N;
cout << "Seed ==> ";
unsigned seed;
cin >> p;
}
else
{
// Read from file and create bitset matrix
}
cout << "p ==> ";
unsigned p;
cin >> p;
cout << "Generations ==> ";
unsigned generations;
cin >> generations;
cout << endl;
}
void
generations_helper ( vector< vector<bool> >& life_matrix, unsigned begin_pos,
unsigned end_pos, unsigned generations, barrier& b )
{
unsigned n = life_matrix.size() - 2;
unsigned begin_i = ( begin_pos / n ) + 1;
unsigned begin_j = ( begin_pos % n ) + 1;
unsigned end_i = ( end_pos / n ) + 1;
unsigned end_j = ( end_pos % n ) + 1;
unsigned next_gen_pos = 0;
vector<bool> next_gen( end_pos - begin_pos );
for ( unsigned curr_gen = 0; curr_gen < generations; ++curr_gen )
{
for ( unsigned i = begin_i; i <= end_i; ++i )
{
unsigned end_value = ( i == end_i ? end_j : n );
for ( unsigned j = ( i == begin_i ? begin_j : 1 );
j <= end_value; ++j )
{
// Reads from curr life matrix
next_gen[ pos ] = check_if_alive( ... );
++pos;
}
}
b.wait(); // caller creates
// write buffer to curr life
next_gen_pos = 0;
for ( unsigned i = begin_i; i <= end_i; ++i )
{
unsigned end_value = ( i == end_i ? end_j : n );
for ( unsigned j = ( i == begin_i ? begin_j : 1 );
j <= end_value; ++j )
{
life_matrix[ i ][ j ] = next_gen[ pos ];
++pos;
}
}
}
} | [
"[email protected]"
] | |
be4d4be48cad37d2611e7a5c244ec6d1ee98064b | 7b4bac7cd798cfbf3a8c018c01a6ad60a1b34c25 | /src/backend/concurrency/optimistic_rb_txn_manager.cpp | 1bc104441f4b369be84c83be55d84d13247fed03 | [
"Apache-2.0"
] | permissive | larryxiao/peloton | 0698b3394aa16cc7befd896220831a87e8ea3995 | 9a02fcacae6f5c5c9a7966cddf1c9e275c9b67c9 | refs/heads/memcached | 2020-04-10T13:28:32.674686 | 2016-05-11T23:09:02 | 2016-05-11T23:09:02 | 51,320,148 | 4 | 1 | null | 2016-05-11T16:47:37 | 2016-02-08T19:14:33 | C++ | UTF-8 | C++ | false | false | 19,236 | cpp | //===----------------------------------------------------------------------===//
//
// PelotonDB
//
// optimistic_rb_txn_manager.cpp
//
// Identification: src/backend/concurrency/optimistic_rb_txn_manager.cpp
//
// Copyright (c) 2015-16, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "optimistic_rb_txn_manager.h"
#include "backend/common/platform.h"
#include "backend/logging/log_manager.h"
#include "backend/logging/records/transaction_record.h"
#include "backend/concurrency/transaction.h"
#include "backend/catalog/manager.h"
#include "backend/common/exception.h"
#include "backend/common/logger.h"
namespace peloton {
namespace concurrency {
thread_local storage::RollbackSegmentPool *current_segment_pool;
thread_local cid_t latest_read_timestamp = INVALID_CID;
OptimisticRbTxnManager &OptimisticRbTxnManager::GetInstance() {
static OptimisticRbTxnManager txn_manager;
return txn_manager;
}
// Visibility check
// check whether a tuple is visible to current transaction.
// in this protocol, we require that a transaction cannot see other
// transaction's local copy.
bool OptimisticRbTxnManager::IsVisible(
const storage::TileGroupHeader *const tile_group_header,
const oid_t &tuple_id) {
txn_id_t tuple_txn_id = tile_group_header->GetTransactionId(tuple_id);
cid_t tuple_begin_cid = tile_group_header->GetBeginCommitId(tuple_id);
cid_t tuple_end_cid = tile_group_header->GetEndCommitId(tuple_id);
if (tuple_txn_id == INVALID_TXN_ID) {
// the tuple is not available.
// This is caused by an comitted deletion
return false;
}
bool own = (current_txn->GetTransactionId() == tuple_txn_id);
// there are exactly two versions that can be owned by a transaction.
// unless it is an insertion.
if (own == true) {
if (GetDeleteFlag(tile_group_header, tuple_id) == true) {
// the tuple is deleted by current transaction
return false;
} else {
assert(tuple_end_cid == MAX_CID);
// the tuple is updated/inserted by current transaction
return true;
}
} else {
bool invalidated = (current_txn->GetBeginCommitId() >= tuple_end_cid);
if (invalidated)
return false;
if (tuple_txn_id != INITIAL_TXN_ID) {
// if the tuple is owned by other transactions.
if (tuple_begin_cid == MAX_CID) {
// The tuple is inserted
return false;
}
}
if (GetActivatedEvidence(tile_group_header, tuple_id) != nullptr) {
return true;
} else {
return false;
}
}
}
// check whether the current transaction owns the tuple.
// this function is called by update/delete executors.
bool OptimisticRbTxnManager::IsOwner(
const storage::TileGroupHeader *const tile_group_header,
const oid_t &tuple_id) {
auto tuple_txn_id = tile_group_header->GetTransactionId(tuple_id);
return tuple_txn_id == current_txn->GetTransactionId();
}
// if the tuple is not owned by any transaction and is visible to current
// transaction.
// this function is called by update/delete executors.
bool OptimisticRbTxnManager::IsOwnable(
const storage::TileGroupHeader *const tile_group_header,
const oid_t &tuple_id) {
auto tuple_txn_id = tile_group_header->GetTransactionId(tuple_id);
char *evidence = GetActivatedEvidence(tile_group_header, tuple_id);
return tuple_txn_id == INITIAL_TXN_ID &&
evidence == tile_group_header->GetReservedFieldRef(tuple_id);
}
// get write lock on a tuple.
// this is invoked by update/delete executors.
bool OptimisticRbTxnManager::AcquireOwnership(
const storage::TileGroupHeader *const tile_group_header,
const oid_t &tile_group_id __attribute__((unused)), const oid_t &tuple_id) {
auto txn_id = current_txn->GetTransactionId();
if (tile_group_header->SetAtomicTransactionId(tuple_id, txn_id) == false) {
LOG_ERROR("Fail to acquire tuple. Set txn failure.");
SetTransactionResult(Result::RESULT_FAILURE);
return false;
}
return true;
}
bool OptimisticRbTxnManager::PerformRead(const ItemPointer &location) {
current_txn->RecordRead(location);
return true;
}
bool OptimisticRbTxnManager::PerformInsert(const ItemPointer &location) {
oid_t tile_group_id = location.block;
oid_t tuple_id = location.offset;
auto &manager = catalog::Manager::GetInstance();
auto tile_group_header = manager.GetTileGroup(tile_group_id)->GetHeader();
auto transaction_id = current_txn->GetTransactionId();
// Set MVCC info
assert(tile_group_header->GetTransactionId(tuple_id) == INVALID_TXN_ID);
assert(tile_group_header->GetBeginCommitId(tuple_id) == MAX_CID);
assert(tile_group_header->GetEndCommitId(tuple_id) == MAX_CID);
tile_group_header->SetTransactionId(tuple_id, transaction_id);
// no need to set next item pointer.
// init the reserved field
InitTupleReserved(tile_group_header, tuple_id);
// Add the new tuple into the insert set
current_txn->RecordInsert(location);
return true;
}
void OptimisticRbTxnManager::PerformUpdateWithRb(const ItemPointer &location, char *new_rb_seg) {
oid_t tile_group_id = location.block;
oid_t tuple_id = location.offset;
auto tile_group_header =
catalog::Manager::GetInstance().GetTileGroup(tile_group_id)->GetHeader();
assert(tile_group_header->GetTransactionId(tuple_id) == current_txn->GetTransactionId());
assert(tile_group_header->GetEndCommitId(tuple_id) == MAX_CID);
// new_rb_seg is a new segment
assert(storage::RollbackSegmentPool::GetNextPtr(new_rb_seg) == nullptr);
assert(storage::RollbackSegmentPool::GetTimeStamp(new_rb_seg) == MAX_CID);
// First link it to the old roolback segment
auto old_rb_seg = GetRbSeg(tile_group_header, tuple_id);
storage::RollbackSegmentPool::SetNextPtr(new_rb_seg, old_rb_seg);
COMPILER_MEMORY_FENCE;
// Modify the head of the segment list
// Note that since we are holding the write lock, we don't need atomic update here
SetRbSeg(tile_group_header, tuple_id, new_rb_seg);
// Add the location to the update set
current_txn->RecordUpdate(location);
}
void OptimisticRbTxnManager::PerformDelete(const ItemPointer &location) {
oid_t tile_group_id = location.block;
oid_t tuple_id = location.offset;
auto &manager = catalog::Manager::GetInstance();
auto tile_group_header = manager.GetTileGroup(tile_group_id)->GetHeader();
assert(tile_group_header->GetTransactionId(tuple_id) ==
current_txn->GetTransactionId());
// tuple deleted should be globally visible
assert(tile_group_header->GetEndCommitId(tuple_id) == MAX_CID);
// Set the delete flag
SetDeleteFlag(tile_group_header, tuple_id);
// Add the old tuple into the delete set
bool ins_del = current_txn->RecordDelete(location);
// Check if we have INS_DEL, if so, just delete and reclaim the tuple
if (ins_del) {
// Mark as invalid
tile_group_header->SetTransactionId(tuple_id, INVALID_TXN_ID);
// recycle the inserted tuple
// FIXME: need to delete them in index and free the tuple --jiexi
// RecycleTupleSlot(tile_group_id, tuple_slot, START_OID);
}
}
void OptimisticRbTxnManager::RollbackTuple(std::shared_ptr<storage::TileGroup> tile_group, const oid_t tuple_id) {
auto tile_group_header = tile_group->GetHeader();
auto txn_begin_cid = current_txn->GetBeginCommitId();
auto rb_seg = GetRbSeg(tile_group_header, tuple_id);
// Follow the RB chain, rollback if needed, stop when first unreadable RB
while (IsRBVisible(rb_seg, txn_begin_cid) == true) {
// Copy the content of the rollback segment onto the tuple
tile_group->ApplyRollbackSegment(rb_seg, tuple_id);
// Move to next rollback segment
rb_seg = storage::RollbackSegmentPool::GetNextPtr(rb_seg);
}
COMPILER_MEMORY_FENCE;
// Set the tile group header's rollback segment header to next rollback segment
SetRbSeg(tile_group_header, tuple_id, rb_seg);
}
void OptimisticRbTxnManager::InstallRollbackSegments(storage::TileGroupHeader *tile_group_header,
const oid_t tuple_id, const cid_t end_cid) {
auto txn_begin_cid = current_txn->GetBeginCommitId();
auto rb_seg = GetRbSeg(tile_group_header, tuple_id);
while (IsRBVisible(rb_seg, txn_begin_cid)) {
storage::RollbackSegmentPool::SetTimeStamp(rb_seg, end_cid);
rb_seg = storage::RollbackSegmentPool::GetNextPtr(rb_seg);
}
}
/**
* @brief Check if begin commit id and end commit id still falls in the same version
* as when then transaction starts
*/
bool OptimisticRbTxnManager::ValidateRead(const storage::TileGroupHeader *const tile_group_header, const oid_t &tuple_id, const cid_t &end_cid) {
auto tuple_end_cid = tile_group_header->GetEndCommitId(tuple_id);
if (IsOwner(tile_group_header, tuple_id) == true) {
// Read tuple is owned by current txn
return true;
}
// The following is essentially to test that begin_cid and end_cid will look at the same
// version
if (end_cid >= tuple_end_cid) {
// Read tuple is invalidated by others
return false;
}
auto evidence = GetActivatedEvidence(tile_group_header, tuple_id);
if (evidence == tile_group_header->GetReservedFieldRef(tuple_id)) {
// begin cid is activated on the master version
// we already know that the end cid is less than the master version's end cid
// since master end cid > end cid > begin cid >= master version's begin cid, we are ok
return true;
}
// Now the evidence is a rollback segment
// If the read is valid, the end cid should also be activated by that rollback segment
return end_cid >= storage::RollbackSegmentPool::GetTimeStamp(evidence);
}
Result OptimisticRbTxnManager::CommitTransaction() {
LOG_INFO("Committing peloton txn : %lu ", current_txn->GetTransactionId());
auto &manager = catalog::Manager::GetInstance();
auto &rw_set = current_txn->GetRWSet();
//*****************************************************
// we can optimize read-only transaction.
if (current_txn->IsReadOnly() == true) {
// validate read set.
for (auto &tile_group_entry : rw_set) {
oid_t tile_group_id = tile_group_entry.first;
auto tile_group = manager.GetTileGroup(tile_group_id);
auto tile_group_header = tile_group->GetHeader();
for (auto &tuple_entry : tile_group_entry.second) {
auto tuple_slot = tuple_entry.first;
// if this tuple is not newly inserted.
if (tuple_entry.second == RW_TYPE_READ) {
// No one should be writting, I can still read it and the begin commit
// id still fall before the end commit id of the tuple
//
// To give an example why tile_group_header->GetEndCommitId(tuple_slot) >=
// current_txn->GetBeginCommitId() is needed
//
// T0 begin at 1, delete a tuple, then get end commit 2, but not commit yet
// T1 begin at 3, read the same tuple, it should read the master version
// T0 now commit, master version has been changed to be visible for (0, 2)
// Now the master version is no longer visible for T0.
if (tile_group_header->GetTransactionId(tuple_slot) == INITIAL_TXN_ID &&
GetActivatedEvidence(tile_group_header, tuple_slot) != nullptr &&
tile_group_header->GetEndCommitId(tuple_slot) >=
current_txn->GetBeginCommitId()) {
// the version is not owned by other txns and is still visible.
continue;
}
LOG_INFO("Abort in read only txn");
// otherwise, validation fails. abort transaction.
return AbortTransaction();
} else {
// It must be a deleted
assert(tuple_entry.second == RW_TYPE_INS_DEL);
assert(tile_group_header->GetTransactionId(tuple_slot) == INVALID_TXN_ID);
}
}
}
EndTransaction();
return Result::RESULT_SUCCESS;
}
//*****************************************************
// generate transaction id.
cid_t end_commit_id = GetNextCommitId();
// validate read set.
for (auto &tile_group_entry : rw_set) {
oid_t tile_group_id = tile_group_entry.first;
auto tile_group = manager.GetTileGroup(tile_group_id);
auto tile_group_header = tile_group->GetHeader();
for (auto &tuple_entry : tile_group_entry.second) {
auto tuple_slot = tuple_entry.first;
// if this tuple is not newly inserted. Meaning this is either read,
// update or deleted.
if (tuple_entry.second != RW_TYPE_INSERT &&
tuple_entry.second != RW_TYPE_INS_DEL) {
if (ValidateRead(tile_group_header, tuple_slot, end_commit_id)) {
continue;
}
LOG_INFO("transaction id=%lu",
tile_group_header->GetTransactionId(tuple_slot));
LOG_INFO("begin commit id=%lu",
tile_group_header->GetBeginCommitId(tuple_slot));
LOG_INFO("end commit id=%lu",
tile_group_header->GetEndCommitId(tuple_slot));
// otherwise, validation fails. abort transaction.
return AbortTransaction();
}
}
}
//////////////////////////////////////////////////////////
// auto &log_manager = logging::LogManager::GetInstance();
// log_manager.LogBeginTransaction(end_commit_id);
// install everything.
for (auto &tile_group_entry : rw_set) {
oid_t tile_group_id = tile_group_entry.first;
auto tile_group = manager.GetTileGroup(tile_group_id);
auto tile_group_header = tile_group->GetHeader();
for (auto &tuple_entry : tile_group_entry.second) {
auto tuple_slot = tuple_entry.first;
if (tuple_entry.second == RW_TYPE_UPDATE) {
// // logging.
// ItemPointer new_version =
// tile_group_header->GetNextItemPointer(tuple_slot);
// ItemPointer old_version(tile_group_id, tuple_slot);
//
// // logging.
// log_manager.LogUpdate(current_txn, end_commit_id, old_version,
// new_version);
// First set the timestamp of the updated master copy
// Since we have the rollback segment, it's safe to do so
assert(tile_group_header->GetEndCommitId(tuple_slot) == MAX_CID);
tile_group_header->SetBeginCommitId(tuple_slot, end_commit_id);
// Then we mark all rollback segment's timestamp as our end timestamp
InstallRollbackSegments(tile_group_header, tuple_slot, end_commit_id);
COMPILER_MEMORY_FENCE;
// Finally we release the write lock on the original tuple
tile_group_header->SetTransactionId(tuple_slot, INITIAL_TXN_ID);
} else if (tuple_entry.second == RW_TYPE_DELETE) {
// ItemPointer new_version =
// tile_group_header->GetNextItemPointer(tuple_slot);
// ItemPointer delete_location(tile_group_id, tuple_slot);
//
// // logging.
// log_manager.LogDelete(end_commit_id, delete_location);
// we do not change begin cid for master copy
// First set the timestamp of the master copy
assert(tile_group_header->GetEndCommitId(tuple_slot) == MAX_CID);
tile_group_header->SetEndCommitId(tuple_slot, end_commit_id);
// COMPILER_MEMORY_FENCE;
// we may have updated this tuple before we delete it, roll it back
RollbackTuple(tile_group, tuple_slot);
// Reset the deleted bit for safety
ClearDeleteFlag(tile_group_header, tuple_slot);
COMPILER_MEMORY_FENCE;
// Finally we release the write lock
tile_group_header->SetTransactionId(tuple_slot, INITIAL_TXN_ID);
// recycle the newer version.
// FIXME: need to delete them in index and free the tuple --jiexi
// RecycleTupleSlot(tile_group_id, tuple_slot, START_OID);
} else if (tuple_entry.second == RW_TYPE_INSERT) {
assert(tile_group_header->GetTransactionId(tuple_slot) ==
current_txn->GetTransactionId());
// set the begin commit id to persist insert
// ItemPointer insert_location(tile_group_id, tuple_slot);
// log_manager.LogInsert(current_txn, end_commit_id, insert_location);
tile_group_header->SetEndCommitId(tuple_slot, MAX_CID);
tile_group_header->SetBeginCommitId(tuple_slot, end_commit_id);
COMPILER_MEMORY_FENCE;
tile_group_header->SetTransactionId(tuple_slot, INITIAL_TXN_ID);
} else if (tuple_entry.second == RW_TYPE_INS_DEL) {
assert(tile_group_header->GetTransactionId(tuple_slot) == INVALID_TXN_ID);
// Do nothing for INS_DEL
}
}
}
// log_manager.LogCommitTransaction(end_commit_id);
current_txn->SetEndCommitId(end_commit_id);
EndTransaction();
return Result::RESULT_SUCCESS;
}
Result OptimisticRbTxnManager::AbortTransaction() {
LOG_INFO("Aborting peloton txn : %lu ", current_txn->GetTransactionId());
auto &manager = catalog::Manager::GetInstance();
auto &rw_set = current_txn->GetRWSet();
for (auto &tile_group_entry : rw_set) {
oid_t tile_group_id = tile_group_entry.first;
auto tile_group = manager.GetTileGroup(tile_group_id);
auto tile_group_header = tile_group->GetHeader();
for (auto &tuple_entry : tile_group_entry.second) {
auto tuple_slot = tuple_entry.first;
if (tuple_entry.second == RW_TYPE_UPDATE) {
// We do not have new version now, no need to mantain it
assert(tile_group_header->GetNextItemPointer(tuple_slot).IsNull());
// The master copy under updating must be a valid version
assert(tile_group_header->GetEndCommitId(tuple_slot) == MAX_CID);
// Rollback the master copy
RollbackTuple(tile_group, tuple_slot);
COMPILER_MEMORY_FENCE;
tile_group_header->SetTransactionId(tuple_slot, INITIAL_TXN_ID);
} else if (tuple_entry.second == RW_TYPE_DELETE) {
// We do not have new version now, no need to mantain it
assert(tile_group_header->GetNextItemPointer(tuple_slot).IsNull());
tile_group_header->SetEndCommitId(tuple_slot, MAX_CID);
// We may have updated this tuple in the same txn, rollback it
RollbackTuple(tile_group, tuple_slot);
// Reset the deleted bit before release the write lock
ClearDeleteFlag(tile_group_header, tuple_slot);
COMPILER_MEMORY_FENCE;
tile_group_header->SetTransactionId(tuple_slot, INITIAL_TXN_ID);
} else if (tuple_entry.second == RW_TYPE_INSERT) {
tile_group_header->SetEndCommitId(tuple_slot, MAX_CID);
tile_group_header->SetBeginCommitId(tuple_slot, MAX_CID);
tile_group_header->SetTransactionId(tuple_slot, INVALID_TXN_ID);
// recycle the newer version.
// FIXME: need to delete them in index and free the tuple --jiexi
// RecycleTupleSlot(tile_group_id, tuple_slot, START_OID);
} else if (tuple_entry.second == RW_TYPE_INS_DEL) {
assert(tile_group_header->GetTransactionId(tuple_slot) == INVALID_TXN_ID);
// Do nothing for INS_DEL
// GC this tuple
}
}
}
current_txn->SetResult(RESULT_ABORTED);
EndTransaction();
return Result::RESULT_ABORTED;
}
} // End storage namespace
} // End peloton namespace
| [
"[email protected]"
] | |
b6699c7479a824eb384a852a1e3436bd3ec53b9c | a3bfa4100f288efd114853351ca2da972048b9c1 | /app/libs/gstreamermm-android-universal-1.10.0/armv7/include/gstreamermm-1.0/gstreamermm/private/vorbistag_p.h | a77b6b0d804355632bed40536574bf676e4b965f | [] | no_license | OleksiiShevchenk0/gstreamerMMDemonstrator | f9dd50f49e8a9b0b52bd22f1a10d37d6267adf17 | 2d6674ed6247a7a3fcc3b7dfaadde7db628ca450 | refs/heads/main | 2023-08-16T02:14:46.425497 | 2021-10-26T12:46:17 | 2021-10-26T12:46:17 | 419,675,770 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,182 | h | // Generated by gmmproc 2.50.1 -- DO NOT MODIFY!
#ifndef _GSTREAMERMM_VORBISTAG_P_H
#define _GSTREAMERMM_VORBISTAG_P_H
#ifndef GSTREAMERMM_DISABLE_DEPRECATED
#include <glibmm/class.h>
namespace Gst
{
class VorbisTag_Class : public Glib::Class
{
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
using CppObjectType = VorbisTag;
using BaseObjectType = GstVorbisTag;
using BaseClassType = GstVorbisTagClass;
using CppClassParent = Gst::VorbisParse_Class;
using BaseClassParent = GstVorbisParseClass;
friend class VorbisTag;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
const Glib::Class& init();
static void class_init_function(void* g_class, void* class_data);
static Glib::ObjectBase* wrap_new(GObject*);
protected:
//Callbacks (default signal handlers):
//These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
//You could prevent the original default signal handlers being called by overriding the *_impl method.
//Callbacks (virtual functions):
};
} // namespace Gst
#include <gstreamermm/private/vorbisparse_p.h>
#endif // GSTREAMERMM_DISABLE_DEPRECATED
#endif /* _GSTREAMERMM_VORBISTAG_P_H */
| [
"[email protected]"
] | |
38ddc7ebb225c91a5ad3cb72c5bb698175d331cf | 6912177d1b73edc67059386b83e61e1db6e404e4 | /higan-094/phoenix/gtk/settings.cpp | aa9f2b17f3baf74cfe2bf290f7e4b0baef861c43 | [] | no_license | jjwatt/higan-debian | 2dc2fcbf31ace413e236f32186c5f25c4b3e2f6a | 4a5801ef7d675cdd911d1fc2e3c206aa4b2877ac | refs/heads/master | 2020-03-29T18:18:56.272662 | 2014-10-19T18:02:03 | 2014-10-19T18:02:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 839 | cpp | namespace phoenix {
static Settings* settings = nullptr;
void Settings::load() {
string path = {configpath(), "phoenix/"};
Configuration::Document::load({path, "gtk.bml"});
}
void Settings::save() {
string path = {configpath(), "phoenix/"};
directory::create(path, 0755);
Configuration::Document::save({path, "gtk.bml"});
}
Settings::Settings() {
geometry.append(geometry.frameX = 4, "FrameX");
geometry.append(geometry.frameY = 24, "FrameY");
geometry.append(geometry.frameWidth = 8, "FrameWidth");
geometry.append(geometry.frameHeight = 28, "FrameHeight");
geometry.append(geometry.menuHeight = 20, "MenuHeight");
geometry.append(geometry.statusHeight = 20, "StatusHeight");
append(geometry, "Geometry");
window.append(window.backgroundColor = 0xedeceb, "BackgroundColor");
append(window, "Window");
}
}
| [
"[email protected]"
] | |
c48775fca151307d153b0ca2b994556a48f53b9e | a39dcac8f4fbb66c24596ff8fe6a46fa1e2502c8 | /main.cc | acf146079f2a7fe2be17b59bf87179d4546f290e | [] | no_license | mujtaba65/HotelReservation | 7f7f2afa1130ba9b4bc25da0123e5b95433e46de | f967d0cde9b2ae4d067a62613879425547ccd5d8 | refs/heads/main | 2023-04-29T09:38:16.736497 | 2021-05-17T07:23:53 | 2021-05-17T07:23:53 | 368,093,122 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 880 | cc | #include <iostream>
using namespace std;
#include <string>
#include "Date.h"
#include "Guest.h"
#include "Room.h"
#include "Hotel.h"
#include "ResManager.h"
#include "RoomArray.h"
#include "Reservation.h"
#include "Recorder.h"
#include "StayRecorder.h"
#include "GuestRecorder.h"
#include "UpgradeRecorder.h"
#include "Control.h"
#include "View.h"
/*
The purpose of this program is to represent a hotel with a reservation manager, now the hotel has a bunch of rooms with specific details, such as room number and room type. Not only that it has premium guests and regular guests, The premium guests have loyalty points. The rooms are stored in room array collection class. There are recorders as well, the base class being abstract and 3 derived classes, which are inherited, and they implement the upgrade function.
*/
int main()
{
Control x;
x.launch();
return 0;
}
| [
"[email protected]"
] | |
38ac8fd12216d82965e88c640046df6a30331cd4 | bbe85a28579b4ae24adc89fc49656519ba2cbe2e | /src/reset-wfc-timer.cpp | 2f7176ed8eba152bccf229807763b4db6dd86f73 | [] | no_license | madrugado/car-driver | 86717a7423994d0354bbc6af216fbc45eca215b3 | ed26d28c88b25008f84a0d02b2204fd4a2496d0a | refs/heads/master | 2021-01-23T22:43:26.509562 | 2013-11-26T13:36:39 | 2013-11-26T13:36:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 332 | cpp | #include <cstdio>
#include <cstdlib>
#include "serial-port.h"
#include "car-driver.h"
#define PORT_NAME "/dev/ttyUSB0"
int main(int argc, char** argv)
{
int fd = serialPort::open_port(PORT_NAME);
if (fd == -1)
return 1;
serialPort::configure_port(fd);
resetWTCTimer(fd);
serialPort::close_port(fd);
return 0;
}
| [
"[email protected]"
] | |
a8137a49759e3f2cae1a8110773640e5fc6ccb9f | 600df3590cce1fe49b9a96e9ca5b5242884a2a70 | /android_webview/common/aw_message_port_messages.h | 6b98023a45b0ef43be55c11a0c2471e97d608b07 | [
"BSD-3-Clause"
] | permissive | metux/chromium-suckless | efd087ba4f4070a6caac5bfbfb0f7a4e2f3c438a | 72a05af97787001756bae2511b7985e61498c965 | refs/heads/orig | 2022-12-04T23:53:58.681218 | 2017-04-30T10:59:06 | 2017-04-30T23:35:58 | 89,884,931 | 5 | 3 | BSD-3-Clause | 2022-11-23T20:52:53 | 2017-05-01T00:09:08 | null | UTF-8 | C++ | false | false | 4,085 | h | // Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Multiply-included file, no traditional include guard.
#include <vector>
#include "ipc/ipc_message_macros.h"
#define IPC_MESSAGE_START AwMessagePortMsgStart
//-----------------------------------------------------------------------------
// MessagePort messages
// These are messages sent from the browser to the renderer process.
// Normally the postmessages are exchanged between the renderers and the message
// itself is opaque to the browser process. The format of the message is a
// WebSerializesScriptValue. A WebSerializedScriptValue is a blink structure
// and can only be serialized/deserialized in renderer. Further, we could not
// have Blink or V8 on the browser side due to their relience on static
// variables.
//
// For posting messages from Java (Webview) to JS, we pass the browser/renderer
// boundary an extra time and convert the messages to a type that browser can
// use. Since WebView is single-process this is not terribly expensive, but
// if we can do the conversion at the browser, then we can drop this code.
// Important Note about multi-process situation: Webview is single process so
// such a conversion does not increase the risk due to untrusted renderers.
// However, in a multi-process scenario, the renderer that does the conversion
// can be different then the renderer that receives the message. There are
// 2 possible solutions to deal with this:
// 1. Do the conversion at the browser side by writing a new serializer
// deserializer for WebSerializedScriptValue
// 2. Do the conversion at the content layer, at the renderer at the time of
// receiveing the message. This may need adding new flags to indicate that
// message needs to be converted. However, this is complicated due to queing
// at the browser side and possibility of ports being shipped to a different
// renderer or browser delegate.
// Tells the renderer to convert the message from a WebSerializeScript
// format to a base::ListValue. This IPC is used for messages that are
// incoming to Android webview from JS.
IPC_MESSAGE_ROUTED3(AwMessagePortMsg_WebToAppMessage,
int /* recipient message port id */,
base::string16 /* message */,
std::vector<int> /* sent message port_ids */)
// Tells the renderer to convert the message from a String16
// format to a WebSerializedScriptValue. This IPC is used for messages that
// are outgoing from Webview to JS.
// TODO(sgurun) when we start supporting other types, use a ListValue instead
// of string16
IPC_MESSAGE_ROUTED3(AwMessagePortMsg_AppToWebMessage,
int /* recipient message port id */,
base::string16 /* message */,
std::vector<int> /* sent message port_ids */)
// Used to defer message port closing until after all in-flight messages
// are flushed from renderer to browser. Renderer piggy-backs the message
// to browser.
IPC_MESSAGE_ROUTED1(AwMessagePortMsg_ClosePort,
int /* message port id */)
//-----------------------------------------------------------------------------
// These are messages sent from the renderer to the browser process.
// Response to AwMessagePortMessage_WebToAppMessage
IPC_MESSAGE_ROUTED3(AwMessagePortHostMsg_ConvertedWebToAppMessage,
int /* recipient message port id */,
base::ListValue /* converted message */,
std::vector<int> /* sent message port_ids */)
// Response to AwMessagePortMessage_AppToWebMessage
IPC_MESSAGE_ROUTED3(AwMessagePortHostMsg_ConvertedAppToWebMessage,
int /* recipient message port id */,
base::string16 /* converted message */,
std::vector<int> /* sent message port_ids */)
// Response to AwMessagePortMsg_ClosePort
IPC_MESSAGE_ROUTED1(AwMessagePortHostMsg_ClosePortAck,
int /* message port id */)
| [
"[email protected]"
] | |
0a46204b67a383e01f84069cf700d9a8e77810f4 | f4a065575709371a1b83d4aeecae0d070b39daba | /GraphicsEngine/MeshComponent.cpp | b9c8a4970e4bca54351c3e755a491829a315d47f | [] | no_license | Sweet-Logic/Graphics-Engine-Refactor | 4cc9691c6695e4a4b70e1896d2e6db4f22e546e5 | 82af84d89a6948b3b5ee8df34f4b4e5802e55bc9 | refs/heads/main | 2023-02-23T23:31:54.048780 | 2021-01-25T21:12:34 | 2021-01-25T21:12:34 | 332,877,567 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 27 | cpp | #include "MeshComponent.h"
| [
"[email protected]"
] | |
b2263d87e4d9a2e7c0e1f812bfef88e002e6f641 | fa419b3c71d4fdbf89c8de75c75be61a0aefcbd2 | /Stream_Sender/winpcap/StreamCommuniCation.cpp | 0635f361e345ec1eeec5525fa6861fe4b9170a6e | [] | no_license | DSLabKoreaUiv/Distributed_Stream_Processing__Platform | b578bdd3ce13a5625d8ec1d082c1070e739c94e3 | 1a269039650e74102953615810f37eda8c5a5f96 | refs/heads/master | 2016-09-05T17:04:00.685377 | 2015-06-02T01:47:30 | 2015-06-02T01:47:30 | 28,707,666 | 0 | 0 | null | null | null | null | IBM866 | C++ | false | false | 961 | cpp | #include "StreamCommuniCation.h"
#include <string>
CStreamCommuniCation::CStreamCommuniCation(char* ip,int port)
{
multiTTL=TTL;
if (WSAStartup(MAKEWORD(2,2),&WSAData) !=0) //winsock.dll ?ех?
{
printf("WSAStartup() error!");
exit(1);
}
s=socket(PF_INET, SOCK_DGRAM, 0);
if(s==INVALID_SOCKET)
{
printf("WSAStartup() error!");
exit(1);
}
memset(&addr, 0, sizeof(addr));
addr.sin_family=AF_INET;
addr.sin_port=htons(port); //port
addr.sin_addr.S_un.S_addr=inet_addr(ip); //ip
int state=setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char*) &multiTTL, sizeof(multiTTL));
if(state==SOCKET_ERROR)
{
printf("setsockopt() error");
exit(1);
}
}
CStreamCommuniCation::~CStreamCommuniCation(void)
{
closesocket(s);
WSACleanup();
}
void CStreamCommuniCation:: Send(char* message)
{
//send(s,message,strlen(message),0);
sendto(s, message, strlen(message), 0, (SOCKADDR*)&addr, sizeof(addr));
}
| [
"[email protected]"
] | |
94d1d213425f58730e35f83acb464e9de7a28618 | 58b4c099be30fe47f659af5ee538552f1c443328 | /battery_test.ino | 89d49bbe66285bf4b1648d2d75bbca11510d50bd | [] | no_license | venomerta/smt | 497782151449b6267488407045923cd8cf26c4bf | b38063e0db095750fd499a1f24b3e04c4fb25651 | refs/heads/master | 2022-06-08T02:45:22.348291 | 2020-05-03T07:02:12 | 2020-05-03T07:02:12 | 260,845,875 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,520 | ino | #include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <battery.h>
#include <bluetooth.h>
#include <wifi.h>
Adafruit_SSD1306 display(-1);
void setup()
{
// initialize with the I2C addr 0x3C
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
}
void loop() {
// Clear the buffer.
display.clearDisplay(); //for Clearing the display
display.drawBitmap(BATTERY_POS_X, BATTERY_POS_Y, battery_empty, BATTERY_WIDTH, BATTERY_HEIGHT, WHITE); // display.drawBitmap(x position, y position, bitmap data, bitmap width, bitmap height, color)
display.drawBitmap(BLUETOOTH_POS_X, BLUETOOTH_POS_Y, bluetooth, BLUETOOTH_WIDTH, BLUETOOTH_HEIGHT, WHITE);
display.drawBitmap(WIFI_POS_X, WIFI_POS_Y, wifi_0, WIFI_WIDTH, WIFI_HEIGHT, WHITE);
display.display();
delay(1000);
display.clearDisplay(); //for Clearing the display
display.drawBitmap(BATTERY_POS_X, BATTERY_POS_Y, battery_quarter, BATTERY_WIDTH, BATTERY_HEIGHT, WHITE); // display.drawBitmap(x position, y position, bitmap data, bitmap width, bitmap height, color)
display.drawBitmap(WIFI_POS_X, WIFI_POS_Y, wifi_1, WIFI_WIDTH, WIFI_HEIGHT, WHITE);
display.display();
delay(1000);
display.clearDisplay(); //for Clearing the display
display.drawBitmap(BATTERY_POS_X, BATTERY_POS_Y, battery_half, BATTERY_WIDTH, BATTERY_HEIGHT, WHITE); // display.drawBitmap(x position, y position, bitmap data, bitmap width, bitmap height, color)
display.drawBitmap(BLUETOOTH_POS_X, BLUETOOTH_POS_Y, bluetooth, BLUETOOTH_WIDTH, BLUETOOTH_HEIGHT, WHITE);
display.drawBitmap(WIFI_POS_X, WIFI_POS_Y, wifi_2, WIFI_WIDTH, WIFI_HEIGHT, WHITE);
display.display();
delay(1000);
display.clearDisplay(); //for Clearing the display
display.drawBitmap(BATTERY_POS_X, BATTERY_POS_Y, battery_three_quarter, BATTERY_WIDTH, BATTERY_HEIGHT, WHITE);
display.drawBitmap(WIFI_POS_X, WIFI_POS_Y, wifi_3, WIFI_WIDTH, WIFI_HEIGHT, WHITE);// display.drawBitmap(x position, y position, bitmap data, bitmap width, bitmap height, color)
display.display();
delay(1000);
display.clearDisplay(); //for Clearing the display
display.drawBitmap(BATTERY_POS_X, BATTERY_POS_Y, battery_full, BATTERY_WIDTH, BATTERY_HEIGHT, WHITE);
display.drawBitmap(WIFI_POS_X, WIFI_POS_Y, wifi_0, WIFI_WIDTH, WIFI_HEIGHT, WHITE);// display.drawBitmap(x position, y position, bitmap data, bitmap width, bitmap height, color)
display.display();
delay(1000);
}
| [
"[email protected]"
] | |
ed49de74eeae2646c129f3295fa6719e44ea6e35 | 7d814cf427952e2c81e0768a7c36b15c5af21262 | /frontend/views/projecttreectrl.cpp | 9b903708e1936e169f43ec7d52687999afbd83a0 | [] | no_license | komorowskilab/Parallel-ROSETTA | e2b9ee90a4bbe4f79546026e9d00abcc38ae3f5d | 60112009f4cc29f943e37d0fda86d1b28344fd3c | refs/heads/master | 2020-08-18T05:18:18.000368 | 2019-10-22T13:12:53 | 2019-10-22T13:12:53 | 215,751,254 | 2 | 1 | null | null | null | null | MacCentralEurope | C++ | false | false | 14,398 | cpp | #include <stdafx.h>
#include <frontend\rosettadoc.h>
#include <frontend\mainfrm.h>
#include <frontend\views\projecttreectrl.h>
#include <frontend\views\hint.h>
#include <frontend\dialogs\algorithmdialogs\dialogalgorithm.h>
#include <kernel\structures\structure.h>
#include <kernel\structures\annotatedstructure.h>
#include <kernel\structures\parentstructure.h>
#include <kernel\structures\project.h>
#include <kernel\algorithms\algorithm.h>
#include <kernel\basic\message.h>
#include <common\objectmanager.h>
#include <frontend\views\viewproject.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//-------------------------------------------------------------------
// Method........: Constructor
// Author........: Jórn E. Nygjerd
// Date..........: 960407
// Description...:
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
CProjectTreeCtrl::CProjectTreeCtrl()
{
m_bDragging = FALSE;
m_pimagelist = NULL;
}
//-------------------------------------------------------------------
// Method........: Destructor
// Author........: Jórn E. Nygjerd
// Date..........: 960407
// Description...:
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
CProjectTreeCtrl::~CProjectTreeCtrl()
{
}
BEGIN_MESSAGE_MAP(CProjectTreeCtrl, CTreeCtrl)
//{{AFX_MSG_MAP(CProjectTreeCtrl)
ON_WM_MOUSEMOVE()
ON_WM_RBUTTONUP()
ON_WM_LBUTTONUP()
ON_NOTIFY_REFLECT(TVN_BEGINDRAG, OnBegindrag)
ON_NOTIFY_REFLECT(TVN_ENDLABELEDIT, OnEndlabeledit)
ON_NOTIFY_REFLECT(NM_DBLCLK, OnDblclk)
ON_NOTIFY_REFLECT(TVN_BEGINRDRAG, OnBegindrag)
ON_NOTIFY_REFLECT(TVN_BEGINLABELEDIT, OnBeginlabeledit)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//-------------------------------------------------------------------
// Method........: OnMouseMove
// Author........: Jórn E. Nygjerd
// Date..........: 960407
// Description...:
// Comments......: TODO: Drag and drop funcionality
// Revisions.....:
//-------------------------------------------------------------------
void CProjectTreeCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
HTREEITEM hitem;
UINT flags;
if (m_bDragging)
{
m_pimagelist->DragMove(point);
if ((hitem = HitTest(point, &flags)) != NULL)
{
m_pimagelist->DragLeave(this);
SelectDropTarget(hitem);
m_hitemDrop = hitem;
m_pimagelist->DragEnter(this, point);
}
}
CTreeCtrl::OnMouseMove(nFlags, point);
}
//-------------------------------------------------------------------
// Method........: OnButtonUp
// Author........: Aleksander öhrn/Jórn E. Nygjerd
// Date..........: 960407
// Description...: Handles drag and drop functionality.
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
void CProjectTreeCtrl::OnButtonUp()
{
Handle<Structure> structure;
Handle<Algorithm> algorithm;
Handle<Identifier> drag;
Handle<Identifier> drop;
if (!m_bDragging)
return;
m_pimagelist->DragLeave(this);
m_pimagelist->EndDrag();
if ((m_hitemDrag == NULL) || (m_hitemDrop == NULL)) {
Message::Error("One of the drag-and-drop objects are invalid.");
}
else if (m_hitemDrag == m_hitemDrop) {
Message::Error("Drag and drop objects cannot be equal.");
}
else if (IsChildNodeOf(m_hitemDrop, m_hitemDrag)) {
Message::Error("Drop object cannot be a child of drag object.");
}
else if (GetParentItem(m_hitemDrag) == m_hitemDrop) {
Message::Error("Drop object cannot be a parent of drag object.");
}
else {
// Get drag and drop objects.
drag = reinterpret_cast(Identifier *, GetItemData(m_hitemDrag));
drop = reinterpret_cast(Identifier *, GetItemData(m_hitemDrop));
// Verify and assign objects.
if (drag.IsNULL() || drop.IsNULL()) {
Message::Error("One or both objects are invalid.");
}
else if (drag->IsA(ALGORITHM) && drop->IsA(ALGORITHM)) {
Message::Error("Both objects cannot be algorithms.");
}
else if (drag->IsA(STRUCTURE) && drop->IsA(ALGORITHM)) {
structure = dynamic_cast(Structure *, drag.GetPointer());
algorithm = dynamic_cast(Algorithm *, drop.GetPointer());
}
else if (drag->IsA(ALGORITHM) && drop->IsA(STRUCTURE)) {
structure = dynamic_cast(Structure *, drop.GetPointer());
algorithm = dynamic_cast(Algorithm *, drag.GetPointer());
}
else if (drag->IsA(STRUCTURE) && drop->IsA(STRUCTURE)) {
// This might imply something special, e.g. some implicit algorithm.
Message::Warning("Both objects cannot be structures.");
}
// So that control is transferred to the dialog (popped in ApplyAlgorithm).
ReleaseCapture();
// Get the view this control is a part of.
CViewProject *view = dynamic_cast(CViewProject *, GetParent());
if (view == NULL) {
Message::Error("Failed to access parent view containing document.");
return;
}
// Get the document attached to the view.
CRosettaDoc *document = dynamic_cast(CRosettaDoc *, view->GetDocument());
if (document == NULL) {
Message::Error("Failed to access document.");
return;
}
// Apply algorithm to structure.
if (!algorithm.IsNULL() && !structure.IsNULL()) {
if (document->ApplyAlgorithm(const_cast(Algorithm *, algorithm.GetPointer()), const_cast(Structure *, structure.GetPointer())) == NULL) {
Message().Notify("Operation not performed.");
}
else {
view->UpdateTree();
}
}
}
ReleaseCapture();
m_bDragging = FALSE;
SelectDropTarget(NULL);
}
//-------------------------------------------------------------------
// Method........: OnRButtonUp
// Author........: Jórn E. Nygjerd
// Date..........: 960407
// Description...:
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
void CProjectTreeCtrl::OnRButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
OnButtonUp();
CTreeCtrl::OnRButtonUp(nFlags, point);
}
//-------------------------------------------------------------------
// Method........: OnLButtonUp
// Author........: Jórn E. Nygjerd
// Date..........: 960407
// Description...:
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
void CProjectTreeCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
OnButtonUp();
CTreeCtrl::OnLButtonUp(nFlags, point);
}
//-------------------------------------------------------------------
// Method........: OnBeginDrag
// Author........: Jórn E. Nygjerd
// Date..........: 960407
// Description...:
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
void CProjectTreeCtrl::OnBegindrag(NMHDR* pNMHDR, LRESULT* pResult)
{
NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
CPoint ptAction;
UINT nFlags;
GetCursorPos(&ptAction);
ScreenToClient(&ptAction);
//ASSERT(!m_bDragging);
if (m_bDragging) {
Message::Debug("Hmm, aren't I already dragging an object...?");
return;
}
m_bDragging = TRUE;
m_hitemDrag = HitTest(ptAction, &nFlags);
m_hitemDrop = NULL;
m_pimagelist = CreateDragImage(m_hitemDrag); // get the image list for dragging
m_pimagelist->DragShowNolock(TRUE);
m_pimagelist->SetDragCursorImage(0, CPoint(0, 0));
m_pimagelist->BeginDrag(0, CPoint(0,0));
m_pimagelist->DragMove(ptAction);
m_pimagelist->DragEnter(this, ptAction);
SetCapture();
*pResult = 0;
}
//-------------------------------------------------------------------
// Method........: SetNewStyle
// Author........: Jórn E. Nygjerd
// Date..........: 960407
// Description...:
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
void CProjectTreeCtrl::SetNewStyle(long lStyleMask, BOOL bSetBits)
{
long lStyleOld;
lStyleOld = GetWindowLong(m_hWnd, GWL_STYLE);
lStyleOld &= ~lStyleMask;
if (bSetBits)
lStyleOld |= lStyleMask;
SetWindowLong(m_hWnd, GWL_STYLE, lStyleOld);
SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
}
//-------------------------------------------------------------------
// Method........: IsChildNodeOf
// Author........: Jórn E. Nygjerd
// Date..........: 960407
// Description...:
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
BOOL CProjectTreeCtrl::IsChildNodeOf(HTREEITEM hitemChild, HTREEITEM hitemSuspectedParent)
{
do
{
if (hitemChild == hitemSuspectedParent)
break;
}
while ((hitemChild = GetParentItem(hitemChild)) != NULL);
return (hitemChild != NULL);
}
//-------------------------------------------------------------------
// Method........: TransferItem
// Author........: Jórn E. Nygjerd
// Date..........: 960407
// Description...: Used if one wants to move a node from one place
// the tree to another. Not in use by this application
// but included for (easy) later expansions.
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
BOOL CProjectTreeCtrl::TransferItem(HTREEITEM hitemDrag, HTREEITEM hitemDrop)
{
TV_INSERTSTRUCT tvstruct;
TCHAR sztBuffer[50];
HTREEITEM hNewItem, hFirstChild;
// avoid an infinite recursion situation
tvstruct.item.hItem = hitemDrag;
tvstruct.item.cchTextMax = 49;
tvstruct.item.pszText = sztBuffer;
tvstruct.item.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
GetItem(&tvstruct.item); // get information of the dragged element
tvstruct.hParent = hitemDrop;
tvstruct.hInsertAfter = TVI_SORT;
tvstruct.item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT;
hNewItem = InsertItem(&tvstruct);
while ((hFirstChild = GetChildItem(hitemDrag)) != NULL)
{
TransferItem(hFirstChild, hNewItem); // recursively transfer all the items
DeleteItem(hFirstChild); // delete the first child and all its children
}
return TRUE;
}
//-------------------------------------------------------------------
// Method........: OnBeginlabeledit
// Author........: Daniel Remmem
// Date..........: 960715
// Description...: Allows only the label of annotated structures to be
// edited.
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
void CProjectTreeCtrl::OnBeginlabeledit(NMHDR* pNMHDR, LRESULT* pResult)
{
TV_DISPINFO *pTVDispInfo;
Handle<Identifier> identifier;
// Default: Not allow editing.
*pResult = TRUE;
// Get the item.
pTVDispInfo = reinterpret_cast(TV_DISPINFO *, pNMHDR);
if (pTVDispInfo == NULL)
return;
identifier = reinterpret_cast(Identifier *, GetItemData(pTVDispInfo->item.hItem));
// Can the structure be renamed?
if (!identifier.IsNULL() && identifier->IsA(ANNOTATEDSTRUCTURE)) {
*pResult = 0;
}
// This is not an annotated structure.
if (*pResult == TRUE)
Message::Error("This item cannot be renamed.");
}
//-------------------------------------------------------------------
// Method........: OnEndlabeledit
// Author........: Jórn E. Nygjerd/Aleksander öhrn
// Date..........: 960407
// Description...: Changes the name of a tree node and then transfers
// the name to the object in the kernel.
// Comments......:
// Revisions.....: Aö 960704 Full rewrite.
//-------------------------------------------------------------------
void CProjectTreeCtrl::OnEndlabeledit(NMHDR *pNMHDR, LRESULT *pResult)
{
TV_DISPINFO *pTVDispInfo;
Handle<Identifier> identifier;
Handle<Structure> structure;
// Get the item.
pTVDispInfo = reinterpret_cast(TV_DISPINFO *, pNMHDR);
*pResult = TRUE;
if ((pTVDispInfo == NULL) || (pTVDispInfo->item.pszText == NULL))
return;
identifier = reinterpret_cast(Identifier *, GetItemData(pTVDispInfo->item.hItem));
if (identifier.IsNULL())
return;
if (!identifier->IsA(STRUCTURE))
return;
structure = dynamic_cast(Structure *, identifier.GetPointer());
// Can the structure be renamed?
if (!structure->SetName(pTVDispInfo->item.pszText)) {
// Revert to old kernel name.
pTVDispInfo->item.pszText = const_cast(char *, (structure->GetName()).GetBuffer());
Message::Error("This structure cannot be renamed.");
}
pTVDispInfo->item.mask = TVIF_TEXT;
SetItem(&pTVDispInfo->item);
// Update window text of view of renamed object, if such a view exists.
CViewProject *view = dynamic_cast(CViewProject *, GetParent()); // Get the view this control is a part of.
if (view == NULL) {
Message::Error("Cannot update views (failed to access parent view containing document).");
return;
}
CRosettaDoc *document = dynamic_cast(CRosettaDoc *, view->GetDocument()); // Get the document attached to the view.
if (document == NULL) {
Message::Error("Cannot update views (failed to access document).");
return;
}
document->SetModifiedFlag(TRUE); // Flag that the document has been modified.
LPARAM lHint = reinterpret_cast(LPARAM, identifier.GetPointer());
CHint pHint(CHint::HINT_NAMECHANGE);
Message::Debug("Updating views..");
document->UpdateAllViews(view, lHint, &pHint); // Update all views that take the hints.
}
//-------------------------------------------------------------------
// Method........: OnDblclk
// Author........: Aleksander öhrn
// Date..........:
// Description...: Responds to a double click in the tree.
// Comments......:
// Revisions.....:
//-------------------------------------------------------------------
void CProjectTreeCtrl::OnDblclk(NMHDR* /*pNMHDR*/, LRESULT* pResult)
{
// Get the view this control is a part of.
CViewProject *view = dynamic_cast(CViewProject *, GetParent());
if (view == NULL) {
Message::Error("Failed to access parent view.");
return;
}
*pResult = TRUE;
// Get the pointer to the currently selected object.
long item_data = GetItemData(GetSelectedItem());
Identifier *identifier = reinterpret_cast(Identifier *, item_data);
if (identifier == NULL)
return;
// View the structure...
if (identifier->IsA(STRUCTURE))
view->DoView(dynamic_cast(Structure *, identifier));
// .. or apply the algorithm.
if (identifier->IsA(ALGORITHM))
view->DoApply(dynamic_cast(Algorithm *, identifier));
}
| [
"[email protected]"
] | |
375f275721f4f57a50b5fcc041348d736195f118 | 069dc57103e767a9ea2aae08d93df48b4bacf2d5 | /전력난.cpp | db168386ea71df2c0309fc4f3fb24cb8ca5115ff | [] | no_license | DongHoonKwak/BackJoon | 562a5d3da8c458d5d4b17c302d4b92719ddf344a | 483cd68aae7c77eae3e6f6e54a8b649fdbd1e783 | refs/heads/master | 2021-09-14T21:41:34.652348 | 2018-05-20T03:58:55 | 2018-05-20T03:58:55 | null | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 1,714 | cpp | #include <iostream>
#include <algorithm>
using namespace std;
pair<int, pair<int, int>>info[200004];
int level[200004];
int parent[200004];
long long ans = 0; //답 : total-cost
void make_set(int x)
{
for (int i = 0; i <= x; i++)
{
level[i] = 0;
parent[i] = i;
}
}
int find_set(int x)
{
if (parent[x] != x)
parent[x] = find_set(parent[x]);
return parent[x];
}
void union_set(int x, int y)
{
x = find_set(x);
y = find_set(y);
if (level[x] > level[y])
parent[y] = x;
else
{
parent[x] = y;
if (level[x] == level[y])
level[y]++;
}
}
int main()
{
long long total = 0; //총 전력 길이
long long cost = 0;; // 최소연결비용
int house; //집의 수
int load; //길의 수
int s_house, e_house;
long long meter;
while (1)
{
total = 0;
cost = 0;
ans = 0;
scanf("%d %d", &house, &load);
if (house == 0 && load == 0)
break;
if (house >= 1 && house <= 200000)
{
if ((load >= house - 1) && (load <= 200000))
{
make_set(house);
for (int i = 1; i <= load; i++)
{
scanf("%d %d %lld", &s_house, &e_house, &meter);
total += meter;
info[i].first = meter;
info[i].second.first = s_house;
info[i].second.second = e_house;
}
sort(info, info + load + 1);
for (int i = 1; i <= load; i++)
{
s_house = info[i].second.first;
e_house = info[i].second.second;
meter = info[i].first;
if ((find_set(s_house)) != (find_set(e_house)))
{
cost += meter;
union_set(s_house, e_house);
}
}
ans = total - cost;
printf("%lld\n", ans);
}
}
}
}
| [
"[email protected]"
] | |
04ec76fca6e05d6cc7485717238a150389f72819 | fa091b57896b56c9ad646ad3474c4c88c796b180 | /6_breakANDcontinue_state.cpp | f4354c2649320c5e55a0aab9358e9dde13f48be2 | [] | no_license | alishaac/.cpp | eecfece5377920fa3a79cd18f69cfd5cd6aa4e29 | 6b7a92810905c911eb14ddc1bf0831adfd521c02 | refs/heads/master | 2023-06-16T09:42:57.773355 | 2021-07-16T08:48:06 | 2021-07-16T08:48:06 | 385,606,951 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 519 | cpp | #include<iostream>
using namespace std;
int main(){
//after using break statement the program gets out of the loop
// for (int i = 0; i < 40; i++)
// {
// if(i==2){
// break;
// }
// cout<<i<<endl;
// }
// after using continue statement the program works cont in loop
for (int i = 0; i < 40; i++)
{
if(i==2){
continue;
}
cout<<i<<endl;
}
return 0;
} | [
"[email protected]"
] | |
a3ed2a7983db7551a9328df2e96c72ad287577e3 | 1c59da2fa9fba8fa35572be2176b96b0af24213e | /Vector/GreaterElementsToTheRight.cpp | bedbc444c32804c0a8927ee88537d4c8872f38b0 | [] | no_license | thienphuvn95/CS3358-DataStructures-Algorithms | 9a78aafe1d7c936ab052cbd1d9b86f8afd55a4a3 | 29afb6ae4d7f53a5b37ff759e78d60786c17d6e2 | refs/heads/master | 2021-05-23T17:44:36.983643 | 2020-04-06T05:57:34 | 2020-04-06T05:57:34 | 253,405,244 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 826 | cpp | // Include the necessary header files
#include <iostream>
#include <vector>
void greaterRightElement(std::vector<int> & vec) {
// Start from the rear of the vector and work backwards
auto ptr=vec.end()-1;
auto max=*(vec.end()-1);
for(int i=0; i<vec.size()-1;i++){
if (*ptr< max){
*ptr=max;
ptr--;
}
else{
max=*ptr;
ptr--;
}
}
vec.push_back(*(vec.end()-1));
vec.erase(vec.begin());
}
int main(){
// Read input into a vector.
int numbs;
std::vector<int> vec;
while(std::cin>>numbs){
vec.push_back(numbs);}
// Call your function on the vector.
greaterRightElement(vec);
// Print contents of the vector.
for (auto i: vec)
std::cout<<i<<" ";
return 0;
}
| [
"[email protected]"
] | |
83acc7e93c879ff42b9ec3b1af9137ff43a56382 | c918e96de354292c5bdd71e5e3a65a969e2e2dff | /labwork_2/4.cpp | e731a4e78c7134956cb4b7401fa487111c095f82 | [] | no_license | romashik17/LABS_YZ_PROG | 11295ab23954b9ece0ff4c55f5ec156acda09d4a | f242f2957c39259e2a4dd722c8e5a82712f5dce8 | refs/heads/master | 2020-05-30T04:03:09.043569 | 2019-12-12T16:57:33 | 2019-12-12T16:57:33 | 189,528,188 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 268 | cpp | #include <iostream>
#include <math.h>
using namespace std;
int main()
{
int n;
cout<<"Введите число: ";
cin >> n;
for (int i=2; i<=sqrt(n); i++) {
if (n%i==0) {
cout << "Нет" <<endl;
return 0;
}
}
cout << "Да" <<endl;
return 0;
}
| [
"[email protected]"
] | |
b66b295a93b972bd3e2f9929c180f2a434291afa | 08d297016d313276c1372d49d349ae5897012937 | /01152016/01152016/SpellCorrection.cpp | 87dc58710d5d74abab4033ba1cb3c8460d9e0ba1 | [] | no_license | jamestiller/katas | ab7e5c598348d439d3498a0f6426e7a01d0176d1 | 35c0fb9708a91501db2bbc5ee6097cb26d638d58 | refs/heads/master | 2021-01-10T10:34:54.987428 | 2016-03-03T22:25:48 | 2016-03-03T22:25:48 | 52,528,689 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 843 | cpp | //
// SpellCorrection.cpp
// 01152016
//
// Created by James Tiller on 3/3/16.
// Copyright © 2016 James Tiller. All rights reserved.
//
#include "SpellCorrection.hpp"
int NumberOfEditsRequired(std::string start, std::string target){
if (start.size() < target.size())
{
std::swap(start,target);
}
std::vector<int> result(target.size() + 1);
std::iota(result.begin(), result.end(), 0);
for (int i = 1 ; i <= start.size(); ++i)
{
int previous = result[0];
result[0] = i;
for (int j = 1; j <= target.size(); ++j)
{
int current = result[j];
result[j] = start[i - 1] == target[j - 1] ? previous : 1 + std::min(previous, std::min(result[j-1],result[j]));
previous = current;
}
}
return result.back();
} | [
"[email protected]"
] | |
af20f08868200ae06bc11a20b337da3d1ba91571 | fee351ff8eb3dea498833426978baf50b5e32e56 | /Library/Source/Nano/Files/NFile.cpp | 2752f36b4aff2ef71d8f5aa24d48d2397d3ed7f6 | [
"BSD-3-Clause"
] | permissive | x414e54/nano | 42a1f733308b92959457cfa6e8e1a78b2cd10928 | 6740b4be7a72facb30e9508261976afc3af85f98 | refs/heads/master | 2021-01-16T20:30:07.050233 | 2013-07-16T20:46:32 | 2013-07-16T20:46:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 22,363 | cpp | /* NAME:
NFile.cpp
DESCRIPTION:
File object.
COPYRIGHT:
Copyright (c) 2006-2013, refNum Software
<http://www.refnum.com/>
All rights reserved. Released under the terms of licence.html.
__________________________________________________________________________
*/
//============================================================================
// Include files
//----------------------------------------------------------------------------
#include "NFileIterator.h"
#include "NTargetFile.h"
#include "NEncoder.h"
#include "NFile.h"
//============================================================================
// Implementation
//----------------------------------------------------------------------------
NENCODABLE_DEFINE(NFile);
//============================================================================
// NFile::NFile : Constructor.
//----------------------------------------------------------------------------
NFile::NFile(const NString &thePath)
{
// Initialize ourselves
InitializeSelf(thePath);
}
//============================================================================
// NFile::NFile : Constructor.
//----------------------------------------------------------------------------
NFile::NFile(const NFile &theFile)
: NEncodable(), NComparable<NFile>()
{
// Initialise ourselves
InitializeSelf();
CloneFile(theFile);
}
//============================================================================
// NFile::NFile : Constructor.
//----------------------------------------------------------------------------
NFile::NFile(void)
{
// Initialize ourselves
InitializeSelf();
}
//============================================================================
// NFile::~NFile : Destructor.
//----------------------------------------------------------------------------
NFile::~NFile(void)
{
// Clean up
if (IsOpen())
Close();
}
//============================================================================
// NFile::IsValid : Is the file valid?
//----------------------------------------------------------------------------
bool NFile::IsValid(void) const
{
// Check our state
return(!mPath.IsEmpty());
}
//============================================================================
// NFile::IsFile : Is this a file?
//----------------------------------------------------------------------------
bool NFile::IsFile(void) const
{
// Check the path
return(Exists() && NTargetFile::IsFile(mPath));
}
//============================================================================
// NFile::IsDirectory : Is this a directory?
//----------------------------------------------------------------------------
bool NFile::IsDirectory(void) const
{
// Check the path
return(Exists() && NTargetFile::IsDirectory(mPath));
}
//============================================================================
// NFile::IsLink : Is this a link?
//----------------------------------------------------------------------------
bool NFile::IsLink(void) const
{
// Check the path
return(Exists() && NTargetFile::IsLink(mPath));
}
//============================================================================
// NFile::IsWriteable : Is the file writeable?
//----------------------------------------------------------------------------
bool NFile::IsWriteable(void) const
{
// Check the path
return(NTargetFile::IsWriteable(mPath));
}
//============================================================================
// NFile::IsOpen : Is the file open?
//----------------------------------------------------------------------------
bool NFile::IsOpen(void) const
{
// Check our state
return(mFile != kNFileRefNone);
}
//============================================================================
// NFile::Exists : Does the file exist?
//----------------------------------------------------------------------------
bool NFile::Exists(void) const
{
// Check the path
return(NTargetFile::Exists(mPath));
}
//============================================================================
// NFile::Clear : Clear the value.
//----------------------------------------------------------------------------
void NFile::Clear(void)
{
// Clear the value
if (IsOpen())
Close();
mPath.Clear();
}
//============================================================================
// NFile::Compare : Compare the value.
//----------------------------------------------------------------------------
NComparison NFile::Compare(const NFile &theValue) const
{
// Compare the value
//
// File paths are considered to be case-insensitive but case-preserving.
return(mPath.Compare(theValue.mPath, kNStringNoCase));
}
//============================================================================
// NFile::GetUTI : Get the UTI.
//----------------------------------------------------------------------------
NUTI NFile::GetUTI(void) const
{ NString theExtension;
NUTI theUTI;
// Use the file extension
//
// Could also use a target-specific mechanism like LaunchServices.
if (!theUTI.IsValid())
{
theExtension = GetExtension();
if (!theExtension.IsEmpty())
theUTI = NUTI(kNUTITagClassFileExtension, theExtension);
}
return(theUTI);
}
//============================================================================
// NFile::GetPath : Get the path.
//----------------------------------------------------------------------------
NString NFile::GetPath(void) const
{
// Get the path
return(mPath);
}
//============================================================================
// NFile::SetPath : Set the path.
//----------------------------------------------------------------------------
void NFile::SetPath(const NString &thePath)
{
// Update our state
if (IsOpen())
Close();
// Set the path
mPath = thePath;
}
//============================================================================
// NFile::GetName : Get the file name.
//----------------------------------------------------------------------------
NString NFile::GetName(NFileName theName) const
{ bool displayName;
NString fileName;
NRange theDot;
// Get the name
displayName = (theName == kNNameDisplay);
fileName = NTargetFile::GetName(mPath, displayName);
if (theName == kNNameNoExtension)
{
theDot = fileName.Find(".", kNStringBackwards);
if (!theDot.IsEmpty())
fileName = fileName.GetLeft(theDot.GetLocation());
}
return(fileName);
}
//============================================================================
// NFile::SetName : Set the file name.
//----------------------------------------------------------------------------
NStatus NFile::SetName(const NString &theName, bool renameFile)
{
// Set the name
return(SetName(theName, renameFile, false));
}
//============================================================================
// NFile::GetExtension : Set the file extension.
//----------------------------------------------------------------------------
NString NFile::GetExtension(void) const
{ NString theResult;
NRange theDot;
// Get the state we need
theResult = GetName();
theDot = theResult.Find(".", kNStringBackwards);
// Extract the extension
if (theDot.IsEmpty())
theResult.Clear();
else
theResult = theResult.GetString(theDot.GetNext());
return(theResult);
}
//============================================================================
// NFile::SetExtension : Set the file extension.
//----------------------------------------------------------------------------
NStatus NFile::SetExtension(const NString &theExtension, bool renameFile)
{ NString theName, oldExtension;
// Construct the new name
theName = GetName();
oldExtension = GetExtension();
if (!oldExtension.IsEmpty())
theName = theName.GetLeft(theName.GetSize() - (oldExtension.GetSize() + 1));
theName += ".";
theName += theExtension;
// Set the file name
return(SetName(theName, renameFile));
}
//============================================================================
// NFile::GetSize : Get the file size.
//----------------------------------------------------------------------------
UInt64 NFile::GetSize(void) const
{
// Check our state
if (!Exists() || !IsFile())
return(0);
// Get the size
return(NTargetFile::GetSize(mPath));
}
//============================================================================
// NFile::SetSize : Set the file size.
//----------------------------------------------------------------------------
NStatus NFile::SetSize(UInt64 theSize)
{ bool wasOpen;
NStatus theErr;
// Prepare the file
wasOpen = IsOpen();
if (!wasOpen)
{
theErr = Open(kNPermissionWrite, true);
NN_ASSERT_NOERR(theErr);
if (theErr != kNoErr)
return(theErr);
}
// Set the size
theErr = NTargetFile::SetSize(mPath, mFile, theSize);
NN_ASSERT_NOERR(theErr);
// Clean up
if (!wasOpen)
Close();
return(theErr);
}
//============================================================================
// NFile::GetCreationTime : Get the creation time.
//----------------------------------------------------------------------------
NDate NFile::GetCreationTime(void) const
{
// Get the time
return(NTargetFile::GetCreationTime(mPath));
}
//============================================================================
// NFile::GetAccessTime : Get the access time.
//----------------------------------------------------------------------------
NDate NFile::GetAccessTime(void) const
{
// Get the time
return(NTargetFile::GetAccessTime(mPath));
}
//============================================================================
// NFile::GetModificationTime : Get the modification time.
//----------------------------------------------------------------------------
NDate NFile::GetModificationTime(void) const
{
// Get the time
return(NTargetFile::GetModificationTime(mPath));
}
//============================================================================
// NFile::GetChild : Get the child of a directory.
//----------------------------------------------------------------------------
NFile NFile::GetChild(const NString &fileName) const
{
// Get the child
return(NTargetFile::GetChild(mPath, fileName));
}
//============================================================================
// NFile::GetParent : Get the parent of a file/directory.
//----------------------------------------------------------------------------
NFile NFile::GetParent(void) const
{
// Get the parent
return(NTargetFile::GetParent(mPath));
}
//============================================================================
// NFile::GetTarget : Get the target of a file.
//----------------------------------------------------------------------------
NFile NFile::GetTarget(void) const
{ NFile theFile;
// Get the target
theFile = *this;
theFile.ResolveTarget();
return(theFile);
}
//============================================================================
// NFile::ResolveTarget : Resolve a linked file.
//----------------------------------------------------------------------------
void NFile::ResolveTarget(void)
{
// Resolve the link
SetPath(NTargetFile::GetTarget(mPath));
}
//============================================================================
// NFile::GetChildren : Get the child of a directory.
//----------------------------------------------------------------------------
NFileList NFile::GetChildren(void) const
{
// Validate our state
NN_ASSERT(IsDirectory());
// Get the children
return(NTargetFile::GetChildren(mPath));
}
//============================================================================
// NFile::Delete : Delete the file.
//----------------------------------------------------------------------------
NStatus NFile::Delete(bool moveToTrash) const
{ NStatus theErr;
// Validate our state
NN_ASSERT(Exists());
// Empty directories
if (IsDirectory() && !moveToTrash)
{
theErr = DeleteContents();
NN_ASSERT_NOERR(theErr);
if (theErr != kNoErr)
return(theErr);
}
// Delete the file
theErr = NTargetFile::Delete(mPath, moveToTrash);
NN_ASSERT_NOERR(theErr);
return(theErr);
}
//============================================================================
// NFile::DeleteContents : Delete the contents if a directory.
//----------------------------------------------------------------------------
NStatus NFile::DeleteContents(void) const
{ NFileIterator fileIterator;
NFileList theFiles;
NFile theFile;
NFileListConstIterator theIter;
NStatus theErr;
// Validate our state
NN_ASSERT(IsDirectory());
// Get the state we need
fileIterator.SetRecurseLimit(0);
theFiles = fileIterator.GetFiles(*this);
theErr = kNoErr;
// Delete the contents
for (theIter = theFiles.begin(); theIter != theFiles.end() && theErr == kNoErr; theIter++)
{
theFile = *theIter;
if (theFile.IsDirectory())
theErr = theFile.DeleteContents();
if (theErr == kNoErr)
theErr = theFile.Delete();
}
return(theErr);
}
//============================================================================
// NFile::CreateFile : Create a file.
//----------------------------------------------------------------------------
NStatus NFile::CreateFile(void)
{ NStatus theErr;
// Validate our state
NN_ASSERT(!Exists());
// Create the parent
CreateParent();
// Create a file
theErr = Open(kNPermissionWrite, true);
NN_ASSERT_NOERR(theErr);
if (theErr == kNoErr)
Close();
return(theErr);
}
//============================================================================
// NFile::CreateDirectory : Create a directory.
//----------------------------------------------------------------------------
NStatus NFile::CreateDirectory(void)
{ NStatus theErr;
// Validate our state
NN_ASSERT(!Exists());
// Create the parent
CreateParent();
// Create a directory
theErr = NTargetFile::CreateDirectory(mPath);
NN_ASSERT_NOERR(theErr);
return(theErr);
}
//============================================================================
// NFile::CreateLink : Create a link.
//----------------------------------------------------------------------------
NStatus NFile::CreateLink(const NFile &theTarget, NFileLink theType)
{ NStatus theErr;
// Validate our state
NN_ASSERT(!Exists());
// Create the parent
CreateParent();
// Create a directory
theErr = NTargetFile::CreateLink(mPath, theTarget.mPath, theType);
NN_ASSERT_NOERR(theErr);
return(theErr);
}
//============================================================================
// NFile::ExchangeWith : Exchange two files.
//----------------------------------------------------------------------------
NStatus NFile::ExchangeWith(const NFile &theTarget)
{ NStatus theErr;
// Exchange two files
theErr = NTargetFile::ExchangeWith(mPath, theTarget.mPath);
NN_ASSERT_NOERR(theErr);
return(theErr);
}
//============================================================================
// NFile::MoveTo : Move a file to a directory.
//----------------------------------------------------------------------------
NStatus NFile::MoveTo(const NFile &theTarget)
{ NFile newFile;
NStatus theErr;
// Validate our parameters and state
NN_ASSERT(theTarget.IsDirectory());
NN_ASSERT(Exists());
// Move the file
newFile = theTarget.GetChild(GetName());
theErr = SetName(newFile.GetPath(), true, true);
return(theErr);
}
//============================================================================
// NFile::Open : Open the file.
//----------------------------------------------------------------------------
NStatus NFile::Open(NFilePermission thePermission, bool canCreate)
{ NStatus theErr;
// Validate our state
NN_ASSERT(!IsOpen());
// Check our state
if (!canCreate && !IsFile())
return(kNErrNotFound);
// Open the file
theErr = kNErrPermission;
mFile = NTargetFile::FileOpen(mPath, thePermission);
if (mFile != kNFileRefNone)
{
theErr = kNoErr;
mPermission = thePermission;
}
return(theErr);
}
//============================================================================
// NFile::Close : Close the file.
//----------------------------------------------------------------------------
void NFile::Close(void)
{
// Validate our state
NN_ASSERT(Exists() ? IsFile() : true);
NN_ASSERT(IsOpen());
// Close the file
NTargetFile::FileClose(mFile);
mFile = kNFileRefNone;
mPermission = kNPermissionRead;
}
//============================================================================
// NFile::GetPosition : Get the read/write position.
//----------------------------------------------------------------------------
UInt64 NFile::GetPosition(void) const
{ UInt64 thePosition;
// Validate our state
NN_ASSERT(IsFile());
NN_ASSERT(IsOpen());
// Get the position
thePosition = NTargetFile::FileGetPosition(mFile);
return(thePosition);
}
//============================================================================
// NFile::SetPosition : Set the read/write position.
//----------------------------------------------------------------------------
NStatus NFile::SetPosition(SInt64 theOffset, NFilePosition thePosition)
{ NStatus theErr;
// Validate our state
NN_ASSERT(IsFile());
NN_ASSERT(IsOpen());
NN_ASSERT(mPermission != kNPermissionWrite);
// Set the position
theErr = NTargetFile::FileSetPosition(mFile, theOffset, thePosition);
NN_ASSERT_NOERR(theErr);
return(theErr);
}
//============================================================================
// NFile::Read : Read data from the file.
//----------------------------------------------------------------------------
NStatus NFile::Read(UInt64 theSize, void *thePtr, UInt64 &numRead, SInt64 theOffset, NFilePosition thePosition, NFileFlags theFlags)
{ NStatus theErr;
// Validate our state
NN_ASSERT(IsFile());
NN_ASSERT(IsOpen());
NN_ASSERT(mPermission != kNPermissionWrite);
// Read the file
numRead = 0;
theErr = NTargetFile::FileRead(mFile, theSize, thePtr, numRead, theOffset, thePosition, theFlags);
NN_ASSERT(theErr == kNoErr || theErr == kNErrExhaustedSrc);
return(theErr);
}
//============================================================================
// NFile::Write : Write data to the file.
//----------------------------------------------------------------------------
NStatus NFile::Write(UInt64 theSize, const void *thePtr, UInt64 &numWritten, SInt64 theOffset, NFilePosition thePosition, NFileFlags theFlags)
{ NStatus theErr;
// Validate our state
NN_ASSERT(IsFile());
NN_ASSERT(IsOpen());
NN_ASSERT(mPermission != kNPermissionRead);
// Write the file
numWritten = 0;
theErr = NTargetFile::FileWrite(mFile, theSize, thePtr, numWritten, theOffset, thePosition, theFlags);
NN_ASSERT_NOERR(theErr);
return(theErr);
}
//============================================================================
// NFile::= : Assignment operator.
//----------------------------------------------------------------------------
const NFile& NFile::operator = (const NFile &theFile)
{
// Assign the file
if (this != &theFile)
CloneFile(theFile);
return(*this);
}
//============================================================================
// NFile::NFormatArgument : NFormatArgument operator.
//----------------------------------------------------------------------------
NFile::operator NFormatArgument(void) const
{
// Get the value
return(GetPath());
}
#pragma mark protected
//============================================================================
// NFile::EncodeSelf : Encode the object.
//----------------------------------------------------------------------------
void NFile::EncodeSelf(NEncoder &theEncoder) const
{
// Encode the object
theEncoder.EncodeString(kNEncoderValueKey, GetPath());
}
//============================================================================
// NFile::DecodeSelf : Decode the object.
//----------------------------------------------------------------------------
void NFile::DecodeSelf(const NEncoder &theEncoder)
{
// Decode the object
SetPath(theEncoder.DecodeString(kNEncoderValueKey));
}
#pragma mark private
//============================================================================
// NFile::InitializeSelf : Initialize the file.
//----------------------------------------------------------------------------
void NFile::InitializeSelf(const NString &thePath)
{
// Initialize ourselves
mPath = thePath;
mFile = kNFileRefNone;
mPermission = kNPermissionRead;
}
//============================================================================
// NFile::CloneFile : Clone a file.
//----------------------------------------------------------------------------
void NFile::CloneFile(const NFile &theFile)
{
// Reset our state
if (IsOpen())
Close();
// Clone the file
//
// File references are not copied between files; a file reference
// is owned by the file object which opened it.
mPath = theFile.mPath;
}
//============================================================================
// NFile::CreateParent : Create the parent directory.
//----------------------------------------------------------------------------
void NFile::CreateParent(void)
{ NFile theParent;
// Create the parent directory
theParent = GetParent();
if (!theParent.Exists())
theParent.CreateDirectory();
}
//============================================================================
// NFile::SetName : Set the file name.
//----------------------------------------------------------------------------
NStatus NFile::SetName(const NString &theName, bool renameFile, bool isPath)
{ NString newPath;
NStatus theErr;
// Set the name
theErr = NTargetFile::SetName(mPath, theName, renameFile, isPath, newPath);
if (theErr == kNoErr)
SetPath(newPath);
return(theErr);
}
| [
"[email protected]"
] | |
5753ca3449ea9c85aa1c6312bb3aa990f72022de | b4e9ff1b80ff022aaacdf2f863bc3a668898ce7f | /gluon/Cfill/bin/src/org/poly2tri/Edge.cpp | 9cb52f71e17657aefa920351e732bad1ae103f33 | [
"MIT"
] | permissive | TrilateralX/TrilateralSamples | c1aa206495cf6e1f4f249c87e49fa46d62544c24 | 9c9168c5c2fabed9222b47e738c67ec724b52aa6 | refs/heads/master | 2023-04-02T05:10:13.579952 | 2021-04-01T17:41:23 | 2021-04-01T17:41:23 | 272,706,707 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | true | 5,273 | cpp | // Generated by Haxe 4.2.0-rc.1+7dc565e63
#include <hxcpp.h>
#ifndef INCLUDED_Std
#include <Std.h>
#endif
#ifndef INCLUDED_haxe_Exception
#include <haxe/Exception.h>
#endif
#ifndef INCLUDED_org_poly2tri_Edge
#include <org/poly2tri/Edge.h>
#endif
#ifndef INCLUDED_org_poly2tri_Point
#include <org/poly2tri/Point.h>
#endif
HX_DEFINE_STACK_FRAME(_hx_pos_ae1a0fb23072ab93_9_new,"org.poly2tri.Edge","new",0xb03bd7ce,"org.poly2tri.Edge.new","org/poly2tri/Edge.hx",9,0x9276df82)
namespace org{
namespace poly2tri{
void Edge_obj::__construct( ::org::poly2tri::Point p1, ::org::poly2tri::Point p2){
HX_STACKFRAME(&_hx_pos_ae1a0fb23072ab93_9_new)
HXLINE( 10) bool _hx_tmp;
HXDLIN( 10) if (::hx::IsNotNull( p1 )) {
HXLINE( 10) _hx_tmp = ::hx::IsNull( p2 );
}
else {
HXLINE( 10) _hx_tmp = true;
}
HXDLIN( 10) if (_hx_tmp) {
HXLINE( 10) HX_STACK_DO_THROW(::haxe::Exception_obj::thrown(HX_("Edge::new p1 or p2 is null",fa,33,85,89)));
}
HXLINE( 12) bool swap = false;
HXLINE( 14) if ((p1->y > p2->y)) {
HXLINE( 16) swap = true;
}
else {
HXLINE( 18) if ((p1->y == p2->y)) {
HXLINE( 20) if ((p1->x == p2->x)) {
HXLINE( 20) HX_STACK_DO_THROW(::haxe::Exception_obj::thrown((HX_("Edge::repeat points ",f5,bb,3a,3f) + ::Std_obj::string(p1))));
}
HXLINE( 22) swap = (p1->x > p2->x);
}
}
HXLINE( 26) if (swap) {
HXLINE( 28) this->q = p1;
HXLINE( 29) this->p = p2;
}
else {
HXLINE( 33) this->p = p1;
HXLINE( 34) this->q = p2;
}
HXLINE( 37) this->q->get_edge_list()->push(::hx::ObjectPtr<OBJ_>(this));
}
Dynamic Edge_obj::__CreateEmpty() { return new Edge_obj; }
void *Edge_obj::_hx_vtable = 0;
Dynamic Edge_obj::__Create(::hx::DynamicArray inArgs)
{
::hx::ObjectPtr< Edge_obj > _hx_result = new Edge_obj();
_hx_result->__construct(inArgs[0],inArgs[1]);
return _hx_result;
}
bool Edge_obj::_hx_isInstanceOf(int inClassId) {
return inClassId==(int)0x00000001 || inClassId==(int)0x42b7a97e;
}
::hx::ObjectPtr< Edge_obj > Edge_obj::__new( ::org::poly2tri::Point p1, ::org::poly2tri::Point p2) {
::hx::ObjectPtr< Edge_obj > __this = new Edge_obj();
__this->__construct(p1,p2);
return __this;
}
::hx::ObjectPtr< Edge_obj > Edge_obj::__alloc(::hx::Ctx *_hx_ctx, ::org::poly2tri::Point p1, ::org::poly2tri::Point p2) {
Edge_obj *__this = (Edge_obj*)(::hx::Ctx::alloc(_hx_ctx, sizeof(Edge_obj), true, "org.poly2tri.Edge"));
*(void **)__this = Edge_obj::_hx_vtable;
__this->__construct(p1,p2);
return __this;
}
Edge_obj::Edge_obj()
{
}
void Edge_obj::__Mark(HX_MARK_PARAMS)
{
HX_MARK_BEGIN_CLASS(Edge);
HX_MARK_MEMBER_NAME(p,"p");
HX_MARK_MEMBER_NAME(q,"q");
HX_MARK_END_CLASS();
}
void Edge_obj::__Visit(HX_VISIT_PARAMS)
{
HX_VISIT_MEMBER_NAME(p,"p");
HX_VISIT_MEMBER_NAME(q,"q");
}
::hx::Val Edge_obj::__Field(const ::String &inName,::hx::PropertyAccess inCallProp)
{
switch(inName.length) {
case 1:
if (HX_FIELD_EQ(inName,"p") ) { return ::hx::Val( p ); }
if (HX_FIELD_EQ(inName,"q") ) { return ::hx::Val( q ); }
}
return super::__Field(inName,inCallProp);
}
::hx::Val Edge_obj::__SetField(const ::String &inName,const ::hx::Val &inValue,::hx::PropertyAccess inCallProp)
{
switch(inName.length) {
case 1:
if (HX_FIELD_EQ(inName,"p") ) { p=inValue.Cast< ::org::poly2tri::Point >(); return inValue; }
if (HX_FIELD_EQ(inName,"q") ) { q=inValue.Cast< ::org::poly2tri::Point >(); return inValue; }
}
return super::__SetField(inName,inValue,inCallProp);
}
void Edge_obj::__GetFields(Array< ::String> &outFields)
{
outFields->push(HX_("p",70,00,00,00));
outFields->push(HX_("q",71,00,00,00));
super::__GetFields(outFields);
};
#ifdef HXCPP_SCRIPTABLE
static ::hx::StorageInfo Edge_obj_sMemberStorageInfo[] = {
{::hx::fsObject /* ::org::poly2tri::Point */ ,(int)offsetof(Edge_obj,p),HX_("p",70,00,00,00)},
{::hx::fsObject /* ::org::poly2tri::Point */ ,(int)offsetof(Edge_obj,q),HX_("q",71,00,00,00)},
{ ::hx::fsUnknown, 0, null()}
};
static ::hx::StaticInfo *Edge_obj_sStaticStorageInfo = 0;
#endif
static ::String Edge_obj_sMemberFields[] = {
HX_("p",70,00,00,00),
HX_("q",71,00,00,00),
::String(null()) };
::hx::Class Edge_obj::__mClass;
void Edge_obj::__register()
{
Edge_obj _hx_dummy;
Edge_obj::_hx_vtable = *(void **)&_hx_dummy;
::hx::Static(__mClass) = new ::hx::Class_obj();
__mClass->mName = HX_("org.poly2tri.Edge",dc,98,2c,f7);
__mClass->mSuper = &super::__SGetClass();
__mClass->mConstructEmpty = &__CreateEmpty;
__mClass->mConstructArgs = &__Create;
__mClass->mGetStaticField = &::hx::Class_obj::GetNoStaticField;
__mClass->mSetStaticField = &::hx::Class_obj::SetNoStaticField;
__mClass->mStatics = ::hx::Class_obj::dupFunctions(0 /* sStaticFields */);
__mClass->mMembers = ::hx::Class_obj::dupFunctions(Edge_obj_sMemberFields);
__mClass->mCanCast = ::hx::TCanCast< Edge_obj >;
#ifdef HXCPP_SCRIPTABLE
__mClass->mMemberStorageInfo = Edge_obj_sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
__mClass->mStaticStorageInfo = Edge_obj_sStaticStorageInfo;
#endif
::hx::_hx_RegisterClass(__mClass->mName, __mClass);
}
} // end namespace org
} // end namespace poly2tri
| [
"none"
] | none |
145e3eb31c61b676f31f476efc5eef505a588f05 | 4c3e844382943271a06b933a9dbc3c8b30b08dca | /2nd Sem/C++/Programs/genericclass3.cpp | d6c8c07675485c1481c824f838bdc8be88970950 | [] | no_license | vijaykumarrpai/mca-code | 9ec29f8684bb4a3327c63fb48eb0c244eef5e9c7 | ed407c539ff8a33811817b8dfcceea39c68641bd | refs/heads/master | 2022-12-22T11:08:53.960599 | 2020-11-08T13:20:22 | 2020-11-08T13:20:22 | 182,063,526 | 4 | 2 | null | 2022-12-16T12:13:43 | 2019-04-18T10:00:53 | Jupyter Notebook | UTF-8 | C++ | false | false | 367 | cpp | // mixing standard and generic data types
#include <iostream>
using namespace std;
template <class t1, int y>
class test
{
t1 a;
int b;
public:
test(t1 x) // constructor requires only one parameter as another is of defaclt type
{
a=x;
b=y;
}
void display()
{
cout<<a<<"\t"<<b;
}
};
int main()
{
test<float, 50>ob1(25.25);
ob1.display();
return 0;
} | [
"[email protected]"
] | |
f53ebcceb8c53fdb7963b9117cb25e45836d9691 | 62ec6bae293411cbde16162caf18d7b9ac22a5c2 | /MRS/MovieView.cpp | 6d443d488df48bd18b8584029c8f9a82b4cce3a4 | [] | no_license | overlord7a/MRS | eca8501d2518c3ca8c5df6324a547e6e62fe554e | 16b7844a3208566573e9555b8b509a3b67f54059 | refs/heads/master | 2022-11-22T02:43:13.365363 | 2020-07-23T07:23:19 | 2020-07-23T07:23:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,520 | cpp | #include "MovieView.h"
#include <iomanip>
#include <iostream>
#include <vector>
#include <string>
using namespace std;
void MovieView::DisplayMovie(vector<Movie> const& movies)
{
cout << " " << "\n";
cout << string(10, ' ') << string(20, '-');
cout << " " << "Display Movies";
cout << " " << string(20, '-') << string(20, ' ') << "\n" << "\n";
cout << " " << "Id" << string(4,' ' )<< "Movie Name" << string(46,' ') << "Year" << "\n";
cout << " " << "--" << string(4, ' ') << string(11, '-') << string(46, ' ') << "----" << "\n";
for (const Movie temp : movies)
{
string str = temp.MovieName;
cout << " " << temp.MovieId << '\t' << setw(50) << std::left << str << '\t' << temp.CreateYear << endl;
delayer(50);
}
cout << "\n Press 'm' to Main menu , and 'q' to quit : ";
}
void MovieView::AddRemoveSection()
{
cout << " " << string(10, '-') << '\n';
cout << " " << "Add/Remove a movie" << '\n';
cout << " " << string(10, '-') << "\n" << "\n";
cout << " " << string(4, '=') << "What do you want to do?" << string(4, '=') << '\n' << '\n';
cout << " " << "a.Add a new movie " << '\n';
cout << " " << "b.Remove a movie " << '\n';
cout << " " << "c.back to main menu " << '\n';
cout << " " << "d.Exit " << '\n' << '\n';
cout << " " << "Your Choice? : ";
}
void MovieView::AddMovie(bool yearSection, bool section, bool saved, bool ModelState, bool result, bool section3, bool lastSection)
{
if (yearSection)
{
if (yearSection && !ModelState && !section)
{
cout << " " << "Year:";
}
if (yearSection && section && !ModelState && !saved)
{
cout << " " << string(15, '=') << '\n';
cout << " " << "Do You Want To Save ? : ";
}
if (saved)
{
if (ModelState && result)
{
cout << "\n\n" << " " << "The record was successfully saved ";
}
}
if (saved &&!ModelState&& section3)
{
cout << "\n " << "This movie already exists"<<'\n';
}
else
{
if (!result && ModelState && saved)
{
cerr << "And Error occured while saving movie";
}
}
if(lastSection)
{
cout << "\n\n" << " " << "Press 'r' to retry, 'p' to Previous ,'m' to Main menu , and 'q' to Quit";
cout << "\n " << "Your Choice? : ";
}
}
else
{
cout << " " << string(10, '-') << '\n';
cout << " " << "Add a new movie" << '\n';
cout << " " << string(10, '-') << "\n" << "\n";
cout << " " << "Enter Information Below" << '\n';
cout << " " << string(15, '=') << '\n';
cout << " " << "Name:";
}
}
void MovieView::RemoveMovie(bool ModelState,bool success)
{
if (ModelState)
{
cout << " " << "This movie does not exist" << '\n';
cout << "\n\n" << " " << "Press 'r' to retry, 'p' to Previous ,'m' to Main menu , and 'q' to Quit";
cout << "\n " << "Your Choice? : ";
}
else if(success)
{
cout << " " << "The record was successfully removed." << '\n';
cout << "\n\n" << " " << "Press 'r' to retry, 'p' to Previous ,'m' to Main menu , and 'q' to Quit";
cout << "\n " << "Your Choice? : ";
}
else
{
cout << " " << string(15, '-') << '\n';
cout << " " << "Remove a movie" << '\n';
cout << " " << string(15, '-') << "\n" << "\n";
cout << " " << "a.By Name " << '\n';
cout << " " << "b.By ID " << '\n';
cout << "\n " << "Your Choice? : ";
}
}
void MovieView::RemoveMovie(int movieId)
{
cout << " " << "Add you sure you want to delete 'movie "<<movieId<<"'(Y/N)? " << '\n';
}
void MovieView::RemoveMovie(const string& movieName)
{
cout << " " << "Add you sure you want to delete '" << movieName << "'(Y/N)? " << '\n';
}
| [
"[email protected]"
] | |
408e80de62ab574b9ce24bed79874fd52f9e35d3 | 31ec06f110652ed5fb9a5b18e6866c6680010ba9 | /include/fabrique/platform/files.hh | 9ca2380d013f89e56a884b5d428e31bcfdf8cf9f | [
"BSD-2-Clause"
] | permissive | fabriquer/fabrique | fea63652b6e700274ebcdf6b66011f4850513b5a | d141ef698ddbeddb5b800f7f906d93751a06f809 | refs/heads/master | 2020-04-12T06:33:34.305435 | 2019-07-17T19:29:59 | 2019-07-17T19:29:59 | 13,753,419 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,269 | hh | //! @file platform/files.h Declarations of OS-specific file/path functions
/*
* Copyright (c) 2014, 2018 Jonathan Anderson
* All rights reserved.
*
* This software was developed by SRI International and the University of
* Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
* ("CTSRD"), as part of the DARPA CRASH research programme and at Memorial University
* of Newfoundland under the NSERC Discovery program (RGPIN-2015-06048).
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef FAB_PLATFORM_FILES_H_
#define FAB_PLATFORM_FILES_H_
#include <functional>
#include <string>
#include <vector>
namespace fabrique {
namespace platform {
//
// File- and path-related predicates:
//
//! Check whether a file is executable on this platform.
bool FileIsExecutable(std::string path);
//! Test whether this platform can load a file as a shared library.
bool FileIsSharedLibrary(std::string path);
//! The named path is absolute, whether or not the file actually exists.
bool PathIsAbsolute(const std::string&);
//! Does the named path exist, and is it a directory?
bool PathIsDirectory(std::string);
//! Does the named path exist, and is it a regular file?
bool PathIsFile(std::string);
//
// Other file- and path-related functions that might be used as arguments:
//
typedef std::function<std::string (std::string, const std::vector<std::string>&)>
MissingFileReporter;
//! Create a @ref std::function that returns a default filename.
MissingFileReporter DefaultFilename(std::string name = "");
//! Throw a @ref UserError to report a missing file.
std::string FileNotFound(std::string name, const std::vector<std::string>& searchPaths);
//
// Filename and path manipulation:
//
//! Find the absolute version of a directory, optionally creating it.
std::string AbsoluteDirectory(std::string name, bool createIfMissing = false);
//! Find the absolute version of a path (file or directory).
std::string AbsolutePath(std::string path);
//! Get the basename of a path: 'foo/bar.c' -> 'bar'.
std::string BaseName(std::string path);
//! The command required to create a directory (if it doesn't already exist).
std::string CreateDirCommand(std::string directory);
//! Find the directory containing a file, optionally returning an absolute path.
std::string DirectoryOf(std::string filename, bool absolute = false);
//! Get the extension of a path: 'foo/bar.c' -> 'c'.
std::string FileExtension(std::string path);
//! Find the non-directory component of a path.
std::string FilenameComponent(std::string pathIncludingDirectory);
//! Search the current PATH (as well as @b extraPaths) for an executable file.
std::string FindExecutable(std::string name,
std::vector<std::string> extraPaths = std::vector<std::string>(),
MissingFileReporter report = FileNotFound);
/**
* Find a file named @a filename within a set of @a directories.
*
* @param test A test to invoke on each file (e.g., PathIsFile, FileIsExecutable)
* in order to confirm the applicability of a file.
* @param report A function to call if the file is not found.
*/
std::string FindFile(std::string filename, const std::vector<std::string>& directories,
std::function<bool (const std::string&)> test = PathIsFile,
MissingFileReporter report = FileNotFound);
//! Join two path components (a directory and a filename).
std::string JoinPath(const std::string&, const std::string&);
//! Join an arbitrary number of path components (directories and maybe a filename).
std::string JoinPath(const std::vector<std::string>&);
//! Convert a library name (e.g., "foo") into a filename (e.g., "libfoo.so").
std::string LibraryFilename(std::string name);
/**
* Where are plugins kept on this platform?
*
* @param executablePath absolute path to Fabrique executable file
*/
std::vector<std::string> PluginSearchPaths(std::string executablePath);
} // namespace platform
} // namespace fabrique
#endif // FAB_PLATFORM_FILES_H_
| [
"[email protected]"
] | |
cd1a0c0b425200e31b2de0424dc4c5a4715cc671 | 872ea7a4f4acd919064a6651ee2c43965b0e5909 | /chap07/Sales_data.h | b14b91071f5143d8c9315db4138bb8144a4b987d | [] | no_license | biggreyhairboy/Cpp_Primer_5th_ex | 9b289af402aed60ada6e3e68f090e835f0ef07af | 444ae3d4991070848721c4aa12f44aa93e7aecd6 | refs/heads/master | 2020-08-06T22:05:17.279070 | 2019-10-06T09:45:33 | 2019-10-06T09:45:33 | 213,174,680 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 624 | h | #ifndef SALES_DATA_H
#define SALES_DATA_H
#include <string>
#include <iostream>
using namespace std;
struct Sales_data;
istream &read(istream &is, Sales_data &item);
ostream &print(ostream &os, Sales_data &item);
struct Sales_data{
Sales_data() = default;
Sales_data(const string &isbn, const unsigned quantity, double price);
Sales_data(istream &is);
Sales_data & combine(const Sales_data &arecord);
Sales_data add(const Sales_data &item1, const Sales_data &item2);
inline double avg_price(){ return revenue / quantity; };
const std::string isbn();
std::string ISBN;
unsigned quantity;
double revenue;
};
#endif
| [
"[email protected]"
] | |
62f19e5c5464bb2e46b0409937df559750f8b88b | 2c00b4fe0aca9ac7e45329349636fd32cbe3cbf4 | /29. Divide Two Integers.cpp | d2c7cc781272841c148aef78f4325c36b020ce32 | [] | no_license | akanarika/CLeetcode | ceb0d7e91d76d91f68c5f550cd160ce19f0b012d | 1bb07d755daeaca24aa8eec3774cdbf35fb297f1 | refs/heads/master | 2020-12-30T13:23:36.349511 | 2020-08-27T20:31:14 | 2020-08-27T20:31:14 | 91,202,901 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 541 | cpp | class Solution {
public:
int divide(int dividend, int divisor) {
if (dividend == INT_MIN && divisor == -1) return INT_MAX;
long dd = labs(dividend);
long dr = labs(divisor);
long res = 0;
while (dd >= dr) {
long curr = dr;
int i = 0;
while ((curr << 1) < dd) {
curr <<= 1;
i++;
}
dd = dd - curr;
res += (1 << i);
}
return (dividend > 0) ^ (divisor > 0) ? -res : res;
}
};
| [
"[email protected]"
] | |
eb99f561217ff76c3cb150d27b2f623a94fd77f2 | 29308ff52dabb614896bccca1c6d90f22dc7b4b2 | /src/rpc/server.cpp | 9b820692b85fb77fad4aaef5c06745ad2bbd1f31 | [
"MIT"
] | permissive | 631250005/astral | 3d95bdfd32cd215c24a128183ae07a9416c73383 | a88fca12413879ed70058d91e2d53a0faf4719c3 | refs/heads/master | 2021-10-02T04:07:14.997718 | 2018-11-29T02:23:04 | 2018-11-29T02:23:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,765 | cpp | // Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Copyright (c) 2017 The Astral Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "rpc/server.h"
#include "base58.h"
#include "fs.h"
#include "init.h"
#include "random.h"
#include "sync.h"
#include "ui_interface.h"
#include "util.h"
#include "utilstrencodings.h"
#include "mining.h"
#include <univalue.h>
#include <boost/bind.hpp>
#include <boost/signals2/signal.hpp>
#include <boost/algorithm/string/case_conv.hpp> // for to_upper()
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>
#include <memory> // for unique_ptr
#include <unordered_map>
#include "assets/assets.h"
static bool fRPCRunning = false;
static bool fRPCInWarmup = true;
static std::string rpcWarmupStatus("RPC server started");
static CCriticalSection cs_rpcWarmup;
/* Timer-creating functions */
static RPCTimerInterface* timerInterface = nullptr;
/* Map of name to timer. */
static std::map<std::string, std::unique_ptr<RPCTimerBase> > deadlineTimers;
static struct CRPCSignals
{
boost::signals2::signal<void ()> Started;
boost::signals2::signal<void ()> Stopped;
boost::signals2::signal<void (const CRPCCommand&)> PreCommand;
} g_rpcSignals;
void RPCServer::OnStarted(std::function<void ()> slot)
{
g_rpcSignals.Started.connect(slot);
}
void RPCServer::OnStopped(std::function<void ()> slot)
{
g_rpcSignals.Stopped.connect(slot);
}
void RPCTypeCheck(const UniValue& params,
const std::list<UniValue::VType>& typesExpected,
bool fAllowNull)
{
unsigned int i = 0;
for (UniValue::VType t : typesExpected)
{
if (params.size() <= i)
break;
const UniValue& v = params[i];
if (!(fAllowNull && v.isNull())) {
RPCTypeCheckArgument(v, t);
}
i++;
}
}
void RPCTypeCheckArgument(const UniValue& value, UniValue::VType typeExpected)
{
if (value.type() != typeExpected) {
throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Expected type %s, got %s", uvTypeName(typeExpected), uvTypeName(value.type())));
}
}
void RPCTypeCheckObj(const UniValue& o,
const std::map<std::string, UniValueType>& typesExpected,
bool fAllowNull,
bool fStrict)
{
for (const auto& t : typesExpected) {
const UniValue& v = find_value(o, t.first);
if (!fAllowNull && v.isNull())
throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Missing %s", t.first));
if (!(t.second.typeAny || v.type() == t.second.type || (fAllowNull && v.isNull()))) {
std::string err = strprintf("Expected type %s for %s, got %s",
uvTypeName(t.second.type), t.first, uvTypeName(v.type()));
throw JSONRPCError(RPC_TYPE_ERROR, err);
}
}
if (fStrict)
{
for (const std::string& k : o.getKeys())
{
if (typesExpected.count(k) == 0)
{
std::string err = strprintf("Unexpected key %s", k);
throw JSONRPCError(RPC_TYPE_ERROR, err);
}
}
}
}
CAmount AmountFromValue(const UniValue& value)
{
if (!value.isNum() && !value.isStr())
throw JSONRPCError(RPC_TYPE_ERROR, "Amount is not a number or string");
CAmount amount;
if (!ParseFixedPoint(value.getValStr(), 8, &amount))
throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount");
if (!MoneyRange(amount))
throw JSONRPCError(RPC_TYPE_ERROR, "Amount out of range");
return amount;
}
uint256 ParseHashV(const UniValue& v, std::string strName)
{
std::string strHex;
if (v.isStr())
strHex = v.get_str();
if (!IsHex(strHex)) // Note: IsHex("") is false
throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
if (64 != strHex.length())
throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("%s must be of length %d (not %d)", strName, 64, strHex.length()));
uint256 result;
result.SetHex(strHex);
return result;
}
uint256 ParseHashO(const UniValue& o, std::string strKey)
{
return ParseHashV(find_value(o, strKey), strKey);
}
std::vector<unsigned char> ParseHexV(const UniValue& v, std::string strName)
{
std::string strHex;
if (v.isStr())
strHex = v.get_str();
if (!IsHex(strHex))
throw JSONRPCError(RPC_INVALID_PARAMETER, strName+" must be hexadecimal string (not '"+strHex+"')");
return ParseHex(strHex);
}
std::vector<unsigned char> ParseHexO(const UniValue& o, std::string strKey)
{
return ParseHexV(find_value(o, strKey), strKey);
}
/**
* Note: This interface may still be subject to change.
*/
std::string CRPCTable::help(const std::string& strCommand, const JSONRPCRequest& helpreq) const
{
std::string strRet;
std::string category;
std::set<rpcfn_type> setDone;
std::vector<std::pair<std::string, const CRPCCommand*> > vCommands;
for (std::map<std::string, const CRPCCommand*>::const_iterator mi = mapCommands.begin(); mi != mapCommands.end(); ++mi)
vCommands.push_back(make_pair(mi->second->category + mi->first, mi->second));
sort(vCommands.begin(), vCommands.end());
JSONRPCRequest jreq(helpreq);
jreq.fHelp = true;
jreq.params = UniValue();
for (const std::pair<std::string, const CRPCCommand*>& command : vCommands)
{
const CRPCCommand *pcmd = command.second;
std::string strMethod = pcmd->name;
if ((strCommand != "" || pcmd->category == "hidden") && strMethod != strCommand)
continue;
jreq.strMethod = strMethod;
try
{
rpcfn_type pfn = pcmd->actor;
if (setDone.insert(pfn).second)
(*pfn)(jreq);
}
catch (const std::exception& e)
{
// Help text is returned in an exception
std::string strHelp = std::string(e.what());
if (strCommand == "")
{
if (strHelp.find('\n') != std::string::npos)
strHelp = strHelp.substr(0, strHelp.find('\n'));
if (category != pcmd->category)
{
if (!category.empty())
strRet += "\n";
category = pcmd->category;
std::string firstLetter = category.substr(0,1);
boost::to_upper(firstLetter);
strRet += "== " + firstLetter + category.substr(1) + " ==\n";
}
}
strRet += strHelp + "\n";
}
}
if (strRet == "")
strRet = strprintf("help: unknown command: %s\n", strCommand);
strRet = strRet.substr(0,strRet.size()-1);
return strRet;
}
UniValue help(const JSONRPCRequest& jsonRequest)
{
if (jsonRequest.fHelp || jsonRequest.params.size() > 1)
throw std::runtime_error(
"help ( \"command\" )\n"
"\nList all commands, or get help for a specified command.\n"
"\nArguments:\n"
"1. \"command\" (string, optional) The command to get help on\n"
"\nResult:\n"
"\"text\" (string) The help text\n"
);
std::string strCommand;
if (jsonRequest.params.size() > 0)
strCommand = jsonRequest.params[0].get_str();
return tableRPC.help(strCommand, jsonRequest);
}
UniValue stop(const JSONRPCRequest& jsonRequest)
{
// Accept the deprecated and ignored 'detach' boolean argument
if (jsonRequest.fHelp || jsonRequest.params.size() > 1)
throw std::runtime_error(
"stop\n"
"\nStop Astral server.");
// Event loop will exit after current HTTP requests have been handled, so
// this reply will get back to the client.
StartShutdown();
return "Astral server stopping";
}
UniValue uptime(const JSONRPCRequest& jsonRequest)
{
if (jsonRequest.fHelp || jsonRequest.params.size() > 1)
throw std::runtime_error(
"uptime\n"
"\nReturns the total uptime of the server.\n"
"\nResult:\n"
"ttt (numeric) The number of seconds that the server has been running\n"
"\nExamples:\n"
+ HelpExampleCli("uptime", "")
+ HelpExampleRpc("uptime", "")
);
return GetTime() - GetStartupTime();
}
/**
* Call Table
*/
static const CRPCCommand vRPCCommands[] =
{ // category name actor (function) argNames
// --------------------- ------------------------ ----------------------- ----------
/* Overall control/query calls */
{ "control", "help", &help, {"command"} },
{ "control", "stop", &stop, {} },
{ "control", "uptime", &uptime, {} },
};
CRPCTable::CRPCTable()
{
unsigned int vcidx;
for (vcidx = 0; vcidx < (sizeof(vRPCCommands) / sizeof(vRPCCommands[0])); vcidx++)
{
const CRPCCommand *pcmd;
pcmd = &vRPCCommands[vcidx];
mapCommands[pcmd->name] = pcmd;
}
}
const CRPCCommand *CRPCTable::operator[](const std::string &name) const
{
std::map<std::string, const CRPCCommand*>::const_iterator it = mapCommands.find(name);
if (it == mapCommands.end())
return nullptr;
return (*it).second;
}
bool CRPCTable::appendCommand(const std::string& name, const CRPCCommand* pcmd)
{
if (IsRPCRunning())
return false;
// don't allow overwriting for now
std::map<std::string, const CRPCCommand*>::const_iterator it = mapCommands.find(name);
if (it != mapCommands.end())
return false;
mapCommands[name] = pcmd;
return true;
}
bool StartRPC()
{
LogPrint(BCLog::RPC, "Starting RPC\n");
fRPCRunning = true;
g_rpcSignals.Started();
return true;
}
void InterruptRPC()
{
LogPrint(BCLog::RPC, "Interrupting RPC\n");
// Interrupt e.g. running longpolls
fRPCRunning = false;
}
void StopRPC()
{
LogPrint(BCLog::RPC, "Stopping RPC\n");
deadlineTimers.clear();
DeleteAuthCookie();
g_rpcSignals.Stopped();
}
bool IsRPCRunning()
{
return fRPCRunning;
}
void SetRPCWarmupStatus(const std::string& newStatus)
{
LOCK(cs_rpcWarmup);
rpcWarmupStatus = newStatus;
}
void SetRPCWarmupFinished()
{
LOCK(cs_rpcWarmup);
assert(fRPCInWarmup);
fRPCInWarmup = false;
}
bool RPCIsInWarmup(std::string *outStatus)
{
LOCK(cs_rpcWarmup);
if (outStatus)
*outStatus = rpcWarmupStatus;
return fRPCInWarmup;
}
void JSONRPCRequest::parse(const UniValue& valRequest)
{
// Parse request
if (!valRequest.isObject())
throw JSONRPCError(RPC_INVALID_REQUEST, "Invalid Request object");
const UniValue& request = valRequest.get_obj();
// Parse id now so errors from here on will have the id
id = find_value(request, "id");
// Parse method
UniValue valMethod = find_value(request, "method");
if (valMethod.isNull())
throw JSONRPCError(RPC_INVALID_REQUEST, "Missing method");
if (!valMethod.isStr())
throw JSONRPCError(RPC_INVALID_REQUEST, "Method must be a string");
strMethod = valMethod.get_str();
LogPrint(BCLog::RPC, "ThreadRPCServer method=%s\n", SanitizeString(strMethod));
// Parse params
UniValue valParams = find_value(request, "params");
if (valParams.isArray() || valParams.isObject())
params = valParams;
else if (valParams.isNull())
params = UniValue(UniValue::VARR);
else
throw JSONRPCError(RPC_INVALID_REQUEST, "Params must be an array or object");
}
bool IsDeprecatedRPCEnabled(const std::string& method)
{
const std::vector<std::string> enabled_methods = gArgs.GetArgs("-deprecatedrpc");
return find(enabled_methods.begin(), enabled_methods.end(), method) != enabled_methods.end();
}
static UniValue JSONRPCExecOne(JSONRPCRequest jreq, const UniValue& req)
{
UniValue rpc_result(UniValue::VOBJ);
try {
jreq.parse(req);
UniValue result = tableRPC.execute(jreq);
rpc_result = JSONRPCReplyObj(result, NullUniValue, jreq.id);
}
catch (const UniValue& objError)
{
rpc_result = JSONRPCReplyObj(NullUniValue, objError, jreq.id);
}
catch (const std::exception& e)
{
rpc_result = JSONRPCReplyObj(NullUniValue,
JSONRPCError(RPC_PARSE_ERROR, e.what()), jreq.id);
}
return rpc_result;
}
std::string JSONRPCExecBatch(const JSONRPCRequest& jreq, const UniValue& vReq)
{
UniValue ret(UniValue::VARR);
for (unsigned int reqIdx = 0; reqIdx < vReq.size(); reqIdx++)
ret.push_back(JSONRPCExecOne(jreq, vReq[reqIdx]));
return ret.write() + "\n";
}
/**
* Process named arguments into a vector of positional arguments, based on the
* passed-in specification for the RPC call's arguments.
*/
static inline JSONRPCRequest transformNamedArguments(const JSONRPCRequest& in, const std::vector<std::string>& argNames)
{
JSONRPCRequest out = in;
out.params = UniValue(UniValue::VARR);
// Build a map of parameters, and remove ones that have been processed, so that we can throw a focused error if
// there is an unknown one.
const std::vector<std::string>& keys = in.params.getKeys();
const std::vector<UniValue>& values = in.params.getValues();
std::unordered_map<std::string, const UniValue*> argsIn;
for (size_t i=0; i<keys.size(); ++i) {
argsIn[keys[i]] = &values[i];
}
// Process expected parameters.
int hole = 0;
for (const std::string &argNamePattern: argNames) {
std::vector<std::string> vargNames;
boost::algorithm::split(vargNames, argNamePattern, boost::algorithm::is_any_of("|"));
auto fr = argsIn.end();
for (const std::string & argName : vargNames) {
fr = argsIn.find(argName);
if (fr != argsIn.end()) {
break;
}
}
if (fr != argsIn.end()) {
for (int i = 0; i < hole; ++i) {
// Fill hole between specified parameters with JSON nulls,
// but not at the end (for backwards compatibility with calls
// that act based on number of specified parameters).
out.params.push_back(UniValue());
}
hole = 0;
out.params.push_back(*fr->second);
argsIn.erase(fr);
} else {
hole += 1;
}
}
// If there are still arguments in the argsIn map, this is an error.
if (!argsIn.empty()) {
throw JSONRPCError(RPC_INVALID_PARAMETER, "Unknown named parameter " + argsIn.begin()->first);
}
// Return request with named arguments transformed to positional arguments
return out;
}
UniValue CRPCTable::execute(const JSONRPCRequest &request) const
{
// Return immediately if in warmup
{
LOCK(cs_rpcWarmup);
if (fRPCInWarmup)
throw JSONRPCError(RPC_IN_WARMUP, rpcWarmupStatus);
}
// Find method
const CRPCCommand *pcmd = tableRPC[request.strMethod];
if (!pcmd)
throw JSONRPCError(RPC_METHOD_NOT_FOUND, "Method not found");
g_rpcSignals.PreCommand(*pcmd);
try
{
// Execute, convert arguments to array if necessary
if (request.params.isObject()) {
return pcmd->actor(transformNamedArguments(request, pcmd->argNames));
} else {
return pcmd->actor(request);
}
}
catch (const std::exception& e)
{
throw JSONRPCError(RPC_MISC_ERROR, e.what());
}
}
std::vector<std::string> CRPCTable::listCommands() const
{
std::vector<std::string> commandList;
typedef std::map<std::string, const CRPCCommand*> commandMap;
std::transform( mapCommands.begin(), mapCommands.end(),
std::back_inserter(commandList),
boost::bind(&commandMap::value_type::first,_1) );
return commandList;
}
std::string HelpExampleCli(const std::string& methodname, const std::string& args)
{
return "> astral-cli " + methodname + " " + args + "\n";
}
std::string HelpExampleRpc(const std::string& methodname, const std::string& args)
{
return "> curl --user myusername --data-binary '{\"jsonrpc\": \"1.0\", \"id\":\"curltest\", "
"\"method\": \"" + methodname + "\", \"params\": [" + args + "] }' -H 'content-type: text/plain;' http://127.0.0.1:8290/\n";
}
void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface)
{
if (!timerInterface)
timerInterface = iface;
}
void RPCSetTimerInterface(RPCTimerInterface *iface)
{
timerInterface = iface;
}
void RPCUnsetTimerInterface(RPCTimerInterface *iface)
{
if (timerInterface == iface)
timerInterface = nullptr;
}
void RPCRunLater(const std::string& name, std::function<void(void)> func, int64_t nSeconds)
{
if (!timerInterface)
throw JSONRPCError(RPC_INTERNAL_ERROR, "No timer handler registered for RPC");
deadlineTimers.erase(name);
LogPrint(BCLog::RPC, "queue run of timer %s in %i seconds (using %s)\n", name, nSeconds, timerInterface->Name());
deadlineTimers.emplace(name, std::unique_ptr<RPCTimerBase>(timerInterface->NewTimer(func, nSeconds*1000)));
}
int RPCSerializationFlags()
{
int flag = 0;
if (gArgs.GetArg("-rpcserialversion", DEFAULT_RPC_SERIALIZE_VERSION) == 0)
flag |= SERIALIZE_TRANSACTION_NO_WITNESS;
return flag;
}
CRPCTable tableRPC;
| [
"[email protected]"
] | |
0e0cb7fac3062f65aaca1f4d8a3b7f08248be28e | e6d2c3e0c9924f65a2b09af45caaf7aa35a2b467 | /OOP01.cpp | fb8f62925cb0cedbe279f82a37674ed5f0c741df | [] | no_license | totoguri/practiceCplus | c749579dcb97c32e7531df97e77614641d97d2dd | c8869b1b9c9d01a5c0ea7f0dcac63ac9548730d2 | refs/heads/main | 2023-07-26T00:03:29.985771 | 2021-09-13T00:07:18 | 2021-09-13T00:07:18 | 405,780,503 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 3,328 | cpp | //#include <iostream>
//using std::cout;
//using std::cin;
//using std::endl;
//
//typedef struct person {
// int id; // 4 numbers
// char customer[20];
// int finance;
//} Person;
//
//void AccMake(void);
//void AccPut(void);
//void AccWith(void);
//void AccShow(void);
//
//Person man[100];
//int accNum = 0;
//
//int main(void) {
// int num=0;
//
// while (num!=5) {
// cout << "-----Menu-----" << endl;
// cout << "1. 계좌 개설" << endl;
// cout << "2. 입금" << endl;
// cout << "3. 출금" << endl;
// cout << "4. 계좌 정보 전체 출력" << endl;
// cout << "5. 프로그램 종료" << endl;
// cout << endl;
// cout << "선택: ";
// cin >> num;
// cout << endl;
//
// switch (num) {
// case 1:
// cout << "[계좌 개설]" << endl;
// cout << endl;
// AccMake();
// cout << endl;
// break;
// case 2:
// if (accNum == 0) {
// cout << "먼저 계좌를 만들어 주세요." << endl;
// break;
// }
// cout << "[입금]" << endl;
// cout << endl;
// AccPut();
// cout << endl;
// break;
// case 3:
// if (accNum == 0) {
// cout << "먼저 계좌를 만들어 주세요." << endl;
// break;
// }
// cout << "[출금]" << endl;
// cout << endl;
// AccWith();
// cout << endl;
// break;
// case 4:
// if (accNum == 0) {
// cout << "먼저 계좌를 만들어 주세요." << endl;
// break;
// }
// cout << "[계좌 정보]" << endl;
// cout << endl;
// AccShow();
// cout << endl;
// break;
// case 5:
// cout << "<<<<업무 종료>>>>" << endl;
// cout << endl;
// break;
// }
// }
//}
//
//void AccMake(void) {
// int id;
// char name[20];
// int finance;
//
// cout << "계좌ID: ";
// cin >> id;
// cout << "이 름: ";
// cin >> name;
// cout << "입금액: ";
// cin >> finance;
//
// man[accNum].id = id;
// strcpy_s(man[accNum].customer, name);
// man[accNum].finance = finance;
//
// accNum++;
//}
//
//void AccPut(void) {
// int id;
// int finance;
//
// while (true) {
// int i;
// cout << "계좌ID: ";
// cin >> id;
//
// for (i = 0; i < accNum; i++) {
// if (man[i].id == id) {
// cout << "입금액: ";
// cin >> finance;
// cout << "입금 완료" << endl;
//
// man[i].finance += finance;
// break;
// }
// }
// if (man[i].id == id)
// return;
// else
// cout << "==잘못된 계좌ID--" << endl;
// cout << endl;
// }
//}
//
//void AccWith(void) {
// int id;
// int finance;
//
// while (true) {
// int i;
// int finance = 0;
// cout << "계좌ID: ";
// cin >> id;
//
// for (i = 0; i < accNum; i++) {
// if (man[i].id == id) {
// do {
// if (man[i].finance < finance) {
// cout << "잔액 부족" << endl;
// cout << endl;
// }
// cout << "출금액: ";
// cin >> finance;
//
// } while (man[i].finance < finance);
//
// cout << "출금 완료" << endl;
//
// man[i].finance -= finance;
// return;
// }
// }
// if (man[i].id == id)
// return;
// else
// cout << "--잘못된 계좌ID--" << endl;
// cout << endl;
// }
//}
//
//void AccShow(void) {
// for (int i = 0; i < accNum; i++) {
// cout << "----[" << i+1 << "]----" << endl;
// cout << "계좌ID: " << man[i].id << endl;
// cout << "이름: " << man[i].customer << endl;
// cout << "잔액: " << man[i].finance << endl;
// cout << endl;
// }
//} | [
"[email protected]"
] | |
232ff67a071d0bd289e7214b5ed31280bc4668c9 | eb731b40f0a75f9c07f28b2c458a175f5623f6ff | /ESP8266MOD/Blink/Blink.ino | f327050ce5a2e945c81c54a3a7e5e4a5905c51b6 | [] | no_license | Rr42/Arduino | c3016c1c1ed28debb550ae9763de63cd51fe1793 | daa3c5d547bcbb80cfb53f525e42fc6d0040bdbf | refs/heads/master | 2020-03-26T15:57:31.997424 | 2018-08-17T06:40:34 | 2018-08-17T06:40:34 | 145,073,828 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 560 | ino | int led = LED_BUILTIN;
void setup() {
Serial.begin(9600);
pinMode(led,OUTPUT);//LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(led, LOW); // Turn the LED on (Note that LOW is the voltage level
// but actually the LED is on; this is because
// it is acive low on the ESP-01)
Serial.println(led);
delay(200);
digitalWrite(led, HIGH); // Turn the LED off by making the voltage HIGH
delay(100);
}
| [
"[email protected]"
] | |
2b900395b063ab157f905f4f6f02bf47c277ee63 | 3122985c6975895dc2fc3e78e575f57268674f07 | /Sensors Interfacing and Serial Debugging.ino | 8e55e8cd6ba1b06f13c899ebb526d709d0539d6a | [] | no_license | karthickcj/Smart-Garbage-Monitoring-System-Using-IoT | a7919d2162fdc45b95a1fb18e607d560542eaf73 | 1a477200d9dadbf438aa88b8e9e46f60394f1c19 | refs/heads/master | 2021-09-10T12:30:20.530451 | 2018-03-26T09:43:25 | 2018-03-26T09:43:25 | 125,800,250 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,297 | ino | #include <OneWire.h>
#include <DallasTemperature.h>
/********************************************Ultrasonic sensors******************************************************
Esp8266 GPIO pin 12 connected to Echo Pin of HC-SR04
Esp8266 GPIO pin 14 connected to Trigger pin of HC-SR04
Since echo output is 5v
We have coonected a 2.2K resistor to it then a 4.7K Resistor
4.7K resistor is grounded
The signal is taken out from the junction of the two resistor
*********************************************************************************************************************/
#define echoPin 12 // Echo Pin
#define trigPin 14 // Trigger Pin
long duration, distance; // Duration used to calculate distance
/********************************************DS18B20 Digital Temperature Sensor***************************************
<OneWire.h> and <DallasTemperature.h> Library required for DS18B20
DS18B20 Data wire is plugged into GPIOpin 2 on the Esp8266
*********************************************************************************************************************/
#define ONE_WIRE_BUS 2
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
// Assign the unique addresses of your 1-Wire temp sensors
DeviceAddress insideThermometer = { 0x28, 0xFF, 0x2B, 0x09, 0x16, 0x15, 0x03, 0x39 };
float temp_c=0.0; // Values read from Temperature sensor
void getTemperature(DeviceAddress deviceAddress)
{
sensors.requestTemperatures();
temp_c = sensors.getTempC(deviceAddress);
if (temp_c == -127.00) {
temp_c=0.0;
Serial.println("Error getting temperature");
}
else {
Serial.print("Inside temperature is: ");
Serial.print(temp_c);
Serial.print( char(176));
Serial.println("C."); }
}
void getGarbageLevel(void)
{
/********************************************Ultrasonic sensors******************************************************
Speed of sound = 340 m/s
Now, 1 metre = 100 centimetre and 1 seconds = 1000000 microseconds
Speed of sound = 340 * 100 cm/(1000000 microseconds) = 0.034 cm per us = (1/29.412) cm per us
The Ultrasonic burst travels out & back.So to we have to divide the time the echo pin was high by 2
Distance = (Time echo pin was high/2) * speed of sound
= (Time echo pin was high/2) * (1/29.412)
= (Time echo pin was high/58.82)
*********************************************************************************************************************/
digitalWrite(trigPin, LOW); // Give a short LOW pulse beforehand to ensure a clean HIGH pulse
delayMicroseconds(2);
digitalWrite(trigPin, HIGH); // The sensor is triggered by a HIGH pulse of 10 or more microseconds.
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
/**************************************************************
Read the signal from the sensor (Echo pin): a HIGH pulse whose duration is the time (in microseconds) from the sending
of the ping to the reception of its echo off of an object.
pulseIn function reads a pulse (either HIGH or LOW) on a pin. For example, if value is HIGH, pulseIn() waits for the pin
to go HIGH, starts timing, then waits for the pin to go LOW and stops timing. Returns the length of the pulse in microseconds
or 0 if no complete pulse was received within the timeout.
Works on pulses from 10 microseconds to 3 minutes in length. Please also note that if the pin is already high when the function
is called, it will wait for the pin to go LOW and then HIGH before it starts counting.
**************************************************************/
duration = pulseIn(echoPin, HIGH);
//Calculate the distance (in cm) based on the speed of sound.
distance = duration/58.82;
Serial.print("Garbage Level: ");
Serial.print(distance);
Serial.println("cm");
}
void setup()
{
Serial.begin (115200);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
// Start up the library
sensors.begin();
// set the resolution to 10 bit (good enough?)
sensors.setResolution(insideThermometer, 12);
}
void loop()
{
getGarbageLevel();
getTemperature(insideThermometer);
//Delay 50ms before next reading.
delay(2500);
}
| [
"[email protected]"
] | |
7a85e7c97d611f600be260a7fbff055fb6737c66 | ff6fc0c94f564b61ecfad3864d3a2efd99d6199f | /tests/range_map_test.cc | c88a6c8259de7f44c2c439212d1466daf17bc72c | [
"Apache-2.0"
] | permissive | fjh658/bloaty | ef1ab082bd893fa069e225751d28e797a2b6c6b3 | 04e9a62d8a600e5626651bcc955ea855d9d10602 | refs/heads/master | 2021-04-30T12:12:44.693549 | 2018-01-26T01:03:59 | 2018-01-26T01:03:59 | 121,268,776 | 1 | 0 | null | 2018-02-12T16:06:59 | 2018-02-12T16:06:59 | null | UTF-8 | C++ | false | false | 10,295 | cc | // Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "bloaty.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <tuple>
namespace bloaty {
class RangeMapTest : public ::testing::Test {
protected:
void CheckConsistencyFor(const bloaty::RangeMap& map) {
uint64_t last_end = 0;
for (auto it = map.mappings_.begin(); it != map.mappings_.end(); ++it) {
ASSERT_GE(it->first, last_end);
last_end = map.RangeEnd(it);
}
}
void CheckConsistency() {
CheckConsistencyFor(map_);
CheckConsistencyFor(map2_);
CheckConsistencyFor(map3_);
}
struct Row {
std::vector<std::string> keys;
uint64_t start;
uint64_t end;
};
void AssertRollupEquals(const std::vector<const RangeMap*> maps,
const std::vector<Row>& rows) {
int i = 0;
RangeMap::ComputeRollup(
maps, [&i, &rows](const std::vector<std::string>& keys, uint64_t start,
uint64_t end) {
ASSERT_LT(i, rows.size());
const auto& row = rows[i];
ASSERT_EQ(row.keys, keys);
ASSERT_EQ(row.start, start);
ASSERT_EQ(row.end, end);
i++;
});
ASSERT_EQ(rows.size(), i);
}
struct Entry {
uint64_t addr;
uint64_t end;
uint64_t other_start;
std::string label;
};
void AssertMapEquals(const bloaty::RangeMap& map,
const std::vector<Entry>& entries) {
auto iter = map.mappings_.begin();
size_t i = 0;
for (; i < entries.size() && iter != map.mappings_.end(); ++i, ++iter) {
const auto& entry = entries[i];
ASSERT_EQ(entry.addr, iter->first) << i;
ASSERT_EQ(entry.end, map.RangeEnd(iter)) << i;
ASSERT_EQ(entry.other_start, iter->second.other_start) << i;
ASSERT_EQ(entry.label, iter->second.label) << i;
}
ASSERT_EQ(i, entries.size());
ASSERT_EQ(iter, map.mappings_.end());
// Also test that ComputeRollup yields the same thing.
i = 0;
RangeMap::ComputeRollup({&map},
[&i, &entries](const std::vector<std::string>& keys,
uint64_t start, uint64_t end) {
ASSERT_LT(i, entries.size());
const auto& entry = entries[i];
ASSERT_EQ(entry.addr, start);
ASSERT_EQ(entry.end, end);
ASSERT_EQ(entry.label, keys[0]);
i++;
});
ASSERT_EQ(entries.size(), i);
}
void AssertMainMapEquals(const std::vector<Entry>& entries) {
AssertMapEquals(map_, entries);
}
bloaty::RangeMap map_;
bloaty::RangeMap map2_;
bloaty::RangeMap map3_;
const uint64_t kNoTranslation = RangeMap::kNoTranslation;
const uint64_t kUnknownSize = RangeMap::kUnknownSize;
};
TEST_F(RangeMapTest, AddRange) {
CheckConsistency();
AssertMainMapEquals({});
map_.AddRange(4, 3, "foo");
CheckConsistency();
AssertMainMapEquals({
{4, 7, kNoTranslation, "foo"}
});
map_.AddRange(30, 5, "bar");
CheckConsistency();
AssertMainMapEquals({
{4, 7, kNoTranslation, "foo"},
{30, 35, kNoTranslation, "bar"}
});
map_.AddRange(50, 0, "baz"); // No-op due to 0 size.
CheckConsistency();
AssertMainMapEquals({
{4, 7, kNoTranslation, "foo"},
{30, 35, kNoTranslation, "bar"}
});
map_.AddRange(20, 5, "baz");
map_.AddRange(25, 5, "baz2");
map_.AddRange(40, 5, "quux");
CheckConsistency();
AssertMainMapEquals({
{4, 7, kNoTranslation, "foo"},
{20, 25, kNoTranslation, "baz"},
{25, 30, kNoTranslation, "baz2"},
{30, 35, kNoTranslation, "bar"},
{40, 45, kNoTranslation, "quux"}
});
map_.AddRange(21, 25, "overlapping");
CheckConsistency();
AssertMainMapEquals({
{4, 7, kNoTranslation, "foo"},
{20, 25, kNoTranslation, "baz"},
{25, 30, kNoTranslation, "baz2"},
{30, 35, kNoTranslation, "bar"},
{35, 40, kNoTranslation, "overlapping"},
{40, 45, kNoTranslation, "quux"},
{45, 46, kNoTranslation, "overlapping"}
});
map_.AddRange(21, 25, "overlapping no-op");
CheckConsistency();
AssertMainMapEquals({
{4, 7, kNoTranslation, "foo"},
{20, 25, kNoTranslation, "baz"},
{25, 30, kNoTranslation, "baz2"},
{30, 35, kNoTranslation, "bar"},
{35, 40, kNoTranslation, "overlapping"},
{40, 45, kNoTranslation, "quux"},
{45, 46, kNoTranslation, "overlapping"}
});
map_.AddRange(0, 100, "overlap everything");
CheckConsistency();
AssertMainMapEquals({
{0, 4, kNoTranslation, "overlap everything"},
{4, 7, kNoTranslation, "foo"},
{7, 20, kNoTranslation, "overlap everything"},
{20, 25, kNoTranslation, "baz"},
{25, 30, kNoTranslation, "baz2"},
{30, 35, kNoTranslation, "bar"},
{35, 40, kNoTranslation, "overlapping"},
{40, 45, kNoTranslation, "quux"},
{45, 46, kNoTranslation, "overlapping"},
{46, 100, kNoTranslation, "overlap everything"},
});
}
TEST_F(RangeMapTest, UnknownSize) {
map_.AddRange(5, kUnknownSize, "foo");
CheckConsistency();
AssertMainMapEquals({
{5, UINT64_MAX, kNoTranslation, "foo"}
});
map_.AddRange(100, 15, "bar");
map_.AddRange(200, kUnknownSize, "baz");
CheckConsistency();
AssertMainMapEquals({
{5, 100, kNoTranslation, "foo"},
{100, 115, kNoTranslation, "bar"},
{200, UINT64_MAX, kNoTranslation, "baz"}
});
map2_.AddRange(5, 110, "base0");
map2_.AddRange(200, 50, "base1");
AssertRollupEquals({&map2_, &map_}, {
{{"base0", "foo"}, 5, 100},
{{"base0", "bar"}, 100, 115},
{{"base1", "baz"}, 200, 250},
});
}
TEST_F(RangeMapTest, UnknownSize2) {
// This case is slightly weird, but we do consider the "100" below to be a
// hard fact even if the size is unknown, so the "[95, 105]: bar" range
// doesn't override it.
map_.AddRange(100, kUnknownSize, "foo");
map_.AddRange(95, 10, "bar");
AssertMainMapEquals({
{95, 100, kNoTranslation, "bar"},
{100, 105, kNoTranslation, "foo"},
});
}
TEST_F(RangeMapTest, UnknownSize3) {
map_.AddRange(100, kUnknownSize, "foo");
map_.AddRange(150, kUnknownSize, "bar");
// This tells us the ultimate size of "foo", and we keep the "foo" label even
// though the new label is "baz".
map_.AddRange(100, 100, "baz");
AssertMainMapEquals({
{100, 150, kNoTranslation, "foo"},
{150, 200, kNoTranslation, "bar"},
});
}
TEST_F(RangeMapTest, UnknownSize4) {
map_.AddRange(100, kUnknownSize, "foo");
map_.AddRange(150, 100, "bar");
// This tells us the ultimate size of "foo", and we keep the "foo" label even
// though the new label is "baz".
map_.AddRange(100, 100, "baz");
AssertMainMapEquals({
{100, 150, kNoTranslation, "foo"},
{150, 250, kNoTranslation, "bar"},
});
}
TEST_F(RangeMapTest, Bug1) {
map_.AddRange(100, 20, "foo");
map_.AddRange(120, 20, "bar");
map_.AddRange(100, 15, "baz");
AssertMainMapEquals({
{100, 120, kNoTranslation, "foo"},
{120, 140, kNoTranslation, "bar"},
});
}
TEST_F(RangeMapTest, Bug2) {
map_.AddRange(100, kUnknownSize, "foo");
map_.AddRange(200, 50, "bar");
map_.AddRange(150, 10, "baz");
AssertMainMapEquals({
{100, 150, kNoTranslation, "foo"},
{150, 160, kNoTranslation, "baz"},
{200, 250, kNoTranslation, "bar"},
});
}
TEST_F(RangeMapTest, Bug3) {
map_.AddRange(100, kUnknownSize, "foo");
map_.AddRange(200, kUnknownSize, "bar");
map_.AddRange(150, 10, "baz");
AssertMainMapEquals({
{100, 150, kNoTranslation, "foo"},
{150, 160, kNoTranslation, "baz"},
{200, UINT64_MAX, kNoTranslation, "bar"},
});
}
TEST_F(RangeMapTest, Translation) {
map_.AddDualRange(20, 5, 120, "foo");
CheckConsistency();
AssertMainMapEquals({
{20, 25, 120, "foo"}
});
map2_.AddRangeWithTranslation(15, 15, "translate me", map_, &map3_);
CheckConsistency();
AssertMapEquals(map2_, {
{15, 30, kNoTranslation, "translate me"}
});
AssertMapEquals(map3_, {
{120, 125, kNoTranslation, "translate me"}
});
map_.AddDualRange(1000, 30, 1100, "bar");
map2_.AddRangeWithTranslation(1000, 5, "translate me2", map_, &map3_);
AssertMapEquals(map2_, {
{15, 30, kNoTranslation, "translate me"},
{1000, 1005, kNoTranslation, "translate me2"}
});
AssertMapEquals(map3_, {
{120, 125, kNoTranslation, "translate me"},
{1100, 1105, kNoTranslation, "translate me2"}
});
}
TEST_F(RangeMapTest, Translation2) {
map_.AddRange(5, 5, "foo");
map_.AddDualRange(20, 5, 120, "bar");
map_.AddRange(25, 5, "baz");
map_.AddDualRange(30, 5, 130, "quux");
CheckConsistency();
AssertMainMapEquals({
{5, 10, kNoTranslation, "foo"},
{20, 25, 120, "bar"},
{25, 30, kNoTranslation, "baz"},
{30, 35, 130, "quux"}
});
map2_.AddRangeWithTranslation(0, 50, "translate me", map_, &map3_);
CheckConsistency();
AssertMapEquals(map2_, {
{0, 50, kNoTranslation, "translate me"}
});
AssertMapEquals(map3_, {
{120, 125, kNoTranslation, "translate me"},
{130, 135, kNoTranslation, "translate me"}
});
}
TEST_F(RangeMapTest, UnknownTranslation) {
map_.AddDualRange(20, 10, 120, "foo");
CheckConsistency();
AssertMainMapEquals({
{20, 30, 120, "foo"}
});
map2_.AddRangeWithTranslation(25, kUnknownSize, "translate me", map_, &map3_);
CheckConsistency();
AssertMapEquals(map2_, {
{25, UINT64_MAX, kNoTranslation, "translate me"}
});
AssertMapEquals(map3_, {
{125, UINT64_MAX, kNoTranslation, "translate me"}
});
map2_.AddRange(20, 10, "fallback");
AssertRollupEquals({&map_, &map2_}, {
{{"foo", "fallback"}, 20, 25},
{{"foo", "translate me"}, 25, 30},
});
}
} // namespace bloaty
| [
"[email protected]"
] | |
b05a7d40121eb6718e3b50d23229ca3ae4ebcca7 | d7a46a529c259264ec914e4bc23a5e1f2cc0a4e2 | /will/Matrix.cpp | 6b8c2683a404d1b09d286194e2ce4252c739971a | [] | no_license | zjysnow/cccc-lite | f23a4772aa1417b62f62521b0298974e8e93a6ce | 5c79c7025a8f1ee559cb7f5bcfe2df0572ef53fa | refs/heads/master | 2023-02-22T20:45:59.928407 | 2021-01-27T13:41:38 | 2021-01-27T13:41:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 28,971 | cpp | #include "Matrix.h"
#include "Random.h"
#include "VectorMath.h"
#include <cassert>
namespace will
{
//const realc Matrix::const_real_1 = 1;
//const realc Matrix::const_real_0 = 0;
//任意阶张量
//描述符最低为4维
Matrix::Matrix(const std::vector<int>& dim, DeviceType device_type, bool create_d)
{
if (device_type == DeviceType::GPU && CudaControl::getGlobalCudaType() == DeviceType::GPU)
{
shared_data_->setCudaAsCurrent();
}
resize(dim);
if (create_d)
{
d_this_ = std::make_shared<Matrix>(std::vector<int>{ 0, 0 }, getDeviceType(), false);
}
}
//4阶张量形式
Matrix::Matrix(int w, int h, int c, int n, DeviceType device_type) : Matrix(std::vector<int>{ w, h, c, n }, device_type)
{
}
//普通二维矩阵构造函数
//注意这样生成的矩阵在以张量形式处理时认为是4维张量，但是所有张量的row都是前面项的积
Matrix::Matrix(int m, int n, DeviceType device_type) : Matrix(std::vector<int>{ m, n }, device_type)
{
}
Matrix::Matrix(const std::vector<int>& dim, real* data, DeviceType device_type) : Matrix(std::vector<int>{ 0, 0 }, device_type)
{
data_ = data;
resize(dim);
}
//空矩阵，后期再调整
Matrix::Matrix(DeviceType device_type) : Matrix(std::vector<int>{ 0, 0 }, device_type)
{
}
Matrix Matrix::clone(DeviceType device_type) const
{
Matrix M(dim_, device_type);
copyData(*this, M);
return M;
}
Matrix Matrix::cloneShared() const
{
return *this;
}
Matrix Matrix::cloneSharedCol(int col) const
{
auto dim = dim_;
dim.back() = 1;
Matrix M(dim, getDeviceType());
M.shareData(*this, 0, col);
return M;
}
Matrix Matrix::autoShareClone(DeviceType device_type) const
{
if (device_type == getDeviceType())
{
return *this;
}
else
{
return clone(device_type);
}
}
Matrix& Matrix::d() const
{
if (d_this_->data_size_ != data_size_)
{
d_this_->resize(dim_);
}
return *d_this_;
}
//依据dim设置尺寸相关的参数，内部使用
//若dim中仅有一个元素，则相当于{1,1,1,n}
void Matrix::setDim(const std::vector<int>& dim)
{
dim_ = dim;
int dim_size = dim.size();
number_ = dim.back();
width_ = 1;
height_ = 1;
channel_ = 1;
data_size_ = 1;
row_ = 1;
for (int i = 0; i < dim_size; i++)
{
data_size_ *= int64_t(dim[i]);
if (i < dim_size - 1) { row_ *= dim[i]; }
if (i < dim_size - 3) { width_ *= dim[i]; }
if (i == dim_size - 3) { height_ = dim[i]; }
if (i == dim_size - 2) { channel_ = dim[i]; }
}
if (dim.size() <= 4)
{
CudaControl::setTensorDesc4D(tensor_desc(), width_, height_, channel_, number_);
}
else
{
CudaControl::setTensorDescND(tensor_desc(), dim);
}
}
int Matrix::coord2i(const std::vector<int>& c)
{
int r = 0;
int s = 1;
for (int i = 0; i < c.size(); i++)
{
r += c[i] * s;
s = s * dim_[i];
}
return r;
}
const std::vector<int>& Matrix::getDim() const
{
return dim_;
}
int Matrix::resize(int m, int n, bool reserve_data, bool force)
{
return resize(std::vector<int>{ m, n }, reserve_data, force);
}
int Matrix::resize(int w, int h, int c, int n, bool reserve_data, bool force)
{
return resize(std::vector<int>{ w, h, c, n }, reserve_data, force);
}
int Matrix::resize(const Matrix& X, bool reserve_data, bool force)
{
return resize(X.dim_, reserve_data, force);
}
int Matrix::resize(const std::vector<int>& dim, bool reserve_data, bool force)
{
setDim(dim);
//指针与共享指针不同时，则认为是数据不由自己管理，不分配空间，此时可能会有隐患
if (data() != shared_data_->data_)
{
return 2;
}
//空间不够或者强制则重新分配
if (shared_data_->data_ == nullptr || data_size_ > shared_data_->occupy_data_size_ || force)
{
//重新申请空间
shared_data_->resize(data_size_, reserve_data, force);
}
data_ = shared_data_->data_;
return 0;
}
int Matrix::resizeNumber(int n, bool reserve_data, bool force)
{
dim_.back() = n;
return resize(dim_, reserve_data, force);
}
int Matrix::resizeAndNumber(const std::vector<int>& dim, int n, bool reserve_data, bool force)
{
auto dim1 = dim;
dim1.back() = n;
return resize(dim1, reserve_data, force);
}
int Matrix::resizeKeepNumber(const std::vector<int>& dim, bool reserve_data, bool force)
{
auto dim1 = dim;
dim1.back() = number_;
return resize(dim1, reserve_data, force);
}
//输出矩阵内容
//注意这个实际上是按照内存顺序
void Matrix::print(FILE* fout) const
{
auto temp = dataMirrorCPU();
for (int p = 0; p < channel_ * number_; p++)
{
for (int h = 0; h < height_; h++)
{
for (int w = 0; w < width_; w++)
{
auto v = temp->data_[whcn2i(w, h, p, 0)];
fmt::print(fout, "{} ", realc(v));
}
fmt::print(fout, "\n");
}
fmt::print(fout, "\n");
}
}
//将矩阵当做向量，按照内存中的顺序依次输出
void Matrix::printAsVector(FILE* fout) const
{
auto temp = dataMirrorCPU();
for (int i = 0; i < data_size_; i++)
{
fmt::print(fout, "{} ", temp->data_[i]);
}
fmt::print(fout, "\n");
}
//按照矩阵输出，因为是列优先，故不是内存顺序
void Matrix::printAsMatrix(FILE* fout) const
{
auto temp = dataMirrorCPU();
for (int r = 0; r < row_; r++)
{
for (int c = 0; c < number_; c++)
{
auto v = temp->data_[mn2i(r, c)];
fmt::print(fout, "{} ", realc(v));
}
fmt::print(fout, "\n");
}
fmt::print(fout, "\n");
}
//int Matrix::save(SaveBuffer& buffer) const
//{
// auto temp = dataMirrorCPU();
// buffer.save(temp->data_, sizeof(real) * data_size_);
// return data_size_;
//}
//
//int Matrix::load(SaveBuffer& buffer)
//{
// auto temp = dataMirrorCPU(false);
// buffer.load(temp->data_, sizeof(real) * data_size_);
// copyDataPointer(DeviceType::CPU, temp->data_, getDeviceType(), getDataPointer(), data_size_);
// return data_size_;
//}
int64_t Matrix::save(void* buffer, int64_t size) const
{
return MatrixData::copy(getDeviceType(), getDataPointer(), DeviceType::CPU, (real*)buffer, std::min(data_size_, size));
}
int64_t Matrix::load(const void* buffer, int64_t size)
{
return MatrixData::copy(DeviceType::CPU, (real*)buffer, getDeviceType(), getDataPointer(), std::min(data_size_, size));
}
//int Matrix::save(const std::string filename)
//{
// SaveBuffer s;
// save(s);
// return s.writeToFile(filename);
//}
//
//int Matrix::load(const std::string filename)
//{
// SaveBuffer s;
// s.loadFromFile(filename);
// return load(s);
//}
//将外界的值复制到矩阵，参数指针必须指向Host内存！
void Matrix::copyDataInFromHost(real* src, int64_t size)
{
if (inGPU())
{
cudaMemcpy(data(), src, int(sizeof(real) * std::min(size, data_size_)), cudaMemcpyHostToDevice);
}
else
{
memcpy(data(), src, int(sizeof(real) * std::min(size, data_size_)));
}
}
//将矩阵的值复制到外界，参数指针必须指向Host内存！
void Matrix::copyDataOutToHost(real* dst, int64_t size)
{
if (inGPU())
{
cudaMemcpy(dst, data(), int(sizeof(real) * std::min(size, data_size_)), cudaMemcpyDeviceToHost);
}
else
{
memcpy(dst, data(), int(sizeof(real) * std::min(size, data_size_)));
}
}
//警告：乱用模式会受惩罚！
int64_t Matrix::copyDataPointer(const Matrix& A, const real* A_pointer, Matrix& R, real* R_pointer, int64_t size)
{
if (size < 0)
{
size = std::min(A.getDataSize(), R.getDataSize());
}
return MatrixData::copy(A.getDeviceType(), A_pointer, R.getDeviceType(), R_pointer, size);
}
//复制数据，只处理较少的
void Matrix::copyData(const Matrix& A, Matrix& R, int64_t size)
{
if (&A == &R)
{
return;
}
copyDataPointer(A, A.data(), R, R.data(), size);
}
void Matrix::copyRows(const Matrix& A, int ra, Matrix& R, int rr, int64_t rows)
{
if (A.row_ != R.row_)
{
return;
}
MatrixData::copy(A.getDeviceType(), A.getDataPointer(0, ra), R.getDeviceType(), R.getDataPointer(0, rr), A.row_ * rows);
}
void Matrix::copyDataAcrossDevice(const Matrix& A, Matrix& R, int64_t size)
{
if (size < 0)
{
size = std::min(A.getDataSize(), R.getDataSize());
}
int64_t size_in_byte = size * sizeof(real);
if (R.inGPU() && A.inGPU())
{
cudaError state = cudaMemcpyPeer(R.data(), R.cuda()->cuda_id_, A.data(), A.cuda()->cuda_id_, size_in_byte);
if (state != cudaSuccess)
{
fmt::print(stderr, "Error: cudaMemcpyPeer failed with error code is {}, size in byte is {} ({:g})!\n", state, size_in_byte, 1.0 * size_in_byte);
}
}
else
{
copyDataPointer(A, A.data(), R, R.data(), size);
}
}
void Matrix::shareData(const Matrix& A)
{
shareData(A, 0, 0, 0, 0);
}
//将一个外部数据矩阵的指针指向其他位置
void Matrix::shareData(const Matrix& A, int m, int n)
{
shareData(A, 0, 0, m, n);
}
void Matrix::shareData(const Matrix& A, int w, int h, int c, int n)
{
assert(checkMatrixDevice({ this, &A }));
if (cuda() != A.cuda())
{
fmt::print(stderr, "Error: share data are on different device ({}, {})!\n", cuda()->cuda_id_, A.cuda()->cuda_id_);
}
if (getDeviceType() == A.getDeviceType())
{
data_ = A.getDataPointer(w, h, c, n);
if (shared_data_->data_ != A.shared_data_->data_)
{
shared_data_ = A.shared_data_;
}
}
}
//指针来自外部，故此时不宜将指针交由自身管理
void Matrix::shareData(real* data)
{
data_ = data;
auto cuda = shared_data_->cuda_;
shared_data_ = std::make_shared<MatrixData>();
shared_data_->cuda_ = cuda;
}
//以同一个值初始化矩阵
//inc不为零时仅用于测试，不要用于实际计算！
Matrix& Matrix::initData(real v, int inc /*=0*/)
{
if (!data())
{
return *this;
}
if (inGPU() && inc == 0)
{
if (v == 0)
{
cudaMemset(data(), 0, getDataSizeInByte());
}
else
{
cudnnSetTensor(cuda()->cudnn_handle_, tensor_desc(), data(), &v);
}
}
else
{
auto temp = dataMirrorCPU(false);
//#pragma loop(hint_parallel(8))
if (v == 0 && inc == 0)
{
memset(data(), 0, getDataSizeInByte());
}
else
{
for (int i = 0; i < data_size_; i++)
{
temp->data_[i] = i * inc + v;
}
}
MatrixData::copy(DeviceType::CPU, temp->data_, getDeviceType(), getDataPointer(), data_size_);
}
return *this;
}
Matrix& Matrix::initData(real* data, int64_t size)
{
MatrixData::copy(DeviceType::CPU, data, getDeviceType(), getDataPointer(), std::min(size, data_size_));
return *this;
}
//随机数初始化矩阵，注意这个函数调用次数很少
Matrix& Matrix::initRandom(int seed /*= 0*/)
{
if (!data())
{
return *this;
}
Random<real> r;
r.set_seed(seed);
std::vector<real> temp(data_size_);
r.rand_data(temp.data(), temp.size());
MatrixData::copy(DeviceType::CPU, temp.data(), getDeviceType(), getDataPointer(), data_size_);
return *this;
}
//内存中的数据转移到显存
void Matrix::toGPU()
{
if (!inGPU() && CudaControl::getGlobalCudaType() == DeviceType::GPU)
{
real* temp = nullptr;
std::swap(temp, shared_data_->data_);
shared_data_->occupy_data_size_ = 0;
shared_data_->setCudaAsCurrent();
shared_data_->resize(data_size_);
MatrixData::copy(DeviceType::CPU, temp, DeviceType::GPU, shared_data_->data_, data_size_);
delete[] temp;
data_ = shared_data_->data_;
}
}
//显存中的数据转移到内存
void Matrix::toCPU(bool reserve_data)
{
if (inGPU())
{
real* temp = new real[data_size_];
MatrixData::copy(DeviceType::GPU, shared_data_->data_, DeviceType::CPU, temp, data_size_);
shared_data_->free();
shared_data_->setCuda(nullptr);
shared_data_->occupy_data_size_ = data_size_;
std::swap(temp, shared_data_->data_);
data_ = shared_data_->data_;
}
}
//flip和transpose暂时仅用于cpu
void Matrix::flip(int flip_flag)
{
if (inGPU())
{
return;
}
Matrix temp(width_, height_, DeviceType::CPU);
for (int c = 0; c < channel_; c++)
{
for (int n = 0; n < number_; n++)
{
Matrix::copyDataPointer(*this, getDataPointer(0, 0, c, n), temp, temp.getDataPointer());
switch (flip_flag)
{
case 1:
for (int i = 0; i < width_; i++)
{
for (int j = 0; j < height_; j++)
{
getData(i, j, c, n) = temp.getData(width_ - 1 - i, j);
}
}
break;
case 0:
for (int i = 0; i < width_; i++)
{
for (int j = 0; j < height_; j++)
{
getData(i, j, c, n) = temp.getData(i, height_ - 1 - j);
}
}
break;
case -1:
for (int i = 0; i < width_; i++)
{
for (int j = 0; j < height_; j++)
{
getData(i, j, c, n) = temp.getData(width_ - 1 - i, height_ - 1 - j);
}
}
break;
default:
break;
}
}
}
}
void Matrix::transpose()
{
if (inGPU())
{
return;
}
auto temp = clone(DeviceType::CPU);
if (row_ != channel_)
{
resize(height_, width_, channel_, number_);
for (int c = 0; c < channel_; c++)
{
for (int n = 0; n < number_; n++)
{
for (int i = 0; i < width_; i++)
{
for (int j = 0; j < height_; j++)
{
getData(i, j, c, n) = temp.getData(j, i, c, n);
}
}
}
}
}
else
{
resize(number_, row_);
for (int c = 0; c < channel_; c++)
{
for (int n = 0; n < number_; n++)
{
getData(c, n) = temp.getData(n, c);
}
}
}
}
//生成一个数据在cpu中的镜像
std::shared_ptr<MatrixData> Matrix::dataMirrorCPU(bool reserve_data) const
{
if (inGPU())
{
auto new_shared_data = std::make_shared<MatrixData>();
new_shared_data->resize(data_size_);
if (reserve_data)
{
MatrixData::copy(DeviceType::GPU, shared_data_->data_, DeviceType::CPU, new_shared_data->data_, data_size_);
}
return new_shared_data;
}
else
{
return shared_data_;
}
}
//将前面几列复制到整个矩阵
void Matrix::repeat(int c)
{
if (inGPU())
{
for (int i = c; i < number_; i *= 2)
{
cudaMemcpy(getDataPointer(0, i), getDataPointer(0, 0), sizeof(real) * row_ * std::min(i, number_ - i), cudaMemcpyDeviceToDevice);
}
}
else
{
//#pragma loop(hint_parallel(8))
for (int i = c; i < number_; i *= 2)
{
memcpy(getDataPointer(0, i), getDataPointer(0, 0), sizeof(real) * row_ * std::min(i, number_ - i));
}
}
}
//一列中最大值的序号
int Matrix::indexColMaxAbs(int c) const
{
if (inGPU())
{
return cuda()->cublas_->iamax(row_, getDataPointer(0, c), 1);
}
else
{
return Cblas::iamax(row_, getDataPointer(0, c), 1);
}
}
//绝对值求和（直接调用的blas，注意这里实际上需要的功能只是求和）
realc Matrix::sumAbs() const
{
if (inGPU())
{
return cuda()->cublas_->asum(data_size_, data(), 1);
}
else
{
return Cblas::asum(data_size_, data(), 1);
}
}
//一列的绝对值和
realc Matrix::sumAbsCol(int c) const
{
if (inGPU())
{
return cuda()->cublas_->asum(row_, getDataPointer(0, c), 1);
}
else
{
return Cblas::asum(row_, getDataPointer(0, c), 1);
}
}
realc Matrix::sum() const
{
Matrix temp1(data_size_, 1);
temp1.initData(1);
real r = dot(*this, temp1);
return r;
}
void Matrix::sectionLimit(real v0, real v1)
{
if (inGPU())
{
cuda_sectionlimit(data(), nullptr, data(), data_size_, v0, v1);
}
else
{
for (int i = 0; i < data_size_; i++)
{
data()[i] = std::min(data()[i], v1);
data()[i] = std::max(data()[i], v0);
}
}
}
//数乘
void Matrix::scale(real v)
{
if (v == 1)
{
return;
}
if (v == 0)
{
initData(0);
return;
}
if (inGPU())
{
cuda()->cublas_->scal(data_size_, v, data(), 1);
}
else
{
Cblas::scal(data_size_, v, data(), 1);
}
}
//好像没有直接的功能
void Matrix::scale(const Matrix& A, Matrix& R, real v)
{
copyData(A, R);
R.scale(v);
}
//选择一列数乘
void Matrix::scaleCol(real v, int c)
{
if (v == 1)
{
return;
}
if (inGPU())
{
cuda()->cublas_->scal(row_, v, getDataPointer(0, c), 1);
}
else
{
Cblas::scal(row_, v, getDataPointer(0, c), 1);
}
}
//矩阵乘，R = aAB+rR
void Matrix::mul(const Matrix& A, const Matrix& B, Matrix& R, real a, real r, MatrixTransType ta, MatrixTransType tb)
{
assert(checkMatrixDevice({ &A, &B, &R }));
int m = R.row_;
int n = R.number_;
int lda = A.row_;
int k = A.number_;
int ldb = B.row_;
if (ta == MATRIX_TRANS)
{
k = A.row_;
}
if (R.inGPU())
{
R.cuda()->cublas_->gemm(ta, tb, m, n, k, a, A.data(), lda, B.data(), ldb, r, R.data(), m);
}
else
{
Cblas::gemm(ta, tb, m, n, k, a, A.data(), lda, B.data(), ldb, r, R.data(), m);
}
}
//矩阵乘以向量，R = aAB+rR
//B和R的维度会被无视
void Matrix::mulVector(Matrix& A, Matrix& B, Matrix& R, real a, real r, MatrixTransType ta)
{
assert(checkMatrixDevice({ &A, &B, &R }));
int m = A.row_, n = A.number_;
if (R.inGPU())
{
R.cuda()->cublas_->gemv(ta, m, n, a, A.data(), A.row_, B.data(), 1, r, R.data(), 1);
}
else
{
Cblas::gemv(ta, m, n, a, A.data(), A.row_, B.data(), 1, r, R.data(), 1);
}
}
//没什么用，废弃
void Matrix::mulVector2(Matrix& A, Matrix& B, Matrix& R, real a, real r, MatrixTransType ta)
{
assert(checkMatrixDevice({ &A, &B, &R }));
int m = A.row_, n = A.number_;
if (ta == MATRIX_TRANS)
{
std::swap(m, n);
};
if (R.inGPU())
{
for (int i = 0; i <= R.number_; i++)
{
R.cuda()->cublas_->gemv(ta, m, n, a, A.data(), A.row_, B.data(), 1, r, R.getDataPointer(0, i), 1);
}
}
else
{
for (int i = 0; i <= R.number_; i++)
{
Cblas::gemv(ta, m, n, a, A.data(), A.row_, B.data(), 1, r, R.getDataPointer(0, i), 1);
}
}
}
//矩阵元素乘，B和R数据不能指向同一区域
void Matrix::elementMul(const Matrix& A, const Matrix& B, Matrix& R, real a, real r)
{
assert(checkMatrixDevice({ &A, &B, &R }));
if (R.inGPU())
{
cudnnSetOpTensorDescriptor(R.cuda()->op_tensor_desc_, CUDNN_OP_TENSOR_MUL, MYCUDNN_DATA_REAL_C, CUDNN_NOT_PROPAGATE_NAN);
//好像B不能与R相同
if (R.data() != B.data())
{
cudnnOpTensor(R.cuda()->cudnn_handle_, R.cuda()->op_tensor_desc_,
&a, A.tensor_desc(), A.data(), &const_real_1, B.tensor_desc(), B.data(), &r, R.tensor_desc(), R.data());
}
else
{
cudnnOpTensor(R.cuda()->cudnn_handle_, R.cuda()->op_tensor_desc_,
&a, B.tensor_desc(), B.data(), &const_real_1, A.tensor_desc(), A.data(), &r, R.tensor_desc(), R.data());
}
}
else
{
for (int i = 0; i < A.data_size_; i++)
{
R.data()[i] = A.data()[i] * B.data()[i] * a + R.data()[i] * r;
}
}
}
//矩阵加，系数为负时可以为减
void Matrix::add(const Matrix& A, const Matrix& B, Matrix& R, realc a, realc b, realc r)
{
assert(checkMatrixDevice({ &A, &B, &R }));
if (A.data() == B.data() && B.data() == R.data() && a + b + r == 1)
{
return;
}
//注意只使用R的tensor_desc
if (R.inGPU())
{
if (A.data() == R.data())
{
r = r + a;
if (b != 0 || r != 1)
{
cudnnAddTensor(R.cuda()->cudnn_handle_, &b, R.tensor_desc(), B.data(), &r, R.tensor_desc(), A.data());
}
}
else if (B.data() == R.data())
{
r = r + b;
if (a != 0 || r != 1)
{
cudnnAddTensor(R.cuda()->cudnn_handle_, &a, R.tensor_desc(), A.data(), &r, R.tensor_desc(), B.data());
}
}
else
{
//geam非Blas标准
//R.cuda()->cublas_->geam(MATRIX_NO_TRANS, MATRIX_NO_TRANS, A.row_, A.number_, a, A.data(), A.row_, b, B.data(), B.row_, R.data(), R.row_);
cudnnSetOpTensorDescriptor(R.cuda()->op_tensor_desc_, CUDNN_OP_TENSOR_ADD, MYCUDNN_DATA_REAL_C, CUDNN_NOT_PROPAGATE_NAN);
//这个函数要求R不可等于A或B
cudnnOpTensor(R.cuda()->cudnn_handle_, R.cuda()->op_tensor_desc_, &a, R.tensor_desc(), A.data(), &b, R.tensor_desc(), B.data(), &r, R.tensor_desc(), R.data());
}
}
else
{
for (int i = 0; i < R.data_size_; i++)
{
R.data()[i] = a * A.data()[i] + b * B.data()[i] + r * R.data()[i];
}
}
}
//整个矩阵点乘
will::realc Matrix::dot(const Matrix& A, const Matrix& B)
{
assert(checkMatrixDevice({ &A, &B }));
if (A.inGPU())
{
return A.cuda()->cublas_->dot(A.data_size_, A.getDataPointer(), 1, B.getDataPointer(), 1);
}
else
{
return Cblas::dot(A.data_size_, A.getDataPointer(), 1, B.getDataPointer(), 1);
}
}
//选择矩阵的某列点乘
will::realc Matrix::dotCol(const Matrix& A, int cA, const Matrix& B, int cB)
{
assert(checkMatrixDevice({ &A, &B }));
if (A.inGPU())
{
return A.cuda()->cublas_->dot(A.row_, A.getDataPointer(0, cA), 1, B.getDataPointer(0, cA), 1);
}
else
{
return Cblas::dot(A.row_, A.getDataPointer(0, cA), 1, B.getDataPointer(0, cA), 1);
}
}
//选择部分点乘
realc Matrix::dotPart(int size, const Matrix& A, real* a, int cA, real* b, int cB)
{
if (A.inGPU())
{
return A.cuda()->cublas_->dot(size, a, cA, b, cB);
}
else
{
return Cblas::dot(size, a, cA, b, cB);
}
}
//点乘，即所有元素平方和
realc Matrix::dotSelf() const
{
if (inGPU())
{
return cuda()->cublas_->dot(data_size_, data(), 1, data(), 1);
}
else
{
return Cblas::dot(data_size_, data(), 1, data(), 1);
}
}
//取符号
void Matrix::sign(Matrix& A, Matrix& R, real v, real section)
{
if (A.inGPU())
{
cuda_sign(A.data(), R.data(), A.data_size_, v, section);
}
else
{
for (int i = 0; i < A.data_size_; i++)
{
if (A.data()[i] > section)
{
R.data()[i] = 1;
continue;
}
if (A.data()[i] < -section)
{
R.data()[i] = -1;
continue;
}
R.data()[i] = 0;
}
}
}
void Matrix::importData(real* v, int64_t n)
{
MatrixData::copy(DeviceType::CPU, v, getDeviceType(), data(), std::min(n, data_size_));
//for (int i = 0; i < n; i++)
//{
// fmt::print(stdout, "{}, ", v[i]);
//}
}
void Matrix::exportData(real* v, int64_t n)
{
MatrixData::copy(getDeviceType(), data(), DeviceType::CPU, v, std::min(n, data_size_));
}
//求倒数，a = scale ./ a
void Matrix::reciprocal(real scale)
{
if (inGPU())
{
cuda_reciprocal(data(), data(), data_size_, scale, 0.0);
}
else
{
for (int i = 0; i < data_size_; i++)
{
data()[i] = scale / data()[i];
}
}
}
//加上一个数字，a = v + scale .* a;
void Matrix::addNumber(real v, real scale)
{
if (inGPU())
{
cuda_addnumber(data(), data(), data_size_, v, scale);
}
else
{
for (int i = 0; i < data_size_; i++)
{
data()[i] = v + scale * data()[i];
}
}
}
void Matrix::addNumber(const Matrix& A, Matrix& R, real v, real scale)
{
assert(checkMatrixDevice({ &A, &R }));
if (A.inGPU())
{
cuda_addnumber(A.data(), R.data(), A.data_size_, v, scale);
}
else
{
for (int i = 0; i < A.data_size_; i++)
{
R.data()[i] = v + scale * A.data()[i];
}
}
}
void Matrix::addNumberCol(real v, real scale, int c)
{
if (inGPU())
{
cuda_addnumber(getDataPointer(0, c), getDataPointer(0, c), row_, v, scale);
}
else
{
for (int i = 0; i < row_; i++)
{
getData(i, c) = v + scale * getData(i, c);
}
}
}
void Matrix::elementPow(const Matrix& A, Matrix& R, real e, real bias)
{
assert(checkMatrixDevice({ &A, &R }));
if (A.inGPU())
{
cuda_pow(A.data(), R.data(), A.data_size_, e, bias);
}
else
{
for (int i = 0; i < A.data_size_; i++)
{
R.data()[i] = pow(bias + A.data()[i], e);
}
}
}
void Matrix::elementDiv(const Matrix& A, const Matrix& B, Matrix& R, real a, real b, real scale)
{
assert(checkMatrixDevice({ &A, &B, &R }));
if (A.inGPU())
{
cuda_div(A.data(), B.data(), R.data(), A.data_size_, a, b, scale);
}
else
{
for (int i = 0; i < A.data_size_; i++)
{
R.data()[i] = scale * (A.data()[i] + a) / (B.data()[i] + b);
}
}
}
void Matrix::crossEntropy(const Matrix& A, const Matrix& Y, Matrix& R, real a, real scale)
{
assert(checkMatrixDevice({ &A, &Y, &R }));
if (A.inGPU())
{
cuda_cross_entropy(A.data(), Y.data(), R.data(), A.data_size_, a, scale);
}
else
{
for (int i = 0; i < A.data_size_; i++)
{
R.data()[i] = Y.data()[i] * log(A.data()[i] + a);
R.data()[i] *= -scale;
}
}
}
void Matrix::crossEntropy2(const Matrix& A, const Matrix& Y, Matrix& R, real a, real scale)
{
assert(checkMatrixDevice({ &A, &Y, &R }));
if (A.inGPU())
{
cuda_cross_entropy2(A.data(), Y.data(), R.data(), A.data_size_, a, scale);
}
else
{
for (int i = 0; i < A.data_size_; i++)
{
R.data()[i] = Y.data()[i] * log(A.data()[i] + a) + (1 - Y.data()[i]) * log(1 - A.data()[i] + a);
R.data()[i] *= -scale;
}
}
}
bool Matrix::checkMatrixDevice(const std::vector<const Matrix*>& v)
{
if (v.size() <= 1)
{
return true;
}
else
{
const CudaControl* cuda = nullptr;
for (int i = 0; i < v.size(); i++)
{
if (v[i]->data_size_ > 0)
{
cuda = v[i]->cuda();
break;
}
}
for (int i = 0; i < v.size(); i++)
{
if (v[i]->data_size_ > 0 && cuda != v[i]->cuda())
{
fmt::print(stderr, "Matrices are not in the same device!\n");
return false;
break;
}
}
return true;
}
}
void Matrix::message(const std::string& info) const
{
//int w, h, c, n, t;
//cudnnDataType_t tt;
fmt::print(stdout, "{}:", info);
if (inGPU())
{
fmt::print(stdout, " GPU({}),", cuda()->cuda_id_);
}
else
{
fmt::print(stdout, " CPU,");
}
fmt::print(stdout, " dim =");
for (auto& i : dim_)
{
fmt::print(stdout, " {}", i);
}
//fmt::print(stdout, ", address = %p\n", getDataPointer());
fmt::print(stdout, ", norm^2 = {}\n", dotSelf());
//cudnnDataType_t t;
//int n;
//int d1[8];
//int s1[8];
//cudnnGetTensorNdDescriptor(tensor_desc(), 8, &t, &n, d1, s1);
//fmt::print(stdout, "%d %d\n", t, n);
//for (int i = 0; i < 8; i++)
//{
// fmt::print(stdout, "%d %d\n", d1[i], s1[i]);
//}
//cudnnSetTensorNdDescriptor(tensor_desc_, t, n, d1, s1);
} // namespace will
} // namespace will | [
"[email protected]"
] | |
479262343ca15cc5989ad9614f70cd3cc4496d13 | 0985379e8027bbad7c9aa51443b547949814288c | /tests/TestLogIndenterString.cpp | 0e5c3848f7ebb44fc12aaabe830863e69b60b8c3 | [
"Apache-2.0"
] | permissive | Nuovations/LogUtilities | 2bb903ae9bebcad4719d1b62560aecf12b35dc72 | 8a367c33757dcf5a7df9ad5abbdc833e6cc21437 | refs/heads/main | 2023-05-22T17:50:51.538757 | 2021-06-04T04:16:53 | 2021-06-04T04:16:53 | 343,894,320 | 1 | 0 | Apache-2.0 | 2021-06-04T04:16:54 | 2021-03-02T19:50:34 | C++ | UTF-8 | C++ | false | false | 7,841 | cpp | /*
* Copyright (c) 2021 Nuovation System Designs, LLC
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file
* This file implements a unit test for Log::Indenter::String.
*/
#include <LogUtilities/LogIndenterString.hpp>
#include <string>
#include <cppunit/TestAssert.h>
#include <cppunit/extensions/HelperMacros.h>
using namespace Nuovations;
class TestLogIndenterString :
public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(TestLogIndenterString);
CPPUNIT_TEST(TestConstruction);
CPPUNIT_TEST(TestFirstIndent);
CPPUNIT_TEST(TestEveryIndent);
CPPUNIT_TEST_SUITE_END();
public:
void TestConstruction(void);
void TestFirstIndent(void);
void TestEveryIndent(void);
private:
void CheckResults(const std::string & inExpected, const std::string & inActual);
};
CPPUNIT_TEST_SUITE_REGISTRATION(TestLogIndenterString);
void
TestLogIndenterString :: TestConstruction(void)
{
const char * kSpaceCString = " ";
const char kSpaceChar = ' ';
const size_t kCount = 1;
const std::string kSpaceCxxString(kSpaceCString);
Log::Indenter::String lCString(kSpaceCString);
Log::Indenter::String lCxxString(kSpaceCxxString);
Log::Indenter::String lChar(kSpaceChar);
Log::Indenter::String lCharWithCOunt(kSpaceChar, kCount);
Log::Indenter::String lCStringWithFirstFlag(kSpaceCString, Log::Indenter::String::Flags::kFirst);
Log::Indenter::String lCStringWithEveryFlag(kSpaceCString, Log::Indenter::String::Flags::kEvery);
Log::Indenter::String lCxxStringWithFirstFlag(kSpaceCxxString, Log::Indenter::String::Flags::kFirst);
Log::Indenter::String lCxxStringWithEveryFlag(kSpaceCxxString, Log::Indenter::String::Flags::kEvery);
Log::Indenter::String lCharWithFirstFlag(kSpaceChar, Log::Indenter::String::Flags::kFirst);
Log::Indenter::String lCharWithEveryFlag(kSpaceChar, Log::Indenter::String::Flags::kEvery);
Log::Indenter::String lCharWithCountWithFirstFlag(kSpaceChar, kCount, Log::Indenter::String::Flags::kFirst);
Log::Indenter::String lCharWithCountWithEveryFlag(kSpaceChar, kCount, Log::Indenter::String::Flags::kEvery);
}
void
TestLogIndenterString :: TestFirstIndent(void)
{
const size_t lCount = 1;
const char lCharacter = '.';
const std::string lTestString =
"First line.\n"
"Second line.\n"
"Third line.\n";
Log::Indenter::String lStringIndenter(lCharacter,
lCount,
Log::Indenter::String::Flags::kFirst);
Log::Level lLevel;
std::string lInputString;
std::string lExpectedResult;
std::string lActualResult;
// Try the indenter at level 0
lLevel = 0;
lInputString = lTestString;
lExpectedResult = std::string(lLevel, lCharacter) + lTestString;
lActualResult = lStringIndenter.Indent(lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
// Try the indenter at level 1
lInputString = lTestString;
lExpectedResult = std::string(++lLevel, lCharacter) + lTestString;
lActualResult = lStringIndenter.Indent(lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
// Try the indenter at level 2
lInputString = lTestString;
lExpectedResult = std::string(++lLevel, lCharacter) + lTestString;
lActualResult = lStringIndenter.Indent(lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
// Try the indenter at level 3
lInputString = lTestString;
lExpectedResult = std::string(++lLevel, lCharacter) + lTestString;
lActualResult = lStringIndenter.Indent(lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
// Try the indenter at level 4
lInputString = lTestString;
lExpectedResult = std::string(++lLevel, lCharacter) + lTestString;
lActualResult = lStringIndenter.Indent(lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
}
void
TestLogIndenterString ::TestEveryIndent(void)
{
const size_t lCount = 1;
const char lCharacter = '.';
const std::string lTestString =
"First line.\n"
"Second line.\n"
"Third line.\n";
Log::Indenter::String lStringIndenter(lCharacter,
lCount,
Log::Indenter::String::Flags::kEvery);
Log::Level lLevel;
std::string lInputString;
std::string lExpectedResult;
std::string lActualResult;
// Try the indenter at level 0
lLevel = 0;
lInputString = lTestString;
lExpectedResult = lTestString;
lActualResult = lStringIndenter.Indent(lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
// Try the indenter at level 1
lInputString = lTestString;
lExpectedResult = ".First line.\n"
".Second line.\n"
".Third line.\n";
lActualResult = lStringIndenter.Indent(++lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
// Try the indenter at level 2
lInputString = lTestString;
lExpectedResult = "..First line.\n"
"..Second line.\n"
"..Third line.\n";
lActualResult = lStringIndenter.Indent(++lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
// Try the indenter at level 3
lInputString = lTestString;
lExpectedResult = "...First line.\n"
"...Second line.\n"
"...Third line.\n";
lActualResult = lStringIndenter.Indent(++lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
// Try the indenter at level 4
lInputString = lTestString;
lExpectedResult = "....First line.\n"
"....Second line.\n"
"....Third line.\n";
lActualResult = lStringIndenter.Indent(++lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
// Try the indenter at level 4, with a string containing some
// existing '.' and blank lines.
lInputString = ".First line.\n"
"\n"
"..Second line.\n"
"\n"
"\n"
"...Third line.\n"
"\n";
lExpectedResult = ".....First line.\n"
"....\n"
"......Second line.\n"
"....\n"
"....\n"
".......Third line.\n"
"....\n";
lActualResult = lStringIndenter.Indent(lLevel, lInputString);
CheckResults(lExpectedResult, lActualResult);
}
void
TestLogIndenterString :: CheckResults(const std::string & inExpected,
const std::string & inActual)
{
const size_t lActualSize = inActual.size();
const size_t lExpectedSize = inExpected.size();
CPPUNIT_ASSERT_EQUAL(lExpectedSize, lActualSize);
CPPUNIT_ASSERT_EQUAL(inExpected, inActual);
}
| [
"[email protected]"
] | |
8ffb1edde0cf8abb36461f2fee82303496502fc6 | 41eff316a4c252dbb71441477a7354c9b192ba41 | /src/PhysX/physx/source/foundation/include/PsUtilities.h | ff57e0587c998aa9be5e79b5712876c44e80511d | [] | no_license | erwincoumans/pybullet_physx | 40615fe8502cf7d7a5e297032fc4af62dbdd0821 | 70f3e11ad7a1e854d4f51992edd1650bbe4ac06a | refs/heads/master | 2021-07-01T08:02:54.367317 | 2020-10-22T21:43:34 | 2020-10-22T21:43:34 | 183,939,616 | 21 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 4,440 | h | //
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of NVIDIA CORPORATION nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2019 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#ifndef PSFOUNDATION_PSUTILITIES_H
#define PSFOUNDATION_PSUTILITIES_H
#include "foundation/PxVec3.h"
#include "foundation/PxAssert.h"
#include "Ps.h"
#include "PsIntrinsics.h"
#include "PsBasicTemplates.h"
namespace physx
{
namespace shdfnd
{
PX_INLINE char littleEndian()
{
int i = 1;
return *(reinterpret_cast<char*>(&i));
}
// PT: checked casts
PX_CUDA_CALLABLE PX_FORCE_INLINE PxU32 to32(PxU64 value)
{
PX_ASSERT(value <= 0xffffffff);
return PxU32(value);
}
PX_CUDA_CALLABLE PX_FORCE_INLINE PxU16 to16(PxU32 value)
{
PX_ASSERT(value <= 0xffff);
return PxU16(value);
}
PX_CUDA_CALLABLE PX_FORCE_INLINE PxU8 to8(PxU16 value)
{
PX_ASSERT(value <= 0xff);
return PxU8(value);
}
PX_CUDA_CALLABLE PX_FORCE_INLINE PxU8 to8(PxU32 value)
{
PX_ASSERT(value <= 0xff);
return PxU8(value);
}
PX_CUDA_CALLABLE PX_FORCE_INLINE PxU8 to8(PxI32 value)
{
PX_ASSERT(value <= 0xff);
PX_ASSERT(value >= 0);
return PxU8(value);
}
PX_CUDA_CALLABLE PX_FORCE_INLINE PxI8 toI8(PxU32 value)
{
PX_ASSERT(value <= 0x7f);
return PxI8(value);
}
/*!
Get number of elements in array
*/
template <typename T, size_t N>
char (&ArraySizeHelper(T (&array)[N]))[N];
#define PX_ARRAY_SIZE(_array) (sizeof(physx::shdfnd::ArraySizeHelper(_array)))
/*!
Sort two elements using operator<
On return x will be the smaller of the two
*/
template <class T>
PX_CUDA_CALLABLE PX_FORCE_INLINE void order(T& x, T& y)
{
if(y < x)
swap(x, y);
}
// most architectures can do predication on real comparisons, and on VMX, it matters
PX_CUDA_CALLABLE PX_FORCE_INLINE void order(PxReal& x, PxReal& y)
{
PxReal newX = PxMin(x, y);
PxReal newY = PxMax(x, y);
x = newX;
y = newY;
}
/*!
Sort two elements using operator< and also keep order
of any extra data
*/
template <class T, class E1>
PX_CUDA_CALLABLE PX_FORCE_INLINE void order(T& x, T& y, E1& xe1, E1& ye1)
{
if(y < x)
{
swap(x, y);
swap(xe1, ye1);
}
}
#if PX_GCC_FAMILY && !PX_EMSCRIPTEN && !PX_LINUX
__attribute__((noreturn))
#endif
PX_INLINE void debugBreak()
{
#if PX_WINDOWS || PX_XBOXONE
__debugbreak();
#elif PX_ANDROID
raise(SIGTRAP); // works better than __builtin_trap. Proper call stack and can be continued.
#elif PX_LINUX
asm("int $3");
#elif PX_GCC_FAMILY
__builtin_trap();
#else
PX_ASSERT(false);
#endif
}
bool checkValid(const float&);
bool checkValid(const PxVec3&);
bool checkValid(const PxQuat&);
bool checkValid(const PxMat33&);
bool checkValid(const PxTransform&);
bool checkValid(const char*);
// equivalent to std::max_element
template <typename T>
inline const T* maxElement(const T* first, const T* last)
{
const T* m = first;
for(const T* it = first + 1; it < last; ++it)
if(*m < *it)
m = it;
return m;
}
} // namespace shdfnd
} // namespace physx
#endif
| [
"[email protected]"
] | |
d471884ceb5840dd8ceeddb4b84d544d3ced3e3e | c6bb78710132dea303e5252c8e6a1bfba2b0b32d | /include/taichi/math/scalar.h | d781d98f80128adb6c0690bd43c8d2aff04f19af | [
"MIT"
] | permissive | ai3DVision/taichi | 4d175df989cdb20689a68d82c8460675b4c6a2c3 | b97c232de75f99d75453902c2267b876b4589079 | refs/heads/master | 2020-03-11T13:40:00.160770 | 2018-04-18T02:13:20 | 2018-04-18T02:13:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,792 | h | /*******************************************************************************
Copyright (c) The Taichi Authors (2016- ). All Rights Reserved.
The use of this software is governed by the LICENSE file.
*******************************************************************************/
#pragma once
#include <cmath>
#include <taichi/common/util.h>
TC_NAMESPACE_BEGIN
#undef max
#undef min
using std::min;
using std::max;
using std::abs;
using std::sin;
using std::asin;
using std::cos;
using std::acos;
using std::tan;
using std::atan;
using std::floor;
const real pi{acosf(-1.0_f)};
const real eps = 1e-6_f;
template <int I, typename T>
constexpr inline T pow(T a) {
T ret(1);
for (int i = 0; i < I; i++) {
ret *= a;
}
return ret;
};
inline float32 fract(float32 a) {
return a - (int)floor(a);
}
inline float64 fract(float64 a) {
return a - (int)floor(a);
}
template <typename T>
inline T clamp(const T &a, const T &min, const T &max) {
if (a < min)
return min;
if (a > max)
return max;
return a;
}
template <typename T>
inline T clamp(const T &a) {
if (a < T(0))
return T(0);
if (a > T(1))
return T(1);
return a;
}
template <typename T, typename V>
inline V lerp(T a, V x_0, V x_1) {
return (T(1) - a) * x_0 + a * x_1;
}
template <typename T>
T sqr(const T &a) {
return pow<2>(a);
}
inline int sgn(float a) {
if (a < -eps)
return -1;
else if (a > eps)
return 1;
return 0;
}
inline int sgn(double a) {
if (a < -eps)
return -1;
else if (a > eps)
return 1;
return 0;
}
inline uint32 rand_int() {
static unsigned int x = 123456789, y = 362436069, z = 521288629, w = 88675123;
unsigned int t = x ^ (x << 11);
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
inline uint64 rand_int64() {
return ((uint64)rand_int() << 32) + rand_int();
}
// inline float frand() { return (float)rand() / (RAND_MAX + 1); }
inline float rand() {
return rand_int() * (1.0_f / 4294967296.0f);
}
inline int is_prime(int a) {
assert(a >= 2);
for (int i = 2; i * i <= a; i++) {
if (a % i == 0)
return false;
}
return true;
}
template <typename T>
inline T hypot2(const T &x, const T &y) {
return x * x + y * y;
}
inline float32 pow(const float32 &a, const float32 &b) {
return ::pow(a, b);
}
inline float64 pow(const float64 &a, const float64 &b) {
return ::pow(a, b);
}
template <typename T>
inline bool is_normal(T m) {
return std::isfinite(m);
}
template <typename T>
inline bool abnormal(T m) {
return !is_normal(m);
}
inline int64 get_largest_pot(int64 a) {
assert_info(a > 0, "a should be positive, instead of " + std::to_string(a));
// TODO: optimize
int64 i = 1;
while (i <= a / 2) {
i *= 2;
}
return i;
}
TC_NAMESPACE_END
| [
"[email protected]"
] | |
ab15afa17851d37a8ffd8fe4dc55247c898c4894 | 64a5bf4e81d354068bfe396dfd93e3c63d3b2294 | /samples/snippets/cpp/VS_Snippets_Remoting/NclNegoSyncServer/CPP/NclNegoSyncServer.cpp | 28364b60513de294dba69a9353c40a946e07dc38 | [
"CC-BY-4.0",
"MIT"
] | permissive | avatarbuss/dotnet-api-docs | 7b14f1a0a71e4a4d3c85523ce5894aea7a125022 | f3030b44600c2de2df63995d96a2a6c7e66f4749 | refs/heads/master | 2022-09-17T19:15:29.173244 | 2020-04-03T14:38:00 | 2020-04-03T14:38:00 | 252,750,128 | 1 | 3 | NOASSERTION | 2020-04-03T14:06:04 | 2020-04-03T14:06:03 | null | UTF-8 | C++ | false | false | 2,056 | cpp |
#using <System.dll>
using namespace System;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Security::Principal;
using namespace System::Text;
using namespace System::IO;
using namespace System::Threading;
//<snippet1>
static void AuthenticateClient( TcpClient^ clientRequest )
{
NetworkStream^ stream = clientRequest->GetStream();
// Create the NegotiateStream.
NegotiateStream^ authStream = gcnew NegotiateStream( stream,false );
// Perform the server side of the authentication.
authStream->AuthenticateAsServer();
// Display properties of the authenticated client.
IIdentity^ id = authStream->RemoteIdentity;
Console::WriteLine( L"{0} was authenticated using {1}.", id->Name, id->AuthenticationType );
// Read a message from the client.
array<Byte>^buffer = gcnew array<Byte>(2048);
int charLength = authStream->Read( buffer, 0, buffer->Length );
String^ messageData = gcnew String( Encoding::UTF8->GetChars( buffer, 0, buffer->Length ) );
Console::WriteLine( L"READ {0}", messageData );
// Finished with the current client.
authStream->Close();
// Close the client connection.
clientRequest->Close();
}
//</snippet1>
int main()
{
// Create an IPv4 TCP/IP socket.
TcpListener^ listener = gcnew TcpListener( IPAddress::Any,11000 );
// Listen for incoming connections.
listener->Start();
while ( true )
{
TcpClient^ clientRequest = nullptr;
// Application blocks while waiting for an incoming connection.
// Type CNTL-C to terminate the server.
clientRequest = listener->AcceptTcpClient();
// A client has connected.
try
{
AuthenticateClient( clientRequest );
}
catch ( Exception^ e )
{
Console::WriteLine( e );
continue;
}
Console::WriteLine( L"Client connected." );
}
}
| [
"[email protected]"
] | |
f28c60f6c4f4ada9563a284bf51023a0fa0b3adc | 8ba26af4be6e5a17e9e8d7bd24cf77ecde9df56d | /lab4/task1/Shapes/Shapes/stdafx.h | 8a3d76437ef8ee7a28f8498f3e4ff55db191d894 | [] | no_license | GreatHorizon/oop | b182b2ddae504280cc0f5c7248a1be5e9b4a5c32 | df8632f64687f37cb138ce855abb317510dded37 | refs/heads/master | 2022-11-17T20:59:01.550294 | 2020-07-13T20:15:01 | 2020-07-13T20:15:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 297 | h | #pragma once
#include <stdio.h>
#include <tchar.h>
#include <optional>
#include <map>
#include <sstream>
#include <istream>
#include <functional>
#include <iostream>
#include <boost/algorithm/string/trim_all.hpp>
#include <typeinfo>
#include <iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
| [
"[email protected]"
] | |
66954b6523022b1f34ca484bc387eb0c685e7f65 | 5ed6e511a9c17f34c5f6340e32d79388c634a726 | /USACO/transform.cpp | a9769bb08ae79fadf4795936b829bc32226c0e55 | [] | no_license | d34th4ck3r/Random-Codes | 516112c240a425d80923fa7f1a5017d0521b0400 | 332066ef9b36229776c36ddf9a98597c4bdf3e75 | refs/heads/master | 2020-12-24T17:07:57.292580 | 2016-02-29T13:17:33 | 2016-02-29T13:17:33 | 5,183,084 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,467 | cpp | /*
ID: gautam11
PROG: transform
LANG: C++
*/
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<vector>
#include<string>
#include<map>
#include<fstream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<limits.h>
#include<set>
#include<stack>
#include<queue>
#define P(s) printf("%s\n",s)
#define Pint(n) printf("%d",n)
#define Sint(n) scanf("%d",&n)
#define TEST printf("Test Called!")
#define NL printf("\n")
typedef struct node{
int value;
struct node *next;
}node;
typedef struct BinaryTree{
int value;
struct BinaryTree *left;
struct BinaryTree *right;
}BinaryTree;
using namespace std;
bool Compare(char **Tiles,char **modTiles,int N)
{
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
if(Tiles[i][j]!=modTiles[i][j])
return 0;
return 1;
}
char** RotateBy90(char **Tiles,int N)
{
char **modTiles;
modTiles=(char **)malloc(sizeof(char *)*N);
for(int i=0;i<N;i++)
modTiles[i]=(char *)malloc(sizeof(char)*N);
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
modTiles[i][j]=Tiles[N-1-j][i];
return modTiles;
}
char** Reflection(char **Tiles,int N)
{
char **modTiles;
modTiles=(char **)malloc(sizeof(char *)*N);
for(int i=0;i<N;i++)
modTiles[i]=(char *)malloc(sizeof(char)*N);
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
modTiles[i][j]=Tiles[i][N-1-j];
return modTiles;
}
int main()
{
freopen ("transform.in", "r", stdin);
freopen ("transform.out", "w", stdout);
int N;
Sint(N);
char **Tiles;
Tiles=(char **)malloc(sizeof(char *)*N);
for(int i=0;i<N;i++)
Tiles[i]=(char *)malloc(sizeof(char)*N);
char **finalTiles;
finalTiles=(char **)malloc(sizeof(char *)*N);
for(int i=0;i<N;i++)
finalTiles[i]=(char *)malloc(sizeof(char)*N);
for(int i=0;i<N;i++)
scanf("%s",Tiles[i]);
for(int i=0;i<N;i++)
scanf("%s",finalTiles[i]);
char **modTiles;
modTiles=RotateBy90(Tiles,N);
if(Compare(modTiles,finalTiles,N))
{
printf("1\n");
return 0;
}
modTiles=RotateBy90(modTiles,N);
if(Compare(modTiles,finalTiles,N))
{
printf("2\n");
return 0;
}
modTiles=RotateBy90(modTiles,N);
if(Compare(modTiles,finalTiles,N))
{
printf("3\n");
return 0;
}
modTiles=Reflection(Tiles,N);
if(Compare(modTiles,finalTiles,N))
{
printf("4\n");
return 0;
}
for(int i=0;i<3;i++)
{
modTiles=RotateBy90(modTiles,N);
if(Compare(modTiles,finalTiles,N))
{
printf("5\n");
return 0;
}
}
if(Compare(Tiles,finalTiles,N))
{
printf("6\n");
return 0;
}
printf("7\n");
return 0;
}
| [
"d34th4ck3r@WorkStation.(none)"
] | d34th4ck3r@WorkStation.(none) |
ed2fecf07a5da42a09ec768bcc1133250796d748 | 06b1c887274634ca9f4606641914e71443d9923c | /src/ascent-shared/Threading/ThreadStarter.h | ce6f7aad11e165435fc0fa9f3b7c08bc3773fca7 | [] | no_license | zod331/Summit | 3d12db09fc02a1557de91cb61aacf6f801c16e38 | 95df88b83918a70d2d25d8618ca79b6cc1e8f38a | refs/heads/master | 2020-06-01T03:44:07.453120 | 2013-06-09T21:21:47 | 2013-06-09T21:21:47 | 10,589,168 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,184 | h | /*
* Ascent MMORPG Server
* Copyright (C) 2005-2008 Ascent Team <http://www.ascentemu.com/>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* 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 Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef _THREADING_STARTER_H
#define _THREADING_STARTER_H
class SERVER_DECL ThreadContext
{
public:
ThreadContext() { m_threadRunning = true; }
virtual ~ThreadContext() {}
virtual bool run() = 0;
#ifdef WIN32
HANDLE THREAD_HANDLE;
#else
pthread_t THREAD_HANDLE;
#endif
ASCENT_INLINE void Terminate() { m_threadRunning = false; }
virtual void OnShutdown() { Terminate(); }
protected:
bool m_threadRunning;
};
#endif
| [
"[email protected]"
] | |
2466d2a2f03dc2598929495545603d393a66461e | dd8899c38ef079c165f277c6cab3d69baf7fda08 | /Section13/ImplementingMethods2/Account.h | 41856eaa73bfd7909dc83f99aa874683f77a5db5 | [] | no_license | RandyZeleznak/CPP-Examples | 7ad6bb5c3dadde7503d270e0bdc19dc8553a6dd6 | 33cd5445d2c34b813b92acab2eff892efdcd9729 | refs/heads/master | 2022-11-29T01:13:24.314286 | 2020-08-11T12:33:10 | 2020-08-11T12:33:10 | 285,107,058 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 117 | h | #ifndef _ACCOUNT_H_
#define _ACCOUNT_H_
class Account
{
public:
Account();
~Account();
};
#endif // _ACCOUNT_H_
| [
"[email protected]"
] | |
842991de3e17980a67006223952289c9ecbc39e6 | 6ced41da926682548df646099662e79d7a6022c5 | /aws-cpp-sdk-apprunner/include/aws/apprunner/model/VpcConnector.h | b4aa0db123c5b0d46c87bc0de34d727f215e47d8 | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | irods/aws-sdk-cpp | 139104843de529f615defa4f6b8e20bc95a6be05 | 2c7fb1a048c96713a28b730e1f48096bd231e932 | refs/heads/main | 2023-07-25T12:12:04.363757 | 2022-08-26T15:33:31 | 2022-08-26T15:33:31 | 141,315,346 | 0 | 1 | Apache-2.0 | 2022-08-26T17:45:09 | 2018-07-17T16:24:06 | C++ | UTF-8 | C++ | false | false | 17,964 | h | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#pragma once
#include <aws/apprunner/AppRunner_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/apprunner/model/VpcConnectorStatus.h>
#include <aws/core/utils/DateTime.h>
#include <utility>
namespace Aws
{
namespace Utils
{
namespace Json
{
class JsonValue;
class JsonView;
} // namespace Json
} // namespace Utils
namespace AppRunner
{
namespace Model
{
/**
* <p>Describes an App Runner VPC connector resource. A VPC connector describes the
* Amazon Virtual Private Cloud (Amazon VPC) that an App Runner service is
* associated with, and the subnets and security group that are used.</p>
* <p>Multiple revisions of a connector might have the same <code>Name</code> and
* different <code>Revision</code> values.</p> <p>At this time, App Runner
* supports only one revision per name.</p> <p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/apprunner-2020-05-15/VpcConnector">AWS
* API Reference</a></p>
*/
class AWS_APPRUNNER_API VpcConnector
{
public:
VpcConnector();
VpcConnector(Aws::Utils::Json::JsonView jsonValue);
VpcConnector& operator=(Aws::Utils::Json::JsonView jsonValue);
Aws::Utils::Json::JsonValue Jsonize() const;
/**
* <p>The customer-provided VPC connector name.</p>
*/
inline const Aws::String& GetVpcConnectorName() const{ return m_vpcConnectorName; }
/**
* <p>The customer-provided VPC connector name.</p>
*/
inline bool VpcConnectorNameHasBeenSet() const { return m_vpcConnectorNameHasBeenSet; }
/**
* <p>The customer-provided VPC connector name.</p>
*/
inline void SetVpcConnectorName(const Aws::String& value) { m_vpcConnectorNameHasBeenSet = true; m_vpcConnectorName = value; }
/**
* <p>The customer-provided VPC connector name.</p>
*/
inline void SetVpcConnectorName(Aws::String&& value) { m_vpcConnectorNameHasBeenSet = true; m_vpcConnectorName = std::move(value); }
/**
* <p>The customer-provided VPC connector name.</p>
*/
inline void SetVpcConnectorName(const char* value) { m_vpcConnectorNameHasBeenSet = true; m_vpcConnectorName.assign(value); }
/**
* <p>The customer-provided VPC connector name.</p>
*/
inline VpcConnector& WithVpcConnectorName(const Aws::String& value) { SetVpcConnectorName(value); return *this;}
/**
* <p>The customer-provided VPC connector name.</p>
*/
inline VpcConnector& WithVpcConnectorName(Aws::String&& value) { SetVpcConnectorName(std::move(value)); return *this;}
/**
* <p>The customer-provided VPC connector name.</p>
*/
inline VpcConnector& WithVpcConnectorName(const char* value) { SetVpcConnectorName(value); return *this;}
/**
* <p>The Amazon Resource Name (ARN) of this VPC connector.</p>
*/
inline const Aws::String& GetVpcConnectorArn() const{ return m_vpcConnectorArn; }
/**
* <p>The Amazon Resource Name (ARN) of this VPC connector.</p>
*/
inline bool VpcConnectorArnHasBeenSet() const { return m_vpcConnectorArnHasBeenSet; }
/**
* <p>The Amazon Resource Name (ARN) of this VPC connector.</p>
*/
inline void SetVpcConnectorArn(const Aws::String& value) { m_vpcConnectorArnHasBeenSet = true; m_vpcConnectorArn = value; }
/**
* <p>The Amazon Resource Name (ARN) of this VPC connector.</p>
*/
inline void SetVpcConnectorArn(Aws::String&& value) { m_vpcConnectorArnHasBeenSet = true; m_vpcConnectorArn = std::move(value); }
/**
* <p>The Amazon Resource Name (ARN) of this VPC connector.</p>
*/
inline void SetVpcConnectorArn(const char* value) { m_vpcConnectorArnHasBeenSet = true; m_vpcConnectorArn.assign(value); }
/**
* <p>The Amazon Resource Name (ARN) of this VPC connector.</p>
*/
inline VpcConnector& WithVpcConnectorArn(const Aws::String& value) { SetVpcConnectorArn(value); return *this;}
/**
* <p>The Amazon Resource Name (ARN) of this VPC connector.</p>
*/
inline VpcConnector& WithVpcConnectorArn(Aws::String&& value) { SetVpcConnectorArn(std::move(value)); return *this;}
/**
* <p>The Amazon Resource Name (ARN) of this VPC connector.</p>
*/
inline VpcConnector& WithVpcConnectorArn(const char* value) { SetVpcConnectorArn(value); return *this;}
/**
* <p>The revision of this VPC connector. It's unique among all the active
* connectors (<code>"Status": "ACTIVE"</code>) that share the same
* <code>Name</code>.</p> <p>At this time, App Runner supports only one
* revision per name.</p>
*/
inline int GetVpcConnectorRevision() const{ return m_vpcConnectorRevision; }
/**
* <p>The revision of this VPC connector. It's unique among all the active
* connectors (<code>"Status": "ACTIVE"</code>) that share the same
* <code>Name</code>.</p> <p>At this time, App Runner supports only one
* revision per name.</p>
*/
inline bool VpcConnectorRevisionHasBeenSet() const { return m_vpcConnectorRevisionHasBeenSet; }
/**
* <p>The revision of this VPC connector. It's unique among all the active
* connectors (<code>"Status": "ACTIVE"</code>) that share the same
* <code>Name</code>.</p> <p>At this time, App Runner supports only one
* revision per name.</p>
*/
inline void SetVpcConnectorRevision(int value) { m_vpcConnectorRevisionHasBeenSet = true; m_vpcConnectorRevision = value; }
/**
* <p>The revision of this VPC connector. It's unique among all the active
* connectors (<code>"Status": "ACTIVE"</code>) that share the same
* <code>Name</code>.</p> <p>At this time, App Runner supports only one
* revision per name.</p>
*/
inline VpcConnector& WithVpcConnectorRevision(int value) { SetVpcConnectorRevision(value); return *this;}
/**
* <p>A list of IDs of subnets that App Runner uses for your service. All IDs are
* of subnets of a single Amazon VPC.</p>
*/
inline const Aws::Vector<Aws::String>& GetSubnets() const{ return m_subnets; }
/**
* <p>A list of IDs of subnets that App Runner uses for your service. All IDs are
* of subnets of a single Amazon VPC.</p>
*/
inline bool SubnetsHasBeenSet() const { return m_subnetsHasBeenSet; }
/**
* <p>A list of IDs of subnets that App Runner uses for your service. All IDs are
* of subnets of a single Amazon VPC.</p>
*/
inline void SetSubnets(const Aws::Vector<Aws::String>& value) { m_subnetsHasBeenSet = true; m_subnets = value; }
/**
* <p>A list of IDs of subnets that App Runner uses for your service. All IDs are
* of subnets of a single Amazon VPC.</p>
*/
inline void SetSubnets(Aws::Vector<Aws::String>&& value) { m_subnetsHasBeenSet = true; m_subnets = std::move(value); }
/**
* <p>A list of IDs of subnets that App Runner uses for your service. All IDs are
* of subnets of a single Amazon VPC.</p>
*/
inline VpcConnector& WithSubnets(const Aws::Vector<Aws::String>& value) { SetSubnets(value); return *this;}
/**
* <p>A list of IDs of subnets that App Runner uses for your service. All IDs are
* of subnets of a single Amazon VPC.</p>
*/
inline VpcConnector& WithSubnets(Aws::Vector<Aws::String>&& value) { SetSubnets(std::move(value)); return *this;}
/**
* <p>A list of IDs of subnets that App Runner uses for your service. All IDs are
* of subnets of a single Amazon VPC.</p>
*/
inline VpcConnector& AddSubnets(const Aws::String& value) { m_subnetsHasBeenSet = true; m_subnets.push_back(value); return *this; }
/**
* <p>A list of IDs of subnets that App Runner uses for your service. All IDs are
* of subnets of a single Amazon VPC.</p>
*/
inline VpcConnector& AddSubnets(Aws::String&& value) { m_subnetsHasBeenSet = true; m_subnets.push_back(std::move(value)); return *this; }
/**
* <p>A list of IDs of subnets that App Runner uses for your service. All IDs are
* of subnets of a single Amazon VPC.</p>
*/
inline VpcConnector& AddSubnets(const char* value) { m_subnetsHasBeenSet = true; m_subnets.push_back(value); return *this; }
/**
* <p>A list of IDs of security groups that App Runner uses for access to Amazon
* Web Services resources under the specified subnets. If not specified, App Runner
* uses the default security group of the Amazon VPC. The default security group
* allows all outbound traffic.</p>
*/
inline const Aws::Vector<Aws::String>& GetSecurityGroups() const{ return m_securityGroups; }
/**
* <p>A list of IDs of security groups that App Runner uses for access to Amazon
* Web Services resources under the specified subnets. If not specified, App Runner
* uses the default security group of the Amazon VPC. The default security group
* allows all outbound traffic.</p>
*/
inline bool SecurityGroupsHasBeenSet() const { return m_securityGroupsHasBeenSet; }
/**
* <p>A list of IDs of security groups that App Runner uses for access to Amazon
* Web Services resources under the specified subnets. If not specified, App Runner
* uses the default security group of the Amazon VPC. The default security group
* allows all outbound traffic.</p>
*/
inline void SetSecurityGroups(const Aws::Vector<Aws::String>& value) { m_securityGroupsHasBeenSet = true; m_securityGroups = value; }
/**
* <p>A list of IDs of security groups that App Runner uses for access to Amazon
* Web Services resources under the specified subnets. If not specified, App Runner
* uses the default security group of the Amazon VPC. The default security group
* allows all outbound traffic.</p>
*/
inline void SetSecurityGroups(Aws::Vector<Aws::String>&& value) { m_securityGroupsHasBeenSet = true; m_securityGroups = std::move(value); }
/**
* <p>A list of IDs of security groups that App Runner uses for access to Amazon
* Web Services resources under the specified subnets. If not specified, App Runner
* uses the default security group of the Amazon VPC. The default security group
* allows all outbound traffic.</p>
*/
inline VpcConnector& WithSecurityGroups(const Aws::Vector<Aws::String>& value) { SetSecurityGroups(value); return *this;}
/**
* <p>A list of IDs of security groups that App Runner uses for access to Amazon
* Web Services resources under the specified subnets. If not specified, App Runner
* uses the default security group of the Amazon VPC. The default security group
* allows all outbound traffic.</p>
*/
inline VpcConnector& WithSecurityGroups(Aws::Vector<Aws::String>&& value) { SetSecurityGroups(std::move(value)); return *this;}
/**
* <p>A list of IDs of security groups that App Runner uses for access to Amazon
* Web Services resources under the specified subnets. If not specified, App Runner
* uses the default security group of the Amazon VPC. The default security group
* allows all outbound traffic.</p>
*/
inline VpcConnector& AddSecurityGroups(const Aws::String& value) { m_securityGroupsHasBeenSet = true; m_securityGroups.push_back(value); return *this; }
/**
* <p>A list of IDs of security groups that App Runner uses for access to Amazon
* Web Services resources under the specified subnets. If not specified, App Runner
* uses the default security group of the Amazon VPC. The default security group
* allows all outbound traffic.</p>
*/
inline VpcConnector& AddSecurityGroups(Aws::String&& value) { m_securityGroupsHasBeenSet = true; m_securityGroups.push_back(std::move(value)); return *this; }
/**
* <p>A list of IDs of security groups that App Runner uses for access to Amazon
* Web Services resources under the specified subnets. If not specified, App Runner
* uses the default security group of the Amazon VPC. The default security group
* allows all outbound traffic.</p>
*/
inline VpcConnector& AddSecurityGroups(const char* value) { m_securityGroupsHasBeenSet = true; m_securityGroups.push_back(value); return *this; }
/**
* <p>The current state of the VPC connector. If the status of a connector revision
* is <code>INACTIVE</code>, it was deleted and can't be used. Inactive connector
* revisions are permanently removed some time after they are deleted.</p>
*/
inline const VpcConnectorStatus& GetStatus() const{ return m_status; }
/**
* <p>The current state of the VPC connector. If the status of a connector revision
* is <code>INACTIVE</code>, it was deleted and can't be used. Inactive connector
* revisions are permanently removed some time after they are deleted.</p>
*/
inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
/**
* <p>The current state of the VPC connector. If the status of a connector revision
* is <code>INACTIVE</code>, it was deleted and can't be used. Inactive connector
* revisions are permanently removed some time after they are deleted.</p>
*/
inline void SetStatus(const VpcConnectorStatus& value) { m_statusHasBeenSet = true; m_status = value; }
/**
* <p>The current state of the VPC connector. If the status of a connector revision
* is <code>INACTIVE</code>, it was deleted and can't be used. Inactive connector
* revisions are permanently removed some time after they are deleted.</p>
*/
inline void SetStatus(VpcConnectorStatus&& value) { m_statusHasBeenSet = true; m_status = std::move(value); }
/**
* <p>The current state of the VPC connector. If the status of a connector revision
* is <code>INACTIVE</code>, it was deleted and can't be used. Inactive connector
* revisions are permanently removed some time after they are deleted.</p>
*/
inline VpcConnector& WithStatus(const VpcConnectorStatus& value) { SetStatus(value); return *this;}
/**
* <p>The current state of the VPC connector. If the status of a connector revision
* is <code>INACTIVE</code>, it was deleted and can't be used. Inactive connector
* revisions are permanently removed some time after they are deleted.</p>
*/
inline VpcConnector& WithStatus(VpcConnectorStatus&& value) { SetStatus(std::move(value)); return *this;}
/**
* <p>The time when the VPC connector was created. It's in Unix time stamp
* format.</p>
*/
inline const Aws::Utils::DateTime& GetCreatedAt() const{ return m_createdAt; }
/**
* <p>The time when the VPC connector was created. It's in Unix time stamp
* format.</p>
*/
inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
/**
* <p>The time when the VPC connector was created. It's in Unix time stamp
* format.</p>
*/
inline void SetCreatedAt(const Aws::Utils::DateTime& value) { m_createdAtHasBeenSet = true; m_createdAt = value; }
/**
* <p>The time when the VPC connector was created. It's in Unix time stamp
* format.</p>
*/
inline void SetCreatedAt(Aws::Utils::DateTime&& value) { m_createdAtHasBeenSet = true; m_createdAt = std::move(value); }
/**
* <p>The time when the VPC connector was created. It's in Unix time stamp
* format.</p>
*/
inline VpcConnector& WithCreatedAt(const Aws::Utils::DateTime& value) { SetCreatedAt(value); return *this;}
/**
* <p>The time when the VPC connector was created. It's in Unix time stamp
* format.</p>
*/
inline VpcConnector& WithCreatedAt(Aws::Utils::DateTime&& value) { SetCreatedAt(std::move(value)); return *this;}
/**
* <p>The time when the VPC connector was deleted. It's in Unix time stamp
* format.</p>
*/
inline const Aws::Utils::DateTime& GetDeletedAt() const{ return m_deletedAt; }
/**
* <p>The time when the VPC connector was deleted. It's in Unix time stamp
* format.</p>
*/
inline bool DeletedAtHasBeenSet() const { return m_deletedAtHasBeenSet; }
/**
* <p>The time when the VPC connector was deleted. It's in Unix time stamp
* format.</p>
*/
inline void SetDeletedAt(const Aws::Utils::DateTime& value) { m_deletedAtHasBeenSet = true; m_deletedAt = value; }
/**
* <p>The time when the VPC connector was deleted. It's in Unix time stamp
* format.</p>
*/
inline void SetDeletedAt(Aws::Utils::DateTime&& value) { m_deletedAtHasBeenSet = true; m_deletedAt = std::move(value); }
/**
* <p>The time when the VPC connector was deleted. It's in Unix time stamp
* format.</p>
*/
inline VpcConnector& WithDeletedAt(const Aws::Utils::DateTime& value) { SetDeletedAt(value); return *this;}
/**
* <p>The time when the VPC connector was deleted. It's in Unix time stamp
* format.</p>
*/
inline VpcConnector& WithDeletedAt(Aws::Utils::DateTime&& value) { SetDeletedAt(std::move(value)); return *this;}
private:
Aws::String m_vpcConnectorName;
bool m_vpcConnectorNameHasBeenSet;
Aws::String m_vpcConnectorArn;
bool m_vpcConnectorArnHasBeenSet;
int m_vpcConnectorRevision;
bool m_vpcConnectorRevisionHasBeenSet;
Aws::Vector<Aws::String> m_subnets;
bool m_subnetsHasBeenSet;
Aws::Vector<Aws::String> m_securityGroups;
bool m_securityGroupsHasBeenSet;
VpcConnectorStatus m_status;
bool m_statusHasBeenSet;
Aws::Utils::DateTime m_createdAt;
bool m_createdAtHasBeenSet;
Aws::Utils::DateTime m_deletedAt;
bool m_deletedAtHasBeenSet;
};
} // namespace Model
} // namespace AppRunner
} // namespace Aws
| [
"[email protected]"
] | |
f0f1efba07ae742bf19113c126de3ced117f16df | 63c7c7e07cf23aa82b6a61a516174da63504f095 | /暑期训练考核/c.cpp | 801778ba0274e0459eff77af483fdae938d0693c | [] | no_license | Linfanty/Code-in-Freshman | 3b174b6fab510dc1aa214d760f050ca1618afc8d | b60b99f520c4740c6b8306880680a610f054f403 | refs/heads/master | 2021-01-24T12:37:29.255747 | 2018-02-27T15:10:29 | 2018-02-27T15:10:29 | 123,144,148 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,172 | cpp | #include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <string>
#include <cstring>
typedef long long ll;
#define inf 0x3f3f3f3f
#define mem(a, b) memset(a, b, sizeof(a))
#define fin freopen("in.txt", "r", stdin)
#define fout freopen("out.txt", "w", stdout)
#define scd(a) scanf("%d",&a);
#define prd(a) printf("%d\n", a);
using namespace std;
const int maxn = 100005;
int n, m;
int hi[maxn];
bool check(int mid)
{
int hi_score = 0, ho_score = 0, ho = 0;
for(int i = 0; i < n; ++i)
{
ho = ho + mid;
if( ho <= hi[i])
++hi_score, ho = 0;
else
++ho_score, ho = ho - hi[i];
}
if( ho_score > hi_score )
return true;
else return false;
}
int main()
{
while( scanf("%d %d",&n, &m) != EOF)
{
int ans = 0, low = 0, high = m+1;
for(int i = 0; i < n; ++i)
scd(hi[i]);
while( low <= high)
{
int mid = (low + high) >> 1;
if( check(mid) )
{
ans = mid ;
high = mid - 1;
}
else low = mid + 1;
}
prd(ans);
}
}
| [
"[email protected]"
] | |
14f55afce81ea2fc2d4a3f0dc742ae02a6c784ba | a164db76288764d3a4f7fd915cd4b69a80e5a35f | /Unidade01/Atividades/toad_race/src/main.cpp | eb041a093271e39b94e253696a38e0cd55511c6d | [
"WTFPL"
] | permissive | filipegmedeiros/IMD0030-LP1 | 484ee000767e79896f8c81e63e59f0eddcb3059a | 86fedf63e2c3f7b563d64e47d448dc0c24d1acaf | refs/heads/master | 2020-04-22T23:19:54.480891 | 2019-03-31T17:00:03 | 2019-03-31T17:00:03 | 170,738,114 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 346 | cpp | /*
? -------------------------------------------
! file main.cpp
! author Filipe Medeiros and Sara Beatriz.
? news Change Coding-sytle, clean main.
@ date 12/03/2019
? -------------------------------------------
*/
#include "toad.h"
int Toad::SizeOfTrack = 100;
int main(int argc, char *argv[])
{
Race(Toad::SizeOfTrack);
return 0;
} | [
"[email protected]"
] | |
7e2bb52cf6c67365a976c3715253af5715866c0f | 367be98d4ed7dde14d05f988c1606aaa60a60eb3 | /sstmac/software/launch/allocation_strategy.h | ce717b73f47ef01db3696c67a180c4b13cabd98d | [
"BSD-3-Clause"
] | permissive | nlslatt/sst-macro | acd3f043468cd13ab0843dff85493737ea5a843f | c0feb7e8d12bde3f0b1a505452276473f9b07ca3 | refs/heads/master | 2021-01-15T12:15:40.773962 | 2016-04-07T21:30:26 | 2016-04-07T21:39:55 | 59,328,703 | 0 | 0 | null | 2016-05-20T21:54:18 | 2016-05-20T21:54:17 | null | UTF-8 | C++ | false | false | 2,580 | h | /*
* This file is part of SST/macroscale:
* The macroscale architecture simulator from the SST suite.
* Copyright (c) 2009 Sandia Corporation.
* This software is distributed under the BSD License.
* Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
* the U.S. Government retains certain rights in this software.
* For more information, see the LICENSE file in the top
* SST/macroscale directory.
*/
#ifndef SSTMAC_BACKENDS_NATIVE_LAUNCH_ALLOCATIONSTRATEGY_H_INCLUDED
#define SSTMAC_BACKENDS_NATIVE_LAUNCH_ALLOCATIONSTRATEGY_H_INCLUDED
#include <sstmac/common/rng.h>
#include <sstmac/common/node_address.h>
#include <sstmac/backends/common/parallel_runtime_fwd.h>
#include <sstmac/hardware/topology/topology_fwd.h>
#include <sstmac/hardware/interconnect/interconnect_fwd.h>
#include <sprockit/factories/factory.h>
#include <sprockit/debug.h>
#include <sprockit/sim_parameters_fwd.h>
#include <set>
DeclareDebugSlot(allocation);
namespace sstmac {
namespace sw {
/**
* Strategy type for assigning processes to nodes in a parallel run.
*
*/
class allocation_strategy : public sprockit::factory_type
{
protected:
typedef std::set<node_id> node_set;
public:
virtual void
init_param1(parallel_runtime* rt){
rt_ = rt;
}
/**
@return The topology being allocated from
*/
hw::topology*
topol() const {
return topology_;
}
void
set_interconnect(hw::interconnect* ic);
virtual void
set_topology(hw::topology* top) {
topology_ = top;
}
virtual void
init_factory_params(sprockit::sim_parameters *params);
virtual std::string
to_string() const {
return "allocation strategy";
}
virtual
~allocation_strategy() throw ();
/** Get nodes.
@param nnode number of nodes requested
@param allocation returns the nodes that have been allocated
@throw value_error If not enough nodes are available, then this will throw.
Nodes are removed from available and put into allocated.
*/
virtual void
allocate(int nnode, node_set& allocation) = 0;
/**
Release a set of nodes back into the allocation
@param alloc The nodes to deallocate
*/
virtual void
release(const node_set& alloc);
protected:
allocation_strategy() :
rt_(0), interconn_(0), topology_(0) {}
void validate_num_nodes(int num_nodes, const char* type);
protected:
hw::topology* topology_;
hw::interconnect* interconn_;
parallel_runtime* rt_;
};
DeclareFactory1InitParam(allocation_strategy, parallel_runtime*);
}
} // end of namespace sstmac
#endif
| [
"[email protected]"
] | |
6c582112431a7d2204796cf1a1a16d67b98dc61a | 1a3b7e83945942e5b25572f31c98e689ba8bab08 | /src/Step5Archive/Test/oldtests.cpp | 0fc3649ba2c89314bc162e5581bc407cb50eec78 | [] | no_license | 70MM13/Step5Archive | 9cc90d51a9ba572dcb5d1d0b124bf5d04e6c0367 | 228a402b89742c677e4fd86280c6841edc805095 | refs/heads/main | 2022-12-26T03:31:02.070326 | 2020-10-14T20:18:56 | 2020-10-14T20:18:56 | 302,458,359 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,084 | cpp | #include "../Step5Archive.h"
#include "Test.brc"
namespace Upp {
StringStream uncompressed_stream;
StringStream compressed_stream;
void TestCodecBrc()
{
MemStream brc_stream(s5demopx_ini, s5demopx_ini_length);
LOG("*** UnCompressing...");
DecodeStream (brc_stream, uncompressed_stream);
if (codec_error) LOG(Format("*** AcsClass ERROR= 0x%X", codec_error));
LOG("*** UnCompressed: ***");
LOG(uncompressed_stream.GetResult());
LOG("*** Compressing...");
uncompressed_stream.Seek(0);
compressed_stream.Seek(0);
EncodeStream (uncompressed_stream, compressed_stream);
if (codec_error) LOG(Format("*** AcsClass ERROR= 0x%X", codec_error));
String s(s5demopx_ini, s5demopx_ini_length);
if (s == compressed_stream.GetResult()) LOG("*** verification ok");
else LOG("*** verification FAILED");
}
// From Autotest/StringStream
String RandomString(int n)
{
String h;
while(n-- > 0)
h.Cat((byte)Random());
return h;
}
void TestCodecRandom()
{
// From Autotest/StringStream
StringStream ss;
String es;
int time0 = msecs();
int i = 0;
float insize=0, outsize=0;
float ratio;
/**/while(msecs(time0) < 150000) {
if(++i % 10 == 0)
{
ratio = (outsize/insize)*100;
Cout() << i << " : " << insize << "->" << outsize << ", " << Format("%.2f", ratio) << "\%\r\n";
insize = 0;
outsize = 0;
}
Cout() << ".";
Cout().Flush();
int p = Random(1000);
String h = RandomString(p);
ss.Put(h);
es.Cat(h);
ss.Seek(0);
compressed_stream.Create();
EncodeStream (ss, compressed_stream);
ASSERT(codec_error==0);
compressed_stream.Seek(0);
uncompressed_stream.Create();
DecodeStream(compressed_stream, uncompressed_stream);
ASSERT(codec_error==0);
insize+= uncompressed_stream.GetSize();
outsize+= compressed_stream.GetSize();
h = uncompressed_stream.GetResult();
ASSERT(h == es);
/**/ }
if(Random(15) == 0) {
// ss.Create();
// es.Clear();
}
// LOGHEXDUMP(es, es.GetCount());
LOG("========= OK");
}
} | [
"[email protected]"
] | |
11208b02a3c1c42d45ebf9912e1768940bb28ef2 | 74829184a9f043f0eb564d9ade74c032feee3656 | /game/Player.h | d6941c8fc13fc742d203a8798d5fa3ee577d2dfb | [] | no_license | LNU-PMi-1-2020/seventy-five-percent | 62ef7a226f733983922a4cf59c3128b56ef363d0 | a49e7fc81a9981b9734700c1567bf1c843b515fc | refs/heads/main | 2023-04-21T00:57:49.161944 | 2021-05-20T11:02:28 | 2021-05-20T11:02:28 | 347,707,315 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 384 | h | #ifndef SEVENTY_FIVE_PERCENT_PLAYER_H
#define SEVENTY_FIVE_PERCENT_PLAYER_H
#include <set>
class Player {
private:
Player() = default;
public:
bool newGame = true;
std::set<size_t> ownedCards;
static Player &get();
Player &operator=(Player &) = delete;
Player(const Player &) = delete;
void loadPlayer();
};
#endif //SEVENTY_FIVE_PERCENT_PLAYER_H
| [
"[email protected]"
] | |
a72469ee3d054a01c7e2c9a3faf36362ee56a1f0 | 1ae742dadb02e7770a5dbd7d64e9899e30704c13 | /src/models/ChartModel.cpp | bcf92a7b60fc9b371e782051b7f9bc516ac9a240 | [] | no_license | RoboTeamTwente/roboteam_monitor | d4ce988edd48737f8b1c028c14d887251fb2d2b7 | af3ac4db3bf5fb7ac1dfda2fe732ece262201b71 | refs/heads/master | 2020-09-12T03:02:23.005579 | 2020-03-02T17:55:23 | 2020-03-02T17:55:23 | 222,280,001 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 24 | cpp | #include "ChartModel.h"
| [
"[email protected]"
] | |
d81d993d8c656e4c37b7f7cc9f91abaef98fe3aa | 6d44aaf6199100420bafc894f1f5d2f66997c6e6 | /test/test-200-types/sources/tools/types/common/is_const_data/test-is_const_data.cpp | af9cb8a0258954b1a83ef58956da14c0adefb7f5 | [
"MIT"
] | permissive | Kartonagnick/tools-types | 0efee36a9649a432511eae8d0d502a4193d1dbb8 | 4b3a697e579050eade081b82f9b96309fea8f5e7 | refs/heads/master | 2023-04-30T08:59:12.607088 | 2021-05-07T19:59:07 | 2021-05-07T19:59:07 | 340,642,238 | 0 | 0 | MIT | 2021-05-07T19:59:08 | 2021-02-20T11:51:21 | C++ | UTF-8 | C++ | false | false | 4,395 | cpp | // [2020y-02m-20d][18:40:18] Idrisov Denis R.
// [2021y-04m-08d][03:09:44] Idrisov Denis R.
#include <mygtest/modern.hpp>
#ifdef TEST_TOOLS_IS_CONST_DATA
#include <tools/features.hpp>
#ifdef dHAS_CPP11
#define dTEST_COMPONENT tools, types, common
#define dTEST_METHOD is_const_data
#define dTEST_TAG tdd
#include <tools/types/common.hpp>
#include <string>
#include <memory>
//==============================================================================
//=== make_test ================================================================
namespace
{
#define dexpression(type, expected) \
::tools::is_const_data<type>::value == expected
#define make_test(type, expected) \
static_assert( \
dexpression(type, expected), \
"tools::is_const_data<" #type ">::value " \
"must be '" #expected "'" \
)
::std::string val;
using shared
= ::std::shared_ptr<int>;
// --- ignore top-level const
struct bar { int operator*(); };
struct sample { int* const& operator*(); };
struct foo { const int& operator*(); };
bar b;
using t = decltype(*b);
// | type | expected |
make_test(int const , true );
make_test(const int , true );
make_test(const int& , true );
make_test(const int* , true );
make_test(const int* const , true );
make_test(const int*& , true );
make_test(const int[1] , true );
make_test(const int(&)[1] , true );
make_test(const int(*)[1] , true );
make_test(int* const , false );
make_test(decltype(val.cbegin()) , true );
make_test(decltype(val.begin()) , false );
make_test(const shared , false );
make_test(shared , false );
make_test(const sample , true );
make_test(sample , true );
make_test(foo , true );
make_test(const foo , true );
make_test(bar , false );
make_test(decltype(*b) , false );
template<class s, dfor_const_data(s)>
constexpr bool new_consept(s&&) noexcept
{ return true; }
template<class s, dfor_not_const_data(s)>
constexpr bool new_consept(s&&) noexcept
{ return false; }
template<class s>
constexpr dif_const_data(s, bool)
old_consept(s&&) noexcept
{ return true; }
template<class s>
constexpr dif_not_const_data(s, bool)
old_consept(s&&) noexcept
{ return false; }
char arr[] = "";
const char carr[] = "";
static_assert(!new_consept(arr), "bug");
static_assert(new_consept(carr), "bug");
static_assert(!old_consept(arr), "bug");
static_assert(old_consept(carr), "bug");
} // namespace
//==============================================================================
TEST_COMPONENT(000)
{
const shared sh(new int(1));
int& ref = *sh; // <--- result is non-const-data
ASSERT_TRUE(ref == 1);
}
namespace
{
struct some { int operator*(); };
struct csome { int* const& operator*(); };
struct bsome { const int* operator*(); };
struct dsome { const int& operator*(); };
struct fsome { const some operator*(); };
struct gsome { const some& operator*(); };
struct dummy;
} // namespace
TEST_COMPONENT(001)
{
// | type | expected |
make_test(const char* , true );
make_test(char* const , false );
make_test(const some , true ); // <--- can not dereferencable, but it is const
make_test(csome , true );
make_test(bsome , false );
make_test(dsome , true );
make_test(fsome , true );
make_test(gsome , true );
make_test(dummy , false );
make_test(const dummy , true );
make_test(const int , true );
}
//==============================================================================
//==============================================================================
#endif // !dHAS_CPP11
#endif // !TEST_TOOLS_IS_CONST_DATA
| [
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.