blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 2
247
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
57
| license_type
stringclasses 2
values | repo_name
stringlengths 4
111
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringlengths 4
58
| visit_date
timestamp[ns]date 2015-07-25 18:16:41
2023-09-06 10:45:08
| revision_date
timestamp[ns]date 1970-01-14 14:03:36
2023-09-06 06:22:19
| committer_date
timestamp[ns]date 1970-01-14 14:03:36
2023-09-06 06:22:19
| github_id
int64 3.89k
689M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 25
values | gha_event_created_at
timestamp[ns]date 2012-06-07 00:51:45
2023-09-14 21:58:52
⌀ | gha_created_at
timestamp[ns]date 2008-03-27 23:40:48
2023-08-24 19:49:39
⌀ | gha_language
stringclasses 159
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 7
10.5M
| extension
stringclasses 111
values | filename
stringlengths 1
195
| text
stringlengths 7
10.5M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
40e82669b6d6618c8c81f810730802160b113144
|
8413273bab84228dad6ff5247f6d581b7796d142
|
/sample/sdl/bomberman/PlatformerObject.h
|
088db1c98a62f6f81523edfde4673a5403df064f
|
[] |
no_license
|
pdpdds/yuzaos
|
91b6f5bb51583da3827594489fc700821bc5cd6a
|
ce3b6d0907f7be470fcbc408382a20e2b75e9ef2
|
refs/heads/master
| 2023-05-01T09:51:21.007740
| 2023-04-27T08:37:42
| 2023-04-27T08:37:42
| 289,303,507
| 28
| 5
| null | 2021-03-20T14:58:37
| 2020-08-21T15:30:10
|
C
|
UTF-8
|
C++
| false
| false
| 1,484
|
h
|
PlatformerObject.h
|
//
// SDLGameObject.h
// SDL Game Programming Book
//
// Created by shaun mitchell on 19/01/2013.
// Copyright (c) 2013 shaun mitchell. All rights reserved.
//
#ifndef __SDL_Game_Programming_Book__SDLGameObject__
#define __SDL_Game_Programming_Book__SDLGameObject__
#include <SDL.h>
#include "GameObject.h"
class PlatformerObject : public GameObject
{
RTTI_DECLARATIONS(PlatformerObject, GameObject)
public:
virtual ~PlatformerObject() {}
virtual void Load(LoaderParams& params);
virtual void Draw();
virtual void Update();
virtual void Clean() {}
virtual void Collision() {}
virtual std::string type() { return "SDLGameObject"; }
int GetSpeed(){ return m_moveSpeed; }
void SetSpeed(int speed){ m_moveSpeed = speed; }
protected:
PlatformerObject();
bool checkCollideTile(Vector2D newPos);
virtual bool CheckCollision(GameObject* gameObject) override;
int CheckCollideTileType(Vector2D& newPos);
bool BreakTile(Vector2D newPos);
void doDyingAnimation();
int m_bulletFiringSpeed;
int m_bulletCounter;
int m_moveSpeed;
// how long the death animation takes, along with a counter
int m_dyingTime;
int m_dyingCounter;
// has the explosion sound played?
bool m_bPlayedDeathSound;
bool m_bFlipped;
bool m_bRunning;
Vector2D m_lastSafePos;
};
#endif /* defined(__SDL_Game_Programming_Book__SDLGameObject__) */
|
a2050215e8aa56b200b10a6db422cbc01251ab15
|
beb4e2be58abe6112cbd13f1173084f62e2439e7
|
/p2/Cuasi-Práctica 2/Parser.cpp
|
d9e7f4b65e2af47d04e034b363735493da2ef869
|
[] |
no_license
|
adlopor/Redes
|
3de81a3d2151700c0d73ef7d533e7b3aca01096a
|
7f6f5109fe880de7de319cec2320b0c152bc0dac
|
refs/heads/master
| 2020-08-08T15:07:06.115126
| 2019-10-09T07:53:53
| 2019-10-09T07:53:53
| 213,854,975
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 436
|
cpp
|
Parser.cpp
|
void parser(char * linea_comandos, std::string fichero_usuarios){
char opcion[256], resto[256];
int aux;
sscanf(linea_comandos, "%s %s", opcion, resto);
if(opcion == "REGISTRO"){
sscanf(resto, " -u %s -p %s", usuario, password);
if(registro_usuario(fichero_usuarios, usuario, password)){
std::cout<<"+Ok. Usuario registrado.\n";
}else{
std::cout<<"-Err. El usuario ya existe.\n";
}
}
return;
}
|
9f2fc1c22d0d4a649ca143303b8f339169c963ae
|
7cfde5f55477a33232f218e877037b07b55f689e
|
/src/scoreboard/overlay_scoreboard.cpp
|
41ecfcff41d35dab93c90e51bb1557b36a57b436
|
[] |
no_license
|
libretro-fork/daphne-libretro
|
aa90a9581962e2433fbfb86a2912e50e3c2952b5
|
dad8599a204b0f917126180c4be115cb0ba85814
|
refs/heads/master
| 2020-03-16T23:49:48.575743
| 2018-05-12T14:20:46
| 2018-05-12T14:20:46
| 133,092,968
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,213
|
cpp
|
overlay_scoreboard.cpp
|
#include "overlay_scoreboard.h"
#include "../video/video.h" // for draw_string
#include "../main_android.h"
#define OVERLAY_LED_WIDTH 8
#define OVERLAY_LED_HEIGHT 13
void OverlayScoreboard::DeleteInstance()
{
delete this;
}
void OverlayScoreboard::Invalidate()
{
m_bNeedsRepaint = true;
}
bool OverlayScoreboard::RepaintIfNeeded()
{
bool bRepainted = false;
if (m_bNeedsRepaint)
{
SDL_Surface *pSurface = m_pFuncGetActiveOverlay();
// if the overlay is visible
if (m_bVisible)
{
// for Dragon's Lair/Space Ace
if (!m_bThayers)
{
// Draw all DL/SA scoreboard labels.
// Credits Label
draw_string("Credits", pSurface->w / 12 - (pSurface->w == 360 ? 4 : 3), 0, pSurface);
// Player labels.
draw_string("Player 1: ", 1, 0, pSurface);
draw_string("Player 2: ", pSurface->w / 6 - 19, 0, pSurface);
// Lives labels.
draw_string("Lives: ", 1, 1, pSurface);
// 2017.11.08 - RJS - reorient draw_string("Lives: ", pSurface->w / 6 - 10, 1, pSurface);
draw_string("Lives: ", pSurface->w / 6 - 19, 1, pSurface);
// Update Player Scores
update_player_score(pSurface, 0, 0, m_DigitValues + this->PLAYER1_0, 6);
update_player_score(pSurface, 1, 0, m_DigitValues + this->PLAYER2_0, 6);
// Update Player Lives
update_player_lives(pSurface, 0, m_DigitValues[this->LIVES0]);
update_player_lives(pSurface, 1, m_DigitValues[this->LIVES1]);
}
// for Thayer's Quest
else
{
// Thayer's Quest only uses "Credits" portion of the DL/SA
// scoreboard.
draw_string("Time", pSurface->w / 12 - 2, 0, pSurface);
}
// Update Credits
update_credits(pSurface);
}
else
{
SDL_FillRect(pSurface, NULL, 0);
}
bRepainted = true;
m_bNeedsRepaint = false;
}
return bRepainted;
}
void OverlayScoreboard::update_player_score (SDL_Surface *pSurface, int player, int start_digit, unsigned int values[], int num_digits)
{
int x = start_digit * OVERLAY_LED_WIDTH;
// Player1 position is static, but Player2 will be affected
// by different MPEG widths (640x480, 720x480 known so far).
x += (player == 0 ? 65 : pSurface->w - 7 * OVERLAY_LED_WIDTH);
// LOGI("In OverlayScoreboard::update_player_score. P: %d Digits: %d%d%d%d%d%d", player, values[start_digit + 0], values[start_digit + 1], values[start_digit + 2], values[start_digit + 3], values[start_digit + 4], values[start_digit + 5]);
draw_overlay_leds(values, num_digits, x, 0, pSurface);
}
void OverlayScoreboard::update_player_lives (SDL_Surface *pSurface, int player, unsigned int lives)
{
// Value of lives was validated in caller, so charge right ahead.
draw_overlay_leds(&lives, 1,
player == 0 ? (65 + (5 * OVERLAY_LED_WIDTH)) : pSurface->w - 2 * OVERLAY_LED_WIDTH,
OVERLAY_LED_HEIGHT, pSurface);
}
void OverlayScoreboard::update_credits(SDL_Surface *pSurface)
{
int fudge;
// need to shift a bit to look exactly centered
if (m_bThayers)
{
fudge = (pSurface->w == 360 ? 4 : 3);
}
else
{
fudge = (pSurface->w == 360 ? 2 : 0);
}
draw_overlay_leds(m_DigitValues + this->CREDITS1_0, 2,
pSurface->w / 2 - (OVERLAY_LED_WIDTH + fudge),
OVERLAY_LED_HEIGHT, pSurface);
}
bool OverlayScoreboard::ChangeVisibility(bool bVisible)
{
bool bChanged = false;
// if the visibility has changed
if (bVisible != m_bVisible)
{
m_bVisible = bVisible;
m_bNeedsRepaint = true;
bChanged = true;
}
return bChanged;
}
bool OverlayScoreboard::set_digit(unsigned int uValue, WhichDigit which)
{
return set_digit_w_sae(uValue, which);
}
bool OverlayScoreboard::is_repaint_needed()
{
return m_bNeedsRepaint;
}
bool OverlayScoreboard::get_digit(unsigned int &uValue, WhichDigit which)
{
bool bRes = true;
uValue = m_DigitValues[which];
return bRes;
}
//
OverlayScoreboard::OverlayScoreboard() :
m_pFuncGetActiveOverlay(NULL),
m_bThayers(false),
m_bVisible(true)
{
}
IScoreboard *OverlayScoreboard::GetInstance(SDL_Surface *(*pFuncGetActiveOverlay)(), bool bThayers)
{
OverlayScoreboard *pInstance = new OverlayScoreboard();
pInstance->m_bThayers = bThayers;
pInstance->m_pFuncGetActiveOverlay = pFuncGetActiveOverlay;
if (!pInstance->Init())
{
pInstance->DeleteInstance();
pInstance = 0;
}
return pInstance;
}
|
8aa30fb795953279e851ce428f7a575e37767860
|
dee25a9d518640f21148900cd16af45d24ffcf2d
|
/Skechs/RN4020connecttest/RN4020connecttest.ino
|
acc35dcc80daa4d8c7d8c64abf52cb7cb738c769
|
[] |
no_license
|
shingokawaue/arduinoSketch
|
49ff218c38818bb23363db136d252e7a19521c96
|
9c89856edcf0e2846982d1a36b6ee2beb1f56c58
|
refs/heads/master
| 2020-07-24T05:13:41.085476
| 2019-09-11T13:20:15
| 2019-09-11T13:20:15
| 207,811,805
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 9,158
|
ino
|
RN4020connecttest.ino
|
const int swichLED_Pin = 4;
bool beforeConnection = false;
String str = "";
//初期化
void setup() {
pinMode(13,OUTPUT);
pinMode(swichLED_Pin,OUTPUT);
Serial.begin(9600); //USBのやつ 9600bpsで通信開始
Serial1.begin(115200); //DIGITAL0番,1番ピンをｼﾘｱﾙ通信で使用,RN4020(ｼﾝｸﾞﾙﾓｰﾄﾞBluetooth smartﾓｼﾞｭｰﾙ)と通信開始
// シリアルストリームが開いていないときには、何もしない:
while (!Serial) ;
Serial.println("始まるよ!!");
digitalWrite(13,LOW);
}
void loop() {
bool sw1, sw2;//センサー状況？
int volt;
//コマンド”Ｅ”を送る。接続出来るまで。
if(!isRN4020Connected()){
// establish_A_ConnectionRN4020();//(これを呼び出さなくてもなぜか接続出来る・・。
digitalWrite(13,LOW);
delay(5000);
beforeConnection = false;
return;
}
//接続している
if (beforeConnection == false){
Serial.println("接続してます");
beforeConnection == true;
digitalWrite(13,HIGH);
}
delay(2000);
//test
sendCommand("LC");
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("LS");
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("SS,06600000");
delay(100);
str = readAllSerial1();
Serial.println(str);
//
// sendCommand("SN,RN4020-GOMIKAS-");
// str = readAllSerial1();
// Serial.println(str);
//
// sendCommand("S-");//ClientHandleRead
// str = readAllSerial1();
// Serial.println(str);
//
//delay(100);
//
// sendCommand("SB");//ClientHandleRead
// str = readAllSerial1();
// Serial.println(str);
//delay(100);
//
// sendCommand("SDM");//ClientHandleRead
// str = readAllSerial1();
// Serial.println(str);
//delay(100);
//
// sendCommand("SDN");//ClientHandleRead
// str = readAllSerial1();
// Serial.println(str);
//
// sendCommand("SDS");//ClientHandleRead
// str = readAllSerial1();
// Serial.println(str);
//
// sendCommand("SM");//ClientHandleRead
// str = readAllSerial1();
// Serial.println(str);
//
// sendCommand("SR");//ClientHandleRead
// str = readAllSerial1();
// Serial.println(str);
//
// sendCommand("ST");//ClientHandleRead
// str = readAllSerial1();
// Serial.println(str);
sendCommand("CHR,000B");//サーバ側（Iphone）の 1810（血圧）サービスの
//2A35というｷｬﾗｸﾀﾘｽﾃｨｯｸのﾊﾝﾄﾞﾙ（アドレス）
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("CHR,001A");
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("CURC,000B");
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("CURC,2A35");
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("CURC,001A");
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("CURC,2A2B");
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("CURV,2A19");
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("SUR");
delay(100);
str = readAllSerial1();
Serial.println(str);
sendCommand("SHR");
delay(100);
str = readAllSerial1();
Serial.println(str);
//3０秒毎
delay(15 * 1000);
return; //toriaezu
//センサー類読み取り
sw1 = true;
sw2 = true;
//PIO2/PIO3の読み取り
// str = readRN4020("000D",1);//ｷｬﾗﾘﾀﾘｽﾃｨｯｸ値の読み出し
//
// if(sw_val & 0x02){//&演算子は、ビット単位で双方が共に真の場合実行。
// //ASCIIコード。0x02はSTX（テキスト開始）
// sw1 = false;
// }
// if(sw_val & 0x04){//&演算子は、ビット単位で双方が共に真の場合実行。
// //ASCIIコード。0x04はEOT（転送終了）
// sw2 = false;
// }
//
// //AIO0の読み取り
// volt = readRN4020("000B",2);
// // この辺でWiFiClientSecure使ってWebにつなげてデータをインターネットに
// // UPする処理を入れる
}
void establish_A_ConnectionRN4020(){
Serial1.println("E");//RN4020にコマンド"E"送信（接続を確立）
delay(100);
while(Serial1.available()){//ちょい待ち、なんか来たら読み込む
Serial1.read();
}
}
///////////////////////////////////////////////////////////////////////////////////////
//メソッドの定義
///////////////////////////////////////////////////////////////////////////////////////
bool isRN4020Connected(){
bool ret = false;
String line;
Serial1.println("D");//RN4020へ"設定内容をダンプ出力"コマンド
// とりあえず解析に必要な情報を受信するまで待つ
for(int i = 0; i < 50; i++)
{
delay(10);
Serial.print(i);
if(Serial1.available() <= 54){ //Serial.available():シリアルポートに何バイトのデータが到着しているかを返します
continue;
}else{
break;
}
}
if(Serial1.available() <= 54){
Serial.println("待ってもデータ来ないわ・・・・");
goto EXIT_FUNC;
}
//54バイト以上バッファがたまったら解析開始
//Ｄコマンドでダンプさせた設定内容は以下の形式になるので
//BTA=???
//Name=???
//Connected=no???
//Connected=???
line = readlnSerial1();
Serial.println(line);
if(!line.startsWith("BTA=")){ goto EXIT_FUNC; }
line = readlnSerial1();
Serial.println(line);
if(!line.startsWith("Name=")){ goto EXIT_FUNC; }
line = readlnSerial1();
Serial.println(line);
//iPhoneに接続してなくてもここまではくる
if(line.startsWith("Connected=no")){ goto EXIT_FUNC; }
if(!line.startsWith("Connected=")){ goto EXIT_FUNC; }
ret = true;
// 解析完了残りを読み捨て
EXIT_FUNC:
while(Serial1.available()){//while文は評価が偽ならばループを抜ける
Serial1.read();
}
return ret;
}
///////////////////////////////////////////////////////////////////////////////////////
void sendCommand (String str){
Serial1.println(str);
Serial.println("send Command [" + str + "] and wait 10ms");
delay(10);
}
///////////////////////////////////////////////////////////////////////////////////////
//String send_CommandRN4020(String id){
// int val = -1;
// String str;
// int retry_cnt = 0;
//
// //ゴミを捨てる
////RETRY:
// while(Serial1.available()){
// Serial1.read();
// }
// // コマンド発行
// Serial1.println("CHR," + id);//コマンド、"CHR,id" クライアント ハンドルから値を読み出し
// //ハンドルでアドレス指定してリモートデバイスからクライアント サービスの
////キャラクタリスティックの内容を読み出します。
////パラメータ(ここではid）は、クライアント サービスのキャラクタリスティック
////に対応するハンドルの16ビット16進数値です。（000Ｄ，000Ｂ）
////このコマンドは、ピアデバイスとのアクティブなリンクが存在し、ハンドル パラメー
////タが有効で、対応するキャラクタリスティックのプロパティが読み出し可能な場合の
////み有効です。戻り値は、リモートのピアデバイスから取得します。
//Serial.print("send [CHR,");
//Serial.print(id);
//Serial.print("] and wait 100ms ⇒ ");
// delay(100);
// if(Serial1.available() <= 0){
// return "RN4020_return_nothing...";
// }
//// c = Serial1.read();
//// if(c != 'R') {
//// if(retry_cnt >= 5){
//// goto EXIT_FUNC;
//// }
//// retry_cnt++;
//// goto RETRY;
//// }
////
//// c = Serial1.read();
//// if(c != ',') { goto EXIT_FUNC;}
//// val = 0;
//// for(int i = 0; i < (2 * num); i++) {
//// c = Serial1.read();
//// int tmp = 0;
//// if((c >= 'A') && (c <= 'F')){
//// tmp = c - 'A' + 10;
//// }else if((c >= '0') && (c <= '9')){
//// tmp = c - '0';
//// }
//// val = ( val << 4) + tmp;
//// }
//EXIT_FUNC:
// while(Serial1.available()){
// str = str + Serial1.read();
// }
// return str;
//}
///////////////////////////////////////////////////////////////////////////////////////
String readlnSerial1(){
String line = String("");
char c;
while(Serial1.available()){//改行0x0aで抜ける
c = Serial1.read();
if( c == 0x0A ){//改行で抜ける
break;
}
line = line + String(c);
}
return line;
}
///////////////////////////////////////////////////////////////////////////////////////
String readAllSerial1(){
String str = String("");
char c;
for(int i = 0;i < 1000;i++){
while(Serial1.available()){
c = Serial1.read();
str = str + String(c);
}
}
return str;
}
|
4295a642f62f12869eaf2c48c5854fec45c0b252
|
5673c02f4c6ddf9722c6afe53db40cd2674bed01
|
/ALL/1065.cpp
|
65d8a9c4d8ff6d4fbe14ce4ad49fdd22e7d797de
|
[] |
no_license
|
weegwangjin/baekjoon
|
5f42a4cd9091007d1299bee610b581dafe62a5c5
|
b2e857eca48d4c799a7f4103af4c043a3160a530
|
refs/heads/master
| 2021-01-12T06:25:24.198968
| 2017-12-26T05:59:33
| 2017-12-26T05:59:33
| 77,357,525
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 447
|
cpp
|
1065.cpp
|
#include <iostream>
#include <string>
using namespace std;
bool ishansu(int n) {
int bak = n / 100;
n -= bak * 100;
int sip = n / 10;
n -= sip * 10;
int one = n;
if (bak + one == 2 * sip) return true;
return false;
}
int main()
{
int num;
cin >> num;
if (num <= 99) {
cout << num << endl;
return 0;
}
int ans = 99;
for (int i = 100; i <= num; i++) {
if (i == 1000) continue;
if (ishansu(i)) ans++;;
}
cout << ans << endl;
}
|
355bb11b5cf9e7dd324a2cba1ab785c3a44f75f3
|
8cad8abc1ea14bcc0080f52594b4eeb814504507
|
/Src/EB/AMReX_WriteEBSurface.cpp
|
75a0421c94debf020ab305306bcd8a0db5912534
|
[
"BSD-3-Clause",
"BSD-2-Clause"
] |
permissive
|
AMReX-Codes/amrex
|
627370aa29f112bee3c32223b58998d3a31cf388
|
de7c6189623bc3ba178a380e703e3173f33f78ef
|
refs/heads/development
| 2023-09-01T02:12:15.348574
| 2023-08-30T17:01:15
| 2023-08-30T17:01:15
| 89,738,953
| 457
| 416
|
NOASSERTION
| 2023-09-14T07:12:15
| 2017-04-28T19:37:00
|
C++
|
UTF-8
|
C++
| false
| false
| 2,078
|
cpp
|
AMReX_WriteEBSurface.cpp
|
#include <AMReX.H>
#include <AMReX_ParmParse.H>
#include <AMReX_Geometry.H>
#include <AMReX_MultiFab.H>
#include <AMReX_MultiCutFab.H>
#include <AMReX_EBFArrayBox.H>
#include <AMReX_EB2.H>
#include <AMReX_WriteEBSurface.H>
#include <AMReX_EBToPVD.H>
namespace amrex {
void WriteEBSurface (const BoxArray & ba, const DistributionMapping & dmap, const Geometry & geom,
const EBFArrayBoxFactory * ebf) {
EBToPVD eb_to_pvd;
const Real* dx = geom.CellSize();
const Real* problo = geom.ProbLo();
MultiFab mf_ba(ba, dmap, 1, 0, MFInfo(), *ebf);
for (MFIter mfi(mf_ba); mfi.isValid(); ++mfi) {
const auto & sfab = static_cast<EBFArrayBox const &>(mf_ba[mfi]);
const auto & my_flag = sfab.getEBCellFlagFab();
const Box & bx = mfi.validbox();
if (my_flag.getType(bx) == FabType::covered ||
my_flag.getType(bx) == FabType::regular) { continue; }
std::array<const MultiCutFab *, AMREX_SPACEDIM> areafrac;
const MultiCutFab * bndrycent;
areafrac = ebf->getAreaFrac();
bndrycent = &(ebf->getBndryCent());
eb_to_pvd.EBToPolygon(
problo, dx,
bx, my_flag.const_array(),
bndrycent->const_array(mfi),
areafrac[0]->const_array(mfi),
areafrac[1]->const_array(mfi),
areafrac[2]->const_array(mfi));
}
int cpu = ParallelDescriptor::MyProc();
int nProcs = ParallelDescriptor::NProcs();
eb_to_pvd.WriteEBVTP(cpu);
if(ParallelDescriptor::IOProcessor()) {
EBToPVD::WritePVTP(nProcs);
}
for (MFIter mfi(mf_ba); mfi.isValid(); ++mfi) {
const auto & sfab = static_cast<EBFArrayBox const &>(mf_ba[mfi]);
const auto & my_flag = sfab.getEBCellFlagFab();
const Box & bx = mfi.validbox();
if (my_flag.getType(bx) == FabType::covered ||
my_flag.getType(bx) == FabType::regular) { continue; }
eb_to_pvd.EBGridCoverage(cpu, problo, dx, bx, my_flag.const_array());
}
}
}
|
14418789f71fc33a2c1f1772517c5a93170a1e89
|
4065c8f9ea9b8dfa52cc029a7d3f3402c40638c6
|
/TPS/Modal.h
|
d8f28cad3f44eb213c7d999390e401fad6987ec6
|
[] |
no_license
|
yongdono/Panasee
|
4fd5ffa048aa4d12e745464736b8811a08fb17d1
|
cade89049e22c8866aa9f04dabbbb9388f3e99cd
|
refs/heads/master
| 2021-08-31T11:22:04.899654
| 2017-12-21T03:51:56
| 2017-12-21T03:51:56
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,083
|
h
|
Modal.h
|
// Modal.h: interface for the CModal class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_MODAL_H__6CD9FCB8_068F_4BEA_BB44_C5DD2D726CF6__INCLUDED_)
#define AFX_MODAL_H__6CD9FCB8_068F_4BEA_BB44_C5DD2D726CF6__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "TpsGlobalConst.h"
#include "vtkActor.h"
#include "vtkVolume.h"
#include "globalDef.h"
class CModal
{
public:
CModal();
virtual ~CModal();
virtual void clear();
virtual BOOL readContent(FILE* file);
virtual BOOL save(FILE* file);
BOOL readHeader(FILE* file,MODALTYPE &modalType);
CString m_name;
HTREEITEM m_treeItem;
COLORREF m_color;
ZONETYPE m_zType;
double m_volume;
int m_opacity;
vtkActor *m_actor;
vtkVolume* m_pVolume;
MODALTYPE m_modalType;
protected:
vtkActor* GenerateMesh(vtkImageData *pImage, MESH_OPTIONS option);
private:
vtkActor* GenerateActor(vtkPolyData *polyData, MESH_OPTIONS option);
BOOL saveHeader(FILE* file);
};
#endif // !defined(AFX_MODAL_H__6CD9FCB8_068F_4BEA_BB44_C5DD2D726CF6__INCLUDED_)
|
2e8a9c07944ff33db37a2513fb4088843449f745
|
4787ec00fc613eaa77256f35056bc6ad32a177dd
|
/course_work/Problem_1/IReader.h
|
254677194454759a1133e60313ebdf661de10fc6
|
[
"MIT"
] |
permissive
|
pavelhristov/cplusplus
|
ad1c63b060a0ceedff6f7b8f0561837b2fe3f0ce
|
3731815fd5681cbc53b4415e2df2f42fc74aaef1
|
refs/heads/master
| 2020-06-07T07:10:33.291003
| 2019-06-20T17:30:17
| 2019-06-20T17:30:17
| 192,958,556
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 193
|
h
|
IReader.h
|
#ifndef IREADER_H
#define IREADER_H
#include <string>
#include <vector>
class Reader {
public:
virtual std::vector<std::string> readLines(int linesCount) = 0;
};
#endif /* IREADER_H */
|
f97196e106a509c55eac690362b62d72d1f4bfad
|
30e1b23df7b8e024758ce44fbf5e759fbae81d2b
|
/tests/ut/common/graph/testcase/ge_graph/ge_reg_unittest.cc
|
48e6a069386c942e2b309d45ea081a662442afad
|
[
"Apache-2.0",
"LGPL-2.1-only",
"MPL-1.0",
"MPL-2.0-no-copyleft-exception",
"GPL-2.0-only",
"BSD-3-Clause",
"AGPL-3.0-only",
"MPL-1.1",
"MPL-2.0",
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
leonwanghui/graphengine
|
dd730f91d64bb9a047e06aa9bffdde9e591ab0fc
|
534a45c714fbddf344f1260100f48b9e66735b53
|
refs/heads/master
| 2022-12-04T18:57:15.957663
| 2020-08-29T06:37:07
| 2020-08-29T06:37:07
| 291,641,909
| 1
| 0
|
Apache-2.0
| 2020-08-31T07:10:12
| 2020-08-31T07:10:11
| null |
UTF-8
|
C++
| false
| false
| 4,364
|
cc
|
ge_reg_unittest.cc
|
/**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <gtest/gtest.h>
#include <iostream>
#define protected public
#define private public
#include "graph/graph.h"
#include "graph/model.h"
#include "graph/utils/tensor_utils.h"
#include "ops_stub.h"
#undef protected
#undef private
using namespace std;
using namespace ge;
class UtestGeOperatorReg : public testing::Test {
protected:
void SetUp() {}
void TearDown() {}
};
TEST_F(UtestGeOperatorReg, ge_test_operator_reg_test) {
TensorDesc desc(ge::Shape({1, 3, 224, 224}));
uint32_t size = desc.GetShape().GetShapeSize();
desc.SetSize(size);
auto data = op::Data("Data").set_attr_index(0);
data.update_input_desc_data(desc);
data.update_output_desc_out(desc);
auto flatten = op::Flatten("Flatten").set_input_x(data, data.name_out_out());
std::vector<Operator> inputs{data};
std::vector<Operator> outputs{flatten};
std::vector<Operator> targets{flatten};
Graph graph("test_graph");
graph.SetInputs(inputs).SetOutputs(outputs).SetTargets(targets);
EXPECT_EQ(true, graph.IsValid());
Graph graph1("test_graph1");
auto data1 = op::Data("Data1").set_attr_index(0);
data1.update_input_desc_data(desc);
data1.update_output_desc_out(desc);
std::vector<Operator> targets1{data1};
graph1.SetInputs(inputs).SetTargets(targets1);
}
TEST_F(UtestGeOperatorReg, test_set_outputs) {
TensorDesc desc(ge::Shape({1, 3, 224, 224}));
uint32_t size = desc.GetShape().GetShapeSize();
desc.SetSize(size);
auto data = op::Data("Data").set_attr_index(0);
data.update_input_desc_data(desc);
data.update_output_desc_out(desc);
auto flatten = op::Flatten("Flatten").set_input_x(data, data.name_out_out());
std::vector<Operator> inputs{data};
std::vector<Operator> targets{flatten};
std::vector<pair<Operator, string>> outputs{{flatten, "Flattern"}};
Graph graph("test_graph");
graph.SetInputs(inputs).SetOutputs(outputs).SetTargets(targets);
EXPECT_EQ(true, graph.IsValid());
}
TEST_F(UtestGeOperatorReg, test_setoutputs_node_not_exist) {
TensorDesc desc(ge::Shape({1, 3, 224, 224}));
uint32_t size = desc.GetShape().GetShapeSize();
desc.SetSize(size);
auto data0 = op::Data("Data0").set_attr_index(0);
data0.update_input_desc_data(desc);
data0.update_output_desc_out(desc);
auto data1 = op::Data("Data1").set_attr_index(0);
data1.update_input_desc_data(desc);
data1.update_output_desc_out(desc);
std::vector<Operator> inputs{data0};
std::vector<Operator> outputs{data1};
Graph graph("test_graph");
graph.SetInputs(inputs).SetOutputs(outputs);
}
bool buildGraph1(Graph &graph) {
auto data = op::Data("data").set_attr_index(0);
graphStatus ret = graph.AddOp(data);
EXPECT_EQ(GRAPH_SUCCESS, ret);
auto flatten = op::Flatten("flatten").set_input_x(data);
ret = graph.AddOp(flatten);
EXPECT_EQ(GRAPH_SUCCESS, ret);
return true;
}
TEST_F(UtestGeOperatorReg, test_add_op) {
Graph graph("simpleGraph");
bool ret_graph = buildGraph1(graph);
EXPECT_EQ(ret_graph, true);
std::vector<string> op_name;
graphStatus ret = graph.GetAllOpName(op_name);
EXPECT_EQ(GRAPH_SUCCESS, ret);
for (unsigned int i = 0; i < op_name.size(); i++) {
std::cout << "opname: " << op_name[i] << std::endl;
}
EXPECT_EQ(op_name.size(), 2);
Operator op;
ret = graph.FindOpByName("dat", op);
EXPECT_EQ(ret, GRAPH_FAILED);
ret = graph.FindOpByName("data", op);
EXPECT_EQ(ret, GRAPH_SUCCESS);
ret = graph.FindOpByName("flatten", op);
EXPECT_EQ(ret, GRAPH_SUCCESS);
Operator data_op;
(void)graph.FindOpByName("data", data_op);
Operator f_op;
(void)graph.FindOpByName("flatten", f_op);
data_op.GetOutputsSize();
std::vector<Operator> inputs{data_op};
std::vector<Operator> outputs{f_op};
graph.SetInputs(inputs).SetOutputs(outputs);
}
|
8738e754a0c263b2b7011a4f463a5ee003e838cc
|
09b612b846f15e4a7571d8d7797a8cb152e5994b
|
/utils.h
|
90fdbbb82ef5722e61005c1d7934fb09eb8ecd5c
|
[] |
no_license
|
anatcruz/FEUP-AEDA-UghEats
|
26cdca48c999c3d2eef31dfc2cf1ffe217d43538
|
b69b8d703630656bf3515d74f4959aa7c20f4e20
|
refs/heads/master
| 2021-02-03T23:48:33.277758
| 2020-01-04T20:01:38
| 2020-01-04T20:01:38
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,996
|
h
|
utils.h
|
#ifndef AEDA_UGHEATS_UTILS_H
#define AEDA_UGHEATS_UTILS_H
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <map>
using namespace std;
/** Checks if a string is made up exclusively by numbers.
* @param str is the string you want to test.
* @return true if the string is only made up by numbers.
*/
bool isNumeric(const string &str);
/** Removes whitespace from both ends of a string.
* @param str is the string you want to trim.
* @return the string passed as parameter without the whitespace at the beginning and ending.
*/
string trim(string &str);
/** Transforms a string into a vector.
* @param str is the string you want to transform.
* @param delim is the separator of the elements of the string.
* @return the vector with the elements of the string separated by delim.
*/
vector<string> strToVect(const string &str, char delim = ' ');
/** Makes a pair of coords from a string
* @param str is the string you want to transform into coords.
* @return the pair of coods.
*/
pair<float,float> makeCoords(const string str);
//Menu utilities
/** Prints a line of a specified size with a specified character.
* @param size is the size of the line.
* @param ch is the character, by default is '-'.
*/
void line(int size, char ch = '-');
/** Outputs an error message and clears cin flags.
* @param message is what you want to display.
*/
void cinERR(const string &message);
/** Tries to get a valid int option from cin to use in a switch-case.
* @param dest is the variable where you want to save the option selected.
* @param message is the message to be display before selecting an option, by default is "Option: ".
*/
void getOption(int &dest, const string &message = "Option: ");
/** Gets a valid nif input from cin
* @param nif return variable where grabbed nif is stored
* @return specifies if nif capture was successful or not
*/
bool inputNIF(int &nif, const string &message);
/** Checks if the nif is valid.
* @param nif is what you want to check.
* @return true if the nif is valid.
*/
bool validNIF(string const &nif);
/** Checks if the postcode is valid.
* @param postcode is what you want to check.
* @return true if the postcode is valid.
*/
bool validPostcode(string const &postcode);
//Just useful
/** The program waits until the user presses Enter to continue.
*/
void enterWait(const string &message = "ENTER to go back");
/** Removes the whitespaces in a string.
* @param str is the string you want to remove the whitespaces.
* @return the string without any whitespaces.
*/
string removeSpaces(string str);
/** Checks if the licence plate is valid.
* @param plate is what you want to check.
* @return true if the licence plate is valid.
*/
bool validLicensePlate(string const &plate);
#endif //AEDA_UGHEATS_UTILS_H
|
f1f5b64cdb0b44e1c532e07fff2ee5b6fd5777b0
|
af2f5806cdb788749a9987a4294a8e270aab3ec8
|
/Project/09_SnakeBite/Class/ItemManager.h
|
3a51f392e129b1f4a471c32d5e0a060f9171e862
|
[] |
no_license
|
pdpdds/SDLProgramming
|
65f53bf7a7d28952780a06b4a1b80b4a80aeea95
|
f69683aa41908f8f1b3b80b7076ca0e7908f59da
|
refs/heads/master
| 2021-01-18T22:35:12.116696
| 2020-12-31T06:22:53
| 2020-12-31T06:22:53
| 37,397,842
| 12
| 13
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 575
|
h
|
ItemManager.h
|
/**
@file ItemManager.h
@date 2013-03-03
@author 심재환(sim436@gmail.com)
@brief 아이템을 생성, 정보를 가지고 있는 클래스
*/
#pragma once
#include "common.h"
#include "SnakeGameObject.h"
class Point2D;
class ItemManager : public SnakeGameObject
{
private:
Point2D* pos; ///< 아이템의 위치
int inc; ///< 아이템의 종류(증가치)
public:
void Init();
void Update();
void Draw();
void CreateItem(); ///< 아이템을 만드는 함수
SDL_Surface* speedItem;
SDL_Surface* tailItem;
ItemManager();
~ItemManager();
};
|
e79e647e5245d8eef568517787682873b0b3afcb
|
0af827799bb94af1de233c01a67fa819d94be254
|
/question4-algorithm/question4-algorithm.cpp
|
30561bbfbb45e64c49587d3d674f89b17ad6f78e
|
[] |
no_license
|
aJoohongKim/stack-permutation
|
d296462c41990776102950b6f1dd93fb5cdb8c54
|
87e778b5e9fa6d1a86261e61fc6d987273b5d703
|
refs/heads/master
| 2020-05-05T06:35:09.853933
| 2019-04-06T05:52:51
| 2019-04-06T05:52:51
| 179,794,089
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,904
|
cpp
|
question4-algorithm.cpp
|
// question4-algorithm.cpp : 이 파일에는 'main' 함수가 포함됩니다. 거기서 프로그램 실행이 시작되고 종료됩니다.
//
#include "pch.h"
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
using namespace std;
int *base = NULL;
// https://www.geeksforgeeks.org/stack-permutations-check-if-an-array-is-stack-permutation-of-other/
bool checkStackPermutation(int ip[], int op[], int n)
{
// Input queue
queue<int> input;
for (int i = 0; i < n; i++)
input.push(ip[i]);
// output queue
queue<int> output;
for (int i = 0; i < n; i++)
output.push(op[i]);
// stack to be used for permutation
stack <int> tempStack;
while (!input.empty())
{
int ele = input.front();
input.pop();
if (ele == output.front())
{
output.pop();
while (!tempStack.empty())
{
if (tempStack.top() == output.front())
{
tempStack.pop();
output.pop();
}
else
break;
}
}
else
tempStack.push(ele);
}
// If after processing, both input queue and
// stack are empty then the input queue is
// permutable otherwise not.
return (input.empty() && tempStack.empty());
}
void swap(int *x, int *y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
void permute(int *a, int l, int r) {
int i;
if (l == r) {
if (checkStackPermutation(base, a, r+1)) {
for (i = 0; i <= r; i++) {
cout << a[i];
}
cout << endl;
}
else {
cout << endl;
}
//std::cout << a << std::endl;
}
else {
for (i = l; i <= r; i++) {
swap((a + l), (a + i));
permute(a, l + 1, r);
swap((a + l), (a + i));
}
}
}
int main()
{
int n;
while (1) {
cin >> n;
if (n == 0) {
return 0;
}
base = new int[n]();
int *seed = new int[n]();
for (int i = 0; i < n; i++) {
seed[i] = base[i] = i + 1;
}
permute(seed, 0, n-1);
cout << endl << endl;
delete[] base;
delete[] seed;
}
}
// 프로그램 실행: <Ctrl+F5> 또는 [디버그] > [디버깅하지 않고 시작] 메뉴
// 프로그램 디버그: <F5> 키 또는 [디버그] > [디버깅 시작] 메뉴
// 시작을 위한 팁:
// 1. [솔루션 탐색기] 창을 사용하여 파일을 추가/관리합니다.
// 2. [팀 탐색기] 창을 사용하여 소스 제어에 연결합니다.
// 3. [출력] 창을 사용하여 빌드 출력 및 기타 메시지를 확인합니다.
// 4. [오류 목록] 창을 사용하여 오류를 봅니다.
// 5. [프로젝트] > [새 항목 추가]로 이동하여 새 코드 파일을 만들거나, [프로젝트] > [기존 항목 추가]로 이동하여 기존 코드 파일을 프로젝트에 추가합니다.
// 6. 나중에 이 프로젝트를 다시 열려면 [파일] > [열기] > [프로젝트]로 이동하고 .sln 파일을 선택합니다.
|
5250e444e46db552d67c6e22c0aa6b8f1fd1f66c
|
1f932eed26f7b214755d00ceedd49b48cc287c91
|
/include/Basic/Types.hpp
|
35f2c16433d5b558766ce0ea04410f2bdf95a51a
|
[
"MIT"
] |
permissive
|
IrisTechnologiesOfficial/Edea
|
1d897a3a313cccdc3b1d541e5f601b51102e2133
|
252a47a32dcbf466e045363883dd00c9b2af6b38
|
refs/heads/master
| 2020-07-29T21:28:48.058534
| 2019-09-23T23:47:30
| 2019-09-23T23:47:30
| 209,968,149
| 3
| 0
| null | 2019-09-21T23:21:22
| 2019-09-21T10:45:19
|
C++
|
UTF-8
|
C++
| false
| false
| 949
|
hpp
|
Types.hpp
|
//Copyright 2019 Iris Technologies, All Rights Reserved
#pragma once
#include <cstdint>
/**
* @typedef u8
* Unsigned 8-bit integral type */
typedef std::uint8_t u8;
/**
* @typedef s8
* Signed 8-bit integral type
*/
typedef std::int8_t s8;
/**
* @typedef u16
* Unsigned 16-bit integral type
*/
typedef std::uint16_t u16;
/**
* @typedef s16
* Signed 16-bit integral type
*/
typedef std::int16_t s16;
/**
* @typedef u32
* Unsigned 32-bit integral type
*/
typedef std::uint32_t u32;
/**
* @typedef s32
* Signed 32-bit integral type
*/
typedef std::int32_t s32;
/**
* @typedef f32
* 32-bit floating-point type
*/
typedef float f32;
/**
* @typedef u64
* Unsigned 64-bit integral type
*/
typedef std::uint64_t u64;
/**
* @typedef s64
* Signed 64-bit integral type
*/
typedef std::int64_t s64;
/**
* @typedef f64
* 64-bit floating-point type
*/
typedef double f64;
|
b496d44eccd13859f5238066d7c79d23eed49a6a
|
733de464662408d2ed3fa637b0c7ecdc7c281c0a
|
/device/devices/mouse/imouse_device.h
|
e9233836f94ba70ffd33d0c1149e04b18a5602d4
|
[
"MIT"
] |
permissive
|
aconstlink/snakeoil
|
f15740eb93d3e36b656621bb57a0f7eb2592f252
|
3c6e02655e1134f8422f01073090efdde80fc109
|
refs/heads/master
| 2021-01-01T17:39:53.820180
| 2020-02-23T20:56:36
| 2020-02-23T20:56:36
| 98,117,868
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 338
|
h
|
imouse_device.h
|
//------------------------------------------------------------
// snakeoil (c) Alexis Constantin Link
// Distributed under the MIT license
//------------------------------------------------------------
#pragma once
#include "../idevice.h"
namespace so_device
{
class SNAKEOIL_DEVICE_API imouse_device : public idevice
{
};
}
|
d1eaf4dfbf79382563bbb4656fa8e432de58dc6c
|
8f671c2622ec2c4910c868b00b6d325a70679797
|
/tests/auto/cpp/users/tst_usersprofilebanner/tst_usersprofilebanner.cpp
|
7b38253381b55d605ad4ca7e6d956cc3ee8a98af
|
[
"BSD-3-Clause"
] |
permissive
|
qt-users-jp/twitter4qml
|
0f90582c8a2a0e9e8ebed92011df4b53883c1260
|
31f34a56ff392058772b0643b34dc7943aebba32
|
refs/heads/master
| 2021-01-20T19:13:21.264123
| 2015-04-17T03:47:25
| 2015-09-05T00:22:43
| 69,147,462
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,587
|
cpp
|
tst_usersprofilebanner.cpp
|
/* Copyright (c) 2012-2013 Twitter4QML Project.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Twitter4QML 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 TWITTER4QML BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "abstracttwitter4qmltest.h"
#include <usersprofilebanner.h>
class UsersProfileBannerTest : public AbstractTwitter4QMLTest
{
Q_OBJECT
private Q_SLOTS:
void profile_banner_by_user_id();
void profile_banner_by_user_id_data();
void profile_banner_by_screen_name();
void profile_banner_by_screen_name_data();
private:
void data();
};
void UsersProfileBannerTest::data()
{
QTest::addColumn<QString>("user_id");
QTest::addColumn<QString>("screen_name");
QTest::addColumn<bool>("profile_banner_is_Empty");
QTest::newRow("Tasuku Suzuki") << "119039167" << "task_jp" << false;
QTest::newRow("Kenya 888") << "15394706" << "kenya888" << true;
}
void UsersProfileBannerTest::profile_banner_by_user_id()
{
QFETCH(QString, user_id);
QFETCH(bool, profile_banner_is_Empty);
UsersProfileBanner usersProfileBanner;
usersProfileBanner.user_id(user_id);
QCOMPARE(usersProfileBanner.user_id(), user_id);
QVERIFY2(wait(&usersProfileBanner), "UsersProfileBanner::load");
QVERIFY(usersProfileBanner.web().keys().isEmpty() == profile_banner_is_Empty);
QVERIFY(usersProfileBanner.web().value(QStringLiteral("url")).isNull() == profile_banner_is_Empty);
}
void UsersProfileBannerTest::profile_banner_by_user_id_data()
{
data();
}
void UsersProfileBannerTest::profile_banner_by_screen_name()
{
QFETCH(QString, screen_name);
QFETCH(bool, profile_banner_is_Empty);
UsersProfileBanner usersProfileBanner;
usersProfileBanner.screen_name(screen_name);
QCOMPARE(usersProfileBanner.screen_name(), screen_name);
QVERIFY2(wait(&usersProfileBanner), "UsersProfileBanner::load");
QVERIFY(usersProfileBanner.web().keys().isEmpty() == profile_banner_is_Empty);
QVERIFY(usersProfileBanner.web().value(QStringLiteral("url")).isNull() == profile_banner_is_Empty);
}
void UsersProfileBannerTest::profile_banner_by_screen_name_data()
{
data();
}
QTEST_MAIN(UsersProfileBannerTest)
#include "tst_usersprofilebanner.moc"
|
412926f9ca5d6e92cb8ca18cb3201eba3ac0ebf8
|
3aa317f44322d3b4a9b46fa7a79f889ea373e2aa
|
/Project/03. Tool/TestSceneMaker.h
|
88a38674da1854bdb3d690d13cfe937570105346
|
[] |
no_license
|
oung/MapleStory-1
|
11580c7ee28337e0ba8f2cb70dcb54ab1c106f26
|
3ddbbbcd7c20a0bf835e724046be1072908b9bae
|
refs/heads/master
| 2023-08-11T11:03:52.630096
| 2021-10-07T14:00:39
| 2021-10-07T14:00:39
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 70
|
h
|
TestSceneMaker.h
|
#pragma once
class CTestSceneMaker
{
public:
static void init();
};
|
4da4765eaa4189397dca7f6106943ed285361ca9
|
4f63be3e3611466511742491cb18797ebcfd9f57
|
/shouyou/common/LibHNLobby/HNLobby/ChildLayer/GameExitChangeLayer.cpp
|
78ad1f5d2c96bcadd766329ef7be11474a484fb5
|
[] |
no_license
|
xubingyue/wulejiu
|
0a9083c08270b453dff316cc827d943908572559
|
ee71a1e299b700436f01c3acab7e4617826b9f85
|
refs/heads/master
| 2020-05-24T06:38:40.276805
| 2017-03-30T05:54:12
| 2017-03-30T05:54:12
| null | 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 3,929
|
cpp
|
GameExitChangeLayer.cpp
|
#include "HNLobby/ChildLayer/GameExitChangeLayer.h"
#include "HNLobby/PlatformDefine.h"
GameExitChangeLayer::GameExitChangeLayer()
{
onExitCallBack = nullptr;
}
GameExitChangeLayer::~GameExitChangeLayer()
{
}
void GameExitChangeLayer::showExitChoose(Node* parent, int zorder, int tag)
{
CCAssert(nullptr != parent, "parent is nullptr");
if (0 != tag)
{
parent->addChild(this, zorder, tag);
}
else
{
parent->addChild(this, zorder);
}
}
void GameExitChangeLayer::closeExitChoose()
{
HNAudioEngine::getInstance()->playEffect(GAME_SOUND_CLOSE);
exitChooseLoader->runAction(Sequence::create(ScaleTo::create(0.1f, 0.3f), CCCallFunc::create([&]()
{
this->removeFromParent();
}), nullptr));
}
bool GameExitChangeLayer::init()
{
if ( !HNLayer::init()) return false;
Size winSize = Director::getInstance()->getWinSize();
//屏蔽后面的层
colorLayer = LayerColor::create(Color4B(0, 0, 0, 100));
addChild(colorLayer);
//事件吞并
auto touchListener = EventListenerTouchOneByOne::create();
touchListener->onTouchBegan = [=](Touch* touch , Event* event){
return true;
};
touchListener->setSwallowTouches(true);
_eventDispatcher->addEventListenerWithSceneGraphPriority(touchListener, colorLayer);
exitChooseLoader = CSLoader::createNode("platform/exitChange/exitNode.csb");
exitChooseLoader->setPosition(winSize/2);
exitChooseLoader->setScale(0);
addChild(exitChooseLoader);
exitChooseLoader->runAction(ScaleTo::create(0.2f, 1));
auto exitChooseLayout = (Layout*)exitChooseLoader->getChildByName("Panel_1");
//关闭
auto chooseClose = (Button*)exitChooseLayout->getChildByName("Button_close");
chooseClose->addTouchEventListener(CC_CALLBACK_2(GameExitChangeLayer::closeExitChooseCallBack, this));
//退出
auto chooseExit = (Button*)exitChooseLayout->getChildByName("Button_exit");
chooseExit->addTouchEventListener(CC_CALLBACK_2(GameExitChangeLayer::exitCallBack, this));
//切换帐号
auto chooseSwitch = (Button*)exitChooseLayout->getChildByName("Button_switch");
chooseSwitch->addTouchEventListener(CC_CALLBACK_2(GameExitChangeLayer::switchCallBack, this));
return true;
}
void GameExitChangeLayer::closeExitChooseCallBack(Ref* pSender, Widget::TouchEventType type)
{
Button* selectedBtn = (Button*)pSender;
switch (type)
{
case cocos2d::ui::Widget::TouchEventType::BEGAN:
selectedBtn->setColor(Color3B(170, 170, 170));
break;
case cocos2d::ui::Widget::TouchEventType::ENDED:
selectedBtn->setColor(Color3B(255, 255, 255));
closeExitChoose();
break;
case cocos2d::ui::Widget::TouchEventType::CANCELED:
selectedBtn->setColor(Color3B(255, 255, 255));
break;
default:
break;
}
}
void GameExitChangeLayer::exitCallBack(Ref* pSender, Widget::TouchEventType type)
{
Button* selectedBtn = (Button*)pSender;
switch (type)
{
case cocos2d::ui::Widget::TouchEventType::BEGAN:
selectedBtn->setColor(Color3B(170, 170, 170));
break;
case cocos2d::ui::Widget::TouchEventType::ENDED:
selectedBtn->setColor(Color3B(255, 255, 255));
Director::getInstance()->end();
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
exit(0);
#elif (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
exit(0);
#elif (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
exit(0);
#endif
break;
case cocos2d::ui::Widget::TouchEventType::CANCELED:
selectedBtn->setColor(Color3B(255, 255, 255));
break;
default:
break;
}
}
void GameExitChangeLayer::switchCallBack(Ref* pSender, Widget::TouchEventType type)
{
Button* selectedBtn = (Button*)pSender;
switch (type)
{
case cocos2d::ui::Widget::TouchEventType::BEGAN:
selectedBtn->setColor(Color3B(170, 170, 170));
break;
case cocos2d::ui::Widget::TouchEventType::ENDED:
selectedBtn->setColor(Color3B(255, 255, 255));
if (nullptr != onExitCallBack)
{
onExitCallBack();
}
break;
case cocos2d::ui::Widget::TouchEventType::CANCELED:
selectedBtn->setColor(Color3B(255, 255, 255));
break;
default:
break;
}
}
|
2cf7e9749af0e5b816968a70b0de25bf5ed06402
|
d27d644ff889367d78ff9fa900d9335157313f4a
|
/DataLinkV5/devs/component/core_j3_broadcast_handler.cpp
|
a2a4627a806e5ef583bdfc1be1a9996f89fdcc06
|
[] |
no_license
|
ydar95/DataLink
|
9f1206f59f3c61608b95aebb7438b177e9c6794b
|
4cd90291d2184e8c57ab7a5dce8a89fbeb8185b5
|
refs/heads/master
| 2020-07-12T02:39:18.553134
| 2019-09-27T08:18:14
| 2019-09-27T08:18:14
| 204,695,358
| 0
| 3
| null | 2019-09-05T03:30:21
| 2019-08-27T12:11:00
|
C++
|
GB18030
|
C++
| false
| false
| 1,967
|
cpp
|
core_j3_broadcast_handler.cpp
|
#include "core_j3_broadcast_handler.hpp"
#include"../handler.hpp"
#include<algorithm>
#include"../time.hpp"
devs::component::CoreJ3BroadcastHandler::CoreJ3BroadcastHandler(Ju & ju, Digraph & _digraph, const std::string & _name, PortType _uid)
:JuComponent(ju,_digraph,_name,_uid)
{
BindSelfRecvSubTS();
}
void devs::component::CoreJ3BroadcastHandler::delta_int()
{
is_recv_ts = false;
}
void devs::component::CoreJ3BroadcastHandler::delta_ext(devs::TimeType e, const IO_Bag & xb)
{
for (auto&x : xb) {
if (x.port == GetSelfRecvSubTS()) {
is_recv_ts = true;
}
}
}
void devs::component::CoreJ3BroadcastHandler::output_func(IO_Bag & yb)
{
auto& ts = parent.time_silce;
for (auto[track_name, last_broadcast_time]/*[key,value] c++17*/ : parent.dict_r2) {
auto& attn = parent.dict_active_track[track_name];
auto broadcast_interval = GetMinBroadcastInterval(attn.track_platform);
auto next_broadcast_time_min = broadcast_interval + last_broadcast_time;
//只要 next_broadcast_time_min 小于 ts.end 就可以发.
//在根据 ts.begin 确定具体在哪个时间 发
if (next_broadcast_time_min < ts.end_time) {
auto next_broadcast_time = std::max(next_broadcast_time_min, ts.begin_time);
parent.dict_r2[track_name] = next_broadcast_time; //更新时间
//广播 J3i
yb.insert(CreatBroadcastIO(util::CreateSptrBlob(
parent.dict_active_track[track_name].get<msg::JointMsg3I>(Time::now())
)));
}
else if (last_broadcast_time == 0) {//立即发
parent.dict_r2[track_name] = Time::now();
yb.insert(CreatBroadcastIO(util::CreateSptrBlob(
parent.dict_active_track[track_name].get<msg::JointMsg3I>(Time::now())
)));
}
}
//std::cout << "time_silce:" << parent.time_silce.begin_time << "\t" << parent.time_silce.end_time << std::endl;
}
devs::TimeType devs::component::CoreJ3BroadcastHandler::ta()
{
return (is_recv_ts == false)*TIME_MAX;
}
|
dd08549adc0525ff79a5297a1227648d021877d6
|
1339f7ba46065e24effd1d8a7197339931bb8f42
|
/dp-18(canconstruct tabulation).cpp
|
a6e2906a6c8f1603ace962dc84affed9923c7e99
|
[] |
no_license
|
jahnavikolli/Dynamic.Programming
|
5dd94564fa8ca4f287889244cc562e503410646e
|
b7f45ad1273c4fc0bc402ca6395dc7d3de5d681e
|
refs/heads/main
| 2023-04-08T08:02:51.268630
| 2021-04-11T11:45:34
| 2021-04-11T11:45:34
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,071
|
cpp
|
dp-18(canconstruct tabulation).cpp
|
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
string s;
int n;
cin>>s>>n;
vector<string> v;
for(int i=0; i<n; i++)
{
string x;
cin>>x;
v.push_back(x);
}
int length=s.size()+1;
bool table[length];
memset(table,false,sizeof(table));
table[0]=true;
for(int i=0; i<length; i++)
{
if(table[i])
{
for(int j=0; j<v.size(); j++)
{
int found=s.find(v[j],i); // using find function to check the word is present in the string or not
if(found!=-1 and v[j][0]==s[i] and found>=i) // if the word is not present found will be -1
{
int value=v[j].size()+i;
table[value]=true;
}
}
}
}
if(table[length-1])cout<<"YES"<<endl;
else cout<<"NO"<<endl;
// for(int i=0;i<length;i++)cout<<table[i]<<endl;
return 0;
}
|
2cf5e39f3de29dbb6bb4cfb0226aa328c4fd95f9
|
d9c613d803bb717861bf1f03591c053caf1d5c1d
|
/GestaoDePessoas/Pessoa.hpp
|
16131abbf4707d0a3e948bd67b9d8bf3ac559bf6
|
[] |
no_license
|
CARVALHOMARCOS93/POO2021-1
|
6e3dca328a4c467db828883d4aa5c137055c8e74
|
f539fa5ad7f065d9194b79a1ce3f323e6ad58ad4
|
refs/heads/main
| 2023-06-05T08:13:47.802361
| 2021-06-20T14:32:52
| 2021-06-20T14:32:52
| 347,510,396
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 619
|
hpp
|
Pessoa.hpp
|
//
// Pessoa.hpp
// GestaoDePessoas
//
// Created by Marcos Carvalho on 13/06/21.
//
#ifndef Pessoa_hpp
#define Pessoa_hpp
#include <stdio.h>
#include <iostream>
using namespace std;
class Pessoa
{
public:
Pessoa(){};
Pessoa(string n, string e, string t);
string getNome();
string getEndereco();
string getTelefone();
void setNome(string n);
void setEndereco(string e);
void setTelefone(string t);
void imprimirDados();
virtual void atualizar(string n, string e, string t);
protected:
string nome;
string endereco;
string telefone;
};
#endif /* Pessoa_hpp */
|
b34c992c27c7000c4092471112944ffc35fa6914
|
52c98acab51455162deab677bfe5e211884989cf
|
/src/tests/class_tests/smartpeak/source/MetaDataHandler_test.cpp
|
df3822c69d60be80a7dd14156f0db8eabc54afa1
|
[
"MIT"
] |
permissive
|
ChristopherAbram/SmartPeak
|
6d997d9e5e0b4982818983a7b95b1924309aaebc
|
2851c4b43ad02e436a2dfe0f102ea0ce1e303484
|
refs/heads/develop
| 2023-03-18T15:32:48.045226
| 2021-03-15T19:48:25
| 2021-03-15T19:48:25
| 337,477,102
| 0
| 0
|
MIT
| 2021-03-15T19:51:14
| 2021-02-09T17:08:24
|
C++
|
UTF-8
|
C++
| false
| false
| 7,092
|
cpp
|
MetaDataHandler_test.cpp
|
// --------------------------------------------------------------------------
// SmartPeak -- Fast and Accurate CE-, GC- and LC-MS(/MS) Data Processing
// --------------------------------------------------------------------------
// Copyright The SmartPeak Team -- Novo Nordisk Foundation
// Center for Biosustainability, Technical University of Denmark 2018-2021.
//
// 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 ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS 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.
//
// --------------------------------------------------------------------------
// $Maintainer: Douglas McCloskey $
// $Authors: Douglas McCloskey $
// --------------------------------------------------------------------------
#define BOOST_TEST_MODULE MetaDataHandler test suite
#include <boost/test/included/unit_test.hpp>
#include <SmartPeak/core/MetaDataHandler.h>
#include <SmartPeak/core/SampleType.h>
using namespace SmartPeak;
using namespace std;
BOOST_AUTO_TEST_SUITE(metadatahandler)
BOOST_AUTO_TEST_CASE(constructor)
{
MetaDataHandler* ptr = nullptr;
MetaDataHandler* nullPointer = nullptr;
ptr = new MetaDataHandler();
BOOST_CHECK_NE(ptr, nullPointer);
delete ptr;
}
BOOST_AUTO_TEST_CASE(getters_setters)
{
MetaDataHandler metaDataHandler;
// test defaults
BOOST_CHECK_EQUAL(metaDataHandler.getSampleName(), "");
BOOST_CHECK_EQUAL(metaDataHandler.getSampleGroupName(), "");
BOOST_CHECK_EQUAL(metaDataHandler.getSampleType() == SampleType::Unknown, true);
BOOST_CHECK_EQUAL(metaDataHandler.getSequenceSegmentName(), "");
BOOST_CHECK_EQUAL(metaDataHandler.getFilename(), "");
BOOST_CHECK_EQUAL(metaDataHandler.getAcquisitionDateAndTimeAsString(), "1900-01-01_000000");
BOOST_CHECK_EQUAL(metaDataHandler.getInjectionName(), "_-1__1900-01-01_000000");
// test setters
metaDataHandler.setSampleName("this is a sample name");
metaDataHandler.setSampleGroupName("this is a sample GROUP name");
metaDataHandler.setSampleType(SampleType::QC);
metaDataHandler.setSequenceSegmentName("this is a SEQUENCE segment name");
metaDataHandler.setFilename("some filename");
metaDataHandler.batch_name = "SomeBatchName";
metaDataHandler.setAcquisitionDateAndTimeFromString("09-06-2015 17:14:00", "%m-%d-%Y %H:%M:%S");
BOOST_CHECK_EQUAL(metaDataHandler.getSampleName(), "this is a sample name");
BOOST_CHECK_EQUAL(metaDataHandler.getSampleGroupName(), "this is a sample GROUP name");
BOOST_CHECK_EQUAL(metaDataHandler.getSampleType() == SampleType::QC, true);
BOOST_CHECK_EQUAL(metaDataHandler.getSequenceSegmentName(), "this is a SEQUENCE segment name");
BOOST_CHECK_EQUAL(metaDataHandler.getFilename(), "some filename");
BOOST_CHECK_EQUAL(metaDataHandler.getAcquisitionDateAndTimeAsString(), "2015-09-06_171400");
BOOST_CHECK_EQUAL(metaDataHandler.getInjectionName(), "this is a sample name_-1_SomeBatchName_2015-09-06_171400");
}
BOOST_AUTO_TEST_CASE(validateMetaData)
{
MetaDataHandler m;
m.setSampleName("1");
m.setSampleGroupName("2");
// m.setSampleType(SampleType::Unknown);
m.setSequenceSegmentName("4");
m.setFilename("5");
m.acq_method_name = "6";
m.inj_volume = 7.0;
m.inj_volume_units = "8";
m.batch_name = "9";
BOOST_CHECK_EQUAL(MetaDataHandler::validateMetaData(m), true);
m.setSampleType(SampleType::Unknown);
BOOST_CHECK_EQUAL(MetaDataHandler::validateMetaData(m), true);
m.setSampleType(SampleType::Standard);
BOOST_CHECK_EQUAL(MetaDataHandler::validateMetaData(m), true);
m.setSampleType(SampleType::QC);
BOOST_CHECK_EQUAL(MetaDataHandler::validateMetaData(m), true);
m.setSampleType(SampleType::Blank);
BOOST_CHECK_EQUAL(MetaDataHandler::validateMetaData(m), true);
m.setSampleType(SampleType::DoubleBlank);
BOOST_CHECK_EQUAL(MetaDataHandler::validateMetaData(m), true);
m.setSampleType(SampleType::Solvent);
BOOST_CHECK_EQUAL(MetaDataHandler::validateMetaData(m), true);
m.setSampleType(SampleType::Unrecognized);
BOOST_CHECK_EQUAL(MetaDataHandler::validateMetaData(m), false);
}
BOOST_AUTO_TEST_CASE(clear)
{
MetaDataHandler m;
m.setSampleName("1");
m.setSampleGroupName("2");
m.setSampleType(SampleType::QC);
m.setSequenceSegmentName("4");
m.setFilename("5");
m.acq_method_name = "6";
m.inj_volume = 7.0;
m.inj_volume_units = "8";
m.batch_name = "9";
m.acquisition_date_and_time = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
m.dilution_factor = 10;
m.scan_polarity = "negative";
m.scan_mass_high = 1000;
m.scan_mass_low = 100;
m.clear();
BOOST_CHECK_EQUAL(m.getSampleName(), "");
BOOST_CHECK_EQUAL(m.getSampleGroupName(), "");
BOOST_CHECK_EQUAL((int)m.getSampleType(), (int)SampleType::Unknown);
BOOST_CHECK_EQUAL(m.getSequenceSegmentName(), "");
BOOST_CHECK_EQUAL(m.getFilename(), "");
BOOST_CHECK_EQUAL(m.acq_method_name, "");
BOOST_CHECK_EQUAL(m.inj_volume, -1.0);
BOOST_CHECK_EQUAL(m.inj_volume_units, "");
BOOST_CHECK_EQUAL(m.batch_name, "");
BOOST_CHECK_EQUAL(m.getAcquisitionDateAndTimeAsString(), "1900-01-01_000000");
BOOST_CHECK_CLOSE(m.dilution_factor, 1.0, 1e-3);
BOOST_CHECK_EQUAL(m.scan_polarity, "Unknown");
BOOST_CHECK_CLOSE(m.scan_mass_high, 1e12, 1e-3);
BOOST_CHECK_CLOSE(m.scan_mass_low, 0.0, 1e-3);
}
BOOST_AUTO_TEST_CASE(SampleTypeToString)
{
BOOST_CHECK_EQUAL(sampleTypeToString.at(SampleType::Unknown), "Unknown");
BOOST_CHECK_EQUAL(sampleTypeToString.at(SampleType::Standard), "Standard");
BOOST_CHECK_EQUAL(sampleTypeToString.at(SampleType::QC), "QC");
BOOST_CHECK_EQUAL(sampleTypeToString.at(SampleType::Blank), "Blank");
BOOST_CHECK_EQUAL(sampleTypeToString.at(SampleType::DoubleBlank), "Double Blank");
BOOST_CHECK_EQUAL(sampleTypeToString.at(SampleType::Solvent), "Solvent");
BOOST_CHECK_EQUAL(sampleTypeToString.at(SampleType::Unrecognized), "Unrecognized");
BOOST_CHECK_EQUAL(sampleTypeToString.size(), 7);
}
BOOST_AUTO_TEST_CASE(getInjectionName)
{
MetaDataHandler m;
m.setSampleName("SampleName");
m.inj_number = 14;
m.batch_name = "BatchName";
m.acquisition_date_and_time.tm_sec = 55;
m.acquisition_date_and_time.tm_min = 40;
m.acquisition_date_and_time.tm_hour = 15;
m.acquisition_date_and_time.tm_mday = 31;
m.acquisition_date_and_time.tm_mon = 0; // months since January
m.acquisition_date_and_time.tm_year = 119; // years since 1900
BOOST_CHECK_EQUAL(m.getInjectionName(), "SampleName_14_BatchName_2019-01-31_154055");
}
BOOST_AUTO_TEST_SUITE_END()
|
7d07f6d8f12fc9ac8d028ba7d99612adbae34c28
|
7bc6c383bbaabc774124be09e9e3672c2f8c01af
|
/lab/lab20/lab20.cpp
|
ab12bc7bef41db5827c63028d670289b0e8f50de
|
[
"MIT"
] |
permissive
|
xivol/AM-PRO1-2018
|
0fbdc44beafbea0584d177bd05213aef0f5eeafe
|
ffa187673912de1789b43567d474664b217d2d3a
|
refs/heads/master
| 2021-10-24T10:13:59.045852
| 2019-03-25T07:31:26
| 2019-03-25T07:31:26
| 118,263,032
| 1
| 1
|
MIT
| 2019-03-25T07:31:27
| 2018-01-20T17:04:47
|
C++
|
WINDOWS-1251
|
C++
| false
| false
| 1,739
|
cpp
|
lab20.cpp
|
//
// Лабораторная работа №20. Рекурсия в списках
// lab20.cpp
//
#include <cassert>
#include <iostream>
#include <fstream>
#include "lab20.h"
using namespace std;
tlist *read_list(size_t length)
{
if (length == 0)
return nullptr;
tlist *begin = nullptr;
tlist::datatype data;
if (cin >> data) { // если чтение без ошибок
begin = new tlist;
begin->data = data;
begin->next = read_list(length - 1);
}
return begin;
}
tlist *read_list(istream &fin)
{
if (!fin.good())
return nullptr;
tlist *begin = nullptr;
tlist::datatype data;
if (fin >> data) { // если чтение без ошибок
begin = new tlist;
begin->data = data;
begin->next = read_list(fin);
}
return begin;
}
tlist *read_list(const char *filename)
{
assert(filename != nullptr);
tlist *begin = nullptr;
ifstream fin(filename);
if (!fin.is_open())
throw "Невозможно открыть файл";
begin = read_list(fin);
fin.close();
return begin;
}
void delete_list(tlist *&begin)
{
if (begin == nullptr)
return;
delete_list(begin->next);
delete begin;
begin = nullptr;
}
void print(const tlist *begin)
{
if (begin == nullptr)
return;
cout << begin->data << ' ';
print(begin->next);
}
tlist *find(const tlist *begin, tlist::datatype x)
{
if (begin == nullptr)
return nullptr;
if (begin->data == x)
return const_cast<tlist *>(begin);
return find(begin->next, x);
}
|
2a6bc601add0d5e82f3d040fa669525cc543d3f8
|
9247cc17fbcf5ce96960e1b180d463339f45378d
|
/.LHP/.Lop10/.O.L.P/.T.Van/Colp2/matkhau/MATKHAU.cpp
|
942eee7ea2d70a39578c6de30e799b5cfbf1d7c1
|
[
"MIT"
] |
permissive
|
sxweetlollipop2912/MaCode
|
dbc63da9400e729ce1fb8fdabe18508047d810ef
|
b8da22d6d9dc4bf82ca016896bf64497ac95febc
|
refs/heads/master
| 2022-07-28T03:42:14.703506
| 2021-12-16T15:44:04
| 2021-12-16T15:44:04
| 294,735,840
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,218
|
cpp
|
MATKHAU.cpp
|
#include <iostream>
#include <cstdio>
#include <string>
#define maxN 1000001
#define maxC 3
#define so 0
#define thg 1
#define hoa 2
#define minL 6
typedef char maxa;
typedef std::string str;
typedef long long maxn, maxr;
typedef int maxc;
str a;
maxn f[maxN][maxC], n;
maxr res = 0;
void Prepare() {
std::cin >> a;
n = a.size();
}
maxc classi(char c) {
if (c < 'A') return so;
if (c < 'a') return hoa;
return thg;
}
bool check(maxn i, maxn j) {
return (j - i + 1 >= minL) && (f[j][so] - f[i][so] > 0) && (f[j][hoa] - f[i][hoa] > 0) && (f[j][thg] - f[i][thg] > 0);
}
void Process() {
f[0][classi(a[0])] = 0;
maxn i = 0, j = 1;
while (j < n) {
maxc x = classi(a[j]);
f[j][so] = f[j - 1][so];
f[j][thg] = f[j - 1][thg];
f[j][hoa] = f[j - 1][hoa];
f[j][x]++;
f[j][classi(a[j - 1])]++;
while (check(i, j)) {
res += n - j;
i++;
}
f[j][x]--;
j++;
}
}
int main() {
//std::ios_base::sync_with_stdio(0);
std::cin.tie(0);
freopen("matkhau.inp","r",stdin);
//freopen("matkhau.out","w",stdout);
Prepare();
Process();
std::cout << res;
}
|
3005cc8fa449bc86a1ce3f821fa06e5650143dc6
|
a210253de470807ae1ea6a98419cbb87438968b9
|
/DXTK/VortexCube.cpp
|
bf0f7e096564355b75d5f2ed8bf3fb8edf928031
|
[] |
no_license
|
g2-pelns/CTP_FireSimulation
|
0e9b10ecb70bb0bb9772b49245a6e359b82eee33
|
48ef742d00582a01695e2d501d34128d7fdbed28
|
refs/heads/master
| 2021-09-13T07:04:46.700140
| 2018-04-26T09:42:51
| 2018-04-26T09:42:51
| 130,504,101
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,653
|
cpp
|
VortexCube.cpp
|
#include "pch.h"
#include "VortexCube.h"
VortexCube::VortexCube(ID3D11DeviceContext1* _d3dContext, DirectX::SimpleMath::Matrix _world, DirectX::SimpleMath::Matrix _view, DirectX::SimpleMath::Matrix _proj, int _x, int _y, int _z, bool _fire)
{
m_alive = true;
//Apply random fuel amount (80 - 100)
m_fuel = rand() % 21 + 80;
//Change heatRate to .0 decimal place (.4 - .6)
m_heatRate = rand() % 7 + 4;
m_heatRate = m_heatRate / 10;
m_world = _world;
m_view = _view;
m_proj = _proj;
m_PosX = _x;
m_PosY = _y;
m_PosZ = _z;
m_onFire = _fire;
m_d3dContext = _d3dContext;
m_shape = DirectX::GeometricPrimitive::CreateCube(m_d3dContext.Get());
m_world.Translation(DirectX::SimpleMath::Vector3(m_PosX, m_PosY, m_PosZ));
}
VortexCube::~VortexCube()
{
}
void VortexCube::Update(DirectX::SimpleMath::Matrix _world, DirectX::SimpleMath::Matrix _view, DirectX::SimpleMath::Matrix _proj)
{
m_view = _view;
if (m_onFire)
{
if (r < 1.f)
{
r += 0.01f;
}
else
{
r = 1.f;
g += 0.01f;
b += 0.01f;
}
m_fuel -= m_heatRate;
}
if (m_fuel < 0.f)
{
m_alive = false;
}
}
void VortexCube::Render()
{
if (m_alive)
{
m_shape->Draw(m_world, m_view, m_proj, DirectX::SimpleMath::Color(r, g, b), nullptr, true);
}
}
void VortexCube::Clear()
{
m_shape.reset();
}
void VortexCube::setFire(bool _state)
{
m_onFire = _state;
}
bool VortexCube::isAlive()
{
return m_alive;
}
int VortexCube::getPosX()
{
return m_PosX;
}
int VortexCube::getPosY()
{
return m_PosY;
}
int VortexCube::getPosZ()
{
return m_PosZ;
}
bool VortexCube::onFire()
{
return m_onFire;
}
float VortexCube::GetHealth()
{
return m_fuel;
}
|
e4e1de8fd669c8d097d92a40c817902e6181844f
|
aef414dba7a19a0471f1338727c7ee779aa5d6be
|
/SampleCode/9-3_Data.h
|
9bdced794c45545824c29a895c1892227365869d
|
[] |
no_license
|
Poissonfish/CptS122
|
7ee468a721c148c34b791bb3933fca4b1a40cb23
|
1547e6652ed6076d7dbd7c9299a73574ddb02d64
|
refs/heads/master
| 2021-05-05T07:31:32.723227
| 2018-04-10T17:15:38
| 2018-04-10T17:15:38
| 118,815,302
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 370
|
h
|
9-3_Data.h
|
#pragma once
#include <iostream>
#include <fstream>
#include <string>
#include "Rational.h"
class Data
{
public:
Data()
{
}
Data(Data &newData);
Data & operator= (Data &newData);
Rational getRational();
void setRational(Rational &newRational);
private:
Rational mNum;
};
// non member
bool operator< (Data &lhs, Data &rhs);
|
19106fca20460e2721c0960c4d3f87bca6290c7f
|
3037cad993cf2de015b17ceb1627f01ce11fc82c
|
/coreApp/src/psc/cblist.h
|
81f090f834365d2985c8fb281d318efceb1fbd1b
|
[] |
no_license
|
mdavidsaver/pscdrv-dev
|
9dbd840fad8aaa9efc3d08b4321d61d4160a224a
|
f0ff311be6464c119b380c0f9a1dacbfd7a826c9
|
refs/heads/master
| 2023-03-31T12:54:11.975839
| 2020-10-17T18:46:17
| 2020-10-17T19:19:27
| 354,068,046
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,331
|
h
|
cblist.h
|
/*************************************************************************\
* Copyright (c) 2014 Brookhaven Science Assoc. as operator of
Brookhaven National Laboratory.
* EPICS BASE is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
\*************************************************************************/
#ifndef CBLIST_H
#define CBLIST_H
#include <list>
#include <map>
#include <typeinfo>
#include <errlog.h>
template<typename T>
class CBList
{
public:
typedef void (*func_t)(void*, T*);
private:
typedef std::pair<void*,func_t> value_type;
typedef std::list<value_type> list_t;
list_t thelist;
public:
CBList():thelist(){};
void add(func_t fn, void* user){thelist.push_back(std::make_pair(user,fn));}
void del(func_t fn, void* user){thelist.remove(std::make_pair(user,fn));}
void operator()(T* obj) {
typename list_t::const_iterator it, end=thelist.end();
for(it=thelist.begin(); it!=end; ++it) {
try {
(*it->second)(it->first, obj);
} catch(std::exception& e) {
errlogPrintf("Exception in CBList<%s>(%p) '%s'\n",
typeid(this).name(), (void*)obj, e.what());
}
}
}
};
#endif // CBLIST_H
|
0bd224e35e1a7760224d9460b3a9929379d63f32
|
d073625f26109523ef3441544c45b00442619df5
|
/instrukcje iteracyjne cz.II/zadanie5/main.cpp
|
1b49a3cbfc8b69e509a772e0431c0102af31afd4
|
[] |
no_license
|
DavidDeep/ZSTH-Programowanie
|
74e281384a337833c2a51b0f1feba4d20471b448
|
c060c4f18f50c6ac7ac97ba9cbebd3b9b6649101
|
refs/heads/master
| 2020-06-02T09:26:04.961063
| 2012-01-23T23:59:20
| 2012-01-23T23:59:20
| 3,250,782
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 699
|
cpp
|
main.cpp
|
#include <cstdlib>
#include <iostream>
#include <conio.h>
#include <math.h>
using namespace std;
int main(int argc, char *argv[])
{
int liczba1,liczba2,wynik,podanyWynik;
srand(static_cast<int>(time(NULL))); //zainicjowanie losowania
for( int i = 1; i <= 10; i++ ){
liczba1 = 1 + rand() % 10;
liczba2 = 1 + rand() % 10;
wynik = liczba1 * liczba2;
cout << i << ". " << liczba1 << " * " << liczba2 << "= ";
cin >> podanyWynik;
while ( wynik != podanyWynik ){
cout << i << ". " << liczba1 << " * " << liczba2 << "= ";
cin >> podanyWynik;
}
}
cout << "Koniec";
getch();
}
|
a927ea635f6a507106532805832b4a08801be97e
|
8dc1d507328d70c298adb8f3bacfc7e987f113dc
|
/include/mgcpp/operations/mult.hpp
|
1ff63fbefc77e04b5c67bfbacee5ac82bb708b73
|
[
"BSL-1.0"
] |
permissive
|
juice500ml/mgcpp
|
64de71872760bf31a403faefe6da072bb5c90d9c
|
7dcaff0b84ecf8e5d77d57086eb1d7602a440938
|
refs/heads/master
| 2021-05-08T11:06:16.593717
| 2018-02-02T09:28:54
| 2018-02-02T09:28:54
| 119,879,165
| 0
| 0
| null | 2018-02-01T18:55:39
| 2018-02-01T18:55:38
| null |
UTF-8
|
C++
| false
| false
| 2,441
|
hpp
|
mult.hpp
|
// Copyright RedPortal, mujjingun 2017 - 2018.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef _MGCPP_OPERATIONS_MULTIPLICATION_HPP_
#define _MGCPP_OPERATIONS_MULTIPLICATION_HPP_
#include <mgcpp/matrix/dense_matrix.hpp>
#include <mgcpp/matrix/device_matrix.hpp>
#include <mgcpp/vector/dense_vector.hpp>
#include <mgcpp/vector/device_vector.hpp>
#include <mgcpp/type_traits/type_traits.hpp>
#include <cstdlib>
namespace mgcpp
{
namespace strict
{
template<typename LhsDenseMat,
typename RhsDenseMat,
typename Type,
size_t DeviceId>
inline decltype(auto)
mult(dense_matrix<LhsDenseMat, Type, DeviceId> const& lhs,
dense_matrix<RhsDenseMat, Type, DeviceId> const& rhs);
// template<typename LhsDenseVec,
// typename RhsDenseVec,
// typename Type,
// size_t Device,
// alignment Align>
// inline device_vector<Type, Device, Align,
// typename LhsDenseVec::allocator_type>
// mult(dense_vector<LhsDenseVec, Type, Device, Align> const& first,
// dense_vector<RhsDenseVec, Type, Device, Align> const& second);
template<typename DenseVec,
typename ScalarType,
typename VectorType,
alignment Align,
size_t DeviceId,
typename = typename
std::enable_if<is_scalar<ScalarType>::value>::type>
inline decltype(auto)
mult(ScalarType scalar,
dense_vector<DenseVec, VectorType, Align, DeviceId> const& vec);
template<typename DenseMat,
typename MatrixType,
size_t DeviceId,
typename ScalarType,
typename = typename
std::enable_if<is_scalar<ScalarType>::value>::type>
inline decltype(auto)
mult(ScalarType scalar,
dense_matrix<DenseMat, MatrixType, DeviceId> const& mat);
// template<typename T, size_t Device, storage_order SO>
// void
// mult_assign(gpu::matrix<T, Device, SO>& first,
// gpu::matrix<T, Device, SO> const& second);
}
}
#include <mgcpp/operations/mult.tpp>
#endif
|
104c79346795a07f831f0ed0270a3a0239134c36
|
629fff41e850e4413064e714205c7fe6b4fb69bf
|
/theAlgorithm/迷宫递归.cpp
|
2a4cb2319e2803b3e35492705b36e27043d746e6
|
[] |
no_license
|
Jiangpeiqi44/vscode_1
|
eb9b25de7e7af9b28f965fe2d6fc4676ecb1ff73
|
988c44815a26a9b922b6a3af8ce2b75f5e0de6cb
|
refs/heads/master
| 2020-11-27T15:56:10.346160
| 2020-03-28T10:01:17
| 2020-03-28T10:01:17
| 229,520,175
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 4,665
|
cpp
|
迷宫递归.cpp
|
#include <iostream>
#include <stack>
#include <windows.h>
using namespace std;
struct Point
{
int X;
int Y;
};
//打印地图
void PrintPath(int arr[][10]);
//递归算法
int Maze(int arr[][10], Point cur, Point end);
//非递归算法
int next(int arr[][10],Point cur, Point end);
//动态效果
void Gotoxy(int x, int y); //光标移动到（x，y）位置
void HideCursor();//不显示光标
//递归找出所有路
void nextAll(int arr[][10], Point cur, Point end);
void PrintPath1(int arr[][10]);
//地图
int arr[10][10]={
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
{-1, 0, 0,-1, 0, 0, 0,-1, 0,-1},
{-1, 0, 0, 0, 0,-1,-1, 0, 0,-1},
{-1, 0,-1,-1,-1, 0, 0, 0, 0,-1},
{-1, 0, 0, 0,-1, 0, 0, 0, 0,-1},
{-1, 0,-1, 0, 0, 0,-1, 0, 0,-1},
{-1, 0,-1, 0, 0, 0,-1, 0, 0,-1},
{-1, 0,-1,-1,-1, 0,-1,-1, 0,-1},
{-1,-1, 0, 0 ,0, 0, 0, 0, 0,-1},
{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}};
void main()
{
Point cur={1,1};
Point end={8,8};
HideCursor();
PrintPath(arr);
//Maze(arr,cur,end); //非递归算法：只能找出一条路
next(arr,cur,end);//递归算法 ：只能找出一条路
Gotoxy(1,22);
//nextAll(arr, cur, end);//递归算法：找出所有路的算法
}
//光标不显示
void HideCursor()
{
CONSOLE_CURSOR_INFO CursorInfo;
GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &CursorInfo);//获取控制台光标信息
CursorInfo.bVisible = false; //隐藏控制台光标
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &CursorInfo);//设置控制台光标状态
}
//指定位置输出
void Gotoxy(int x, int y)
{
COORD c;
c.X = x;
c.Y = y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), c);
}
int Maze(int arr[][10],Point cur, Point end)//非递归
{
Point stack[256];
int top = -1;
do
{
arr[cur.X][cur.Y] = 2;
stack[++top] = cur;
//动态显示开始
Gotoxy(cur.Y*2, cur.X);
cout<<" *";
Sleep(500);
//动态显示结束
if (arr[cur.X + 1][cur.Y] == 0) cur.X++;
else if (arr[cur.X][cur.Y + 1] == 0) cur.Y++;
else if (arr[cur.X-1][cur.Y] ==0) cur.X--;
else if(arr[cur.X][cur.Y - 1] == 0) cur.Y--;
else
{
arr[cur.X][cur.Y] = 1; // 走不通
//动态显示开始
Gotoxy(cur.Y*2, cur.X);
cout<<" 1";
Sleep(500);
//动态显示结束
top--;
cur.X = stack[top].X;
cur.Y = stack[top].Y;
top--;
}
}while(top!=-1 && (cur.X != end.X || cur.Y != end.Y));
//动态显示开始
Gotoxy(cur.Y*2, cur.X);
cout<<" *";
//动态显示结束
return true;
}
int next(int arr[][10],Point cur, Point end)//递归
{
if(cur.X == end.X && cur.Y == end.Y)
{
//动态显示开始
Gotoxy(cur.Y*2,cur.X);
cout<<" *";
//动态显示结束
return true;
}
else
{
arr[cur.X][cur.Y] = 2;
//动态显示开始
Gotoxy(cur.Y*2,cur.X);
cout<<" *";
Sleep(500);
//动态显示结束
if (arr[cur.X][cur.Y+1] ==0)
{
Point t=cur;
t.Y++;
if (next(arr,t,end)) return true;
}
if (arr[cur.X-1][cur.Y] ==0)
{
Point t=cur;
t.X--;
if (next(arr,t,end)) return true;
}
if (arr[cur.X][cur.Y-1] ==0)
{
Point t=cur;
t.Y--;
if (next(arr,t,end)) return true;
}
if (arr[cur.X + 1][cur.Y] == 0)
{
Point t = cur;
t.X++;
if (next(arr, t, end)) return true;
}
arr[cur.X][cur.Y] = 1; // 走不通
//动态显示开始
Gotoxy(cur.Y*2,cur.X);
cout<<" 1";
Sleep(500);
//动态显示结束
return false;
}
}
void PrintPath(int arr[][10])
{
for (int i=0;i<10;i++)
{
for (int j=0;j<10;j++)
{
if (arr[i][j]==-1) cout<<"■";
else cout<<"□";
}
cout<<endl;
}
cout<<endl;
}
void PrintPath1(int arr[][10])
{
for (int i = 0; i<10; i++)
{
for (int j = 0; j<10; j++)
{
if (arr[i][j] == -1) cout << "■";
else if (arr[i][j] == 2) cout << "* ";
else cout << "□";
}
cout << endl;
}
cout << endl;
}
void nextAll(int arr[][10], Point cur, Point end)//递归
{
if (cur.X == end.X && cur.Y == end.Y)
{
arr[end.X][end.Y] =2;
PrintPath1(arr);
Sleep(200);
arr[end.X][end.Y] = 0;
}
else
{
arr[cur.X][cur.Y] = 2;
if (arr[cur.X][cur.Y + 1] == 0)
{
Point t = cur;
t.Y++;
nextAll(arr, t, end);
arr[cur.X][cur.Y + 1] = 0;
}
if (arr[cur.X - 1][cur.Y] == 0)
{
Point t = cur;
t.X--;
nextAll(arr, t, end);
arr[cur.X - 1][cur.Y] = 0;
}
if (arr[cur.X][cur.Y - 1] == 0)
{
Point t = cur;
t.Y--;
nextAll(arr, t, end);
arr[cur.X][cur.Y - 1] = 0;
}
if (arr[cur.X + 1][cur.Y] == 0)
{
Point t = cur;
t.X++;
nextAll(arr, t, end);
arr[cur.X+1][cur.Y] = 0;
}
arr[cur.X][cur.Y] = 1; // 走不通
}
}
|
98877279557058ac711b0b160eccdbba0b42f3b6
|
5d22c35cfee8e0ddfec52b24c495ded867ceecde
|
/exercise-2/reduceFractions.cpp
|
27548c4cdc2686fd597ac58703f2570bc88598b3
|
[
"MIT"
] |
permissive
|
DerHumm3l/oop-cpp
|
9b662f83c22dbe37031f2229b8d82b9354e34076
|
767ca4e553bfc037aa1fac3f41fdf0baf56a3304
|
refs/heads/master
| 2023-01-05T22:56:02.145154
| 2020-11-02T10:10:28
| 2020-11-02T10:10:28
| 264,649,966
| 0
| 0
|
MIT
| 2020-11-02T10:10:29
| 2020-05-17T11:33:53
|
C++
|
UTF-8
|
C++
| false
| false
| 1,384
|
cpp
|
reduceFractions.cpp
|
#include <iostream>
#include <string>
using namespace std;
int getGreatestCommonDivisor(int a, int b)
{
if (b == 0)
{
return a;
}
return getGreatestCommonDivisor(b, a % b);
}
void reduce(int numerator, int denominator)
{
int gcd = getGreatestCommonDivisor(numerator, denominator);
cout << "Der Bruch " << numerator << "/" << denominator
<< " laesst sich auf " << numerator / gcd << "/"
<< denominator / gcd << " kuerzen" << endl;
}
int main(int argc, char *argv[])
{
string choice, numeratorInput, denominatorInput;
int numerator, denominator;
while (true)
{
cout << "Waehlen Sie eine Aktion: " << endl
<< "1 - Kuerzen" << endl
<< "2 - Beenden" << endl
<< "Eingabe: ";
getline(cin, choice);
switch (choice[0])
{
case '1':
cout << "Geben Sie den Zaehler als ganze Zahl ein: ";
getline(cin, numeratorInput);
numerator = stoi(numeratorInput);
cout << "Geben Sie den Nenner als ganze Zahl ein: ";
getline(cin, denominatorInput);
denominator = stoi(denominatorInput);
reduce(numerator, denominator);
break;
case '2':
return 0;
default:
cout << "Falscher Input";
break;
}
}
}
|
192b36a89427cdada4f0c24af10e0d6df66938a2
|
3247375136dc768d0a4f5bca7341ab403a817327
|
/C_Program_Code/version_5_0/locus_algorithm_5_1/src/quick_sort_5_0.h
|
8eab2e2bf52494d7bd9f268afe49f072d9dc0606
|
[] |
no_license
|
creanero/locus
|
79d155b005671d10a534973697c3581cd18058e6
|
833da2fb36c0dcc65e6ce4bac8ad4a94a2578f7a
|
refs/heads/master
| 2022-05-25T18:08:23.629091
| 2022-05-10T16:48:31
| 2022-05-10T16:48:31
| 166,679,955
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 511
|
h
|
quick_sort_5_0.h
|
#ifndef QUICK_SORT_2_0_H_
#define QUICK_SORT_2_0_H_
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
//needed to define the structures
#include "struct_definitions_5_2.h"
//needed to allow for error checking routines
#include "error_checking_5_3.h"
/*int quick_sort_star (struct star **p_struct_star, long int *p_num_rows);
int quick_sort_star_run (struct star **p_struct_star, long int beginning, long int ending);
*/
int star_compare (const void *, const void *);
#endif /*QUICK_SORT_2_0_H_*/
|
5f378a17d4ede47ba82eb87ce69e9fcb26055c6a
|
db91fbb10df982b40bbafed82b254e04ff35f2fd
|
/abstract-factory/concrete_product_b_y.h
|
22ee522a71d10ab388d4154728cbb0ad7bf285c2
|
[] |
no_license
|
xulzee/design-patterns-cpp
|
3d49b55ce36ee327663341ed6f238505271870c8
|
65b4d5c8d9f20641b6163b8ef14cb5f7b0caa8bc
|
refs/heads/master
| 2021-05-17T10:07:44.502707
| 2020-04-20T11:26:47
| 2020-04-20T11:26:47
| 250,734,609
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 389
|
h
|
concrete_product_b_y.h
|
//
// Created by xulzee on 2020/4/17.
//
#ifndef DESIGN_PATTERNS_CPP_ABSTRACT_FACTORY_CONCRETE_PRODUCT_B_Y_H_
#define DESIGN_PATTERNS_CPP_ABSTRACT_FACTORY_CONCRETE_PRODUCT_B_Y_H_
#include "product_b.h"
class ConcreteProductBY : public ProductB{
public:
std::string GetName() override {
return "B-Y";
}
};
#endif //DESIGN_PATTERNS_CPP_ABSTRACT_FACTORY_CONCRETE_PRODUCT_B_Y_H_
|
9ff8ecbddbc311eaaf507762c4a7c7d99949d7f3
|
1f66df2de800c6e46924a51d39d2be6aed481949
|
/my_extend/src/a/a.h
|
b13d4be94eb453d269f41aedead0af5789a22a66
|
[] |
no_license
|
minhanghuang/FKCpp
|
6969c17cd6bdd75933ea2be738dbf86aa3b04a41
|
53d2aa713fcafd275b3e8ccf98b8900a5be197e5
|
refs/heads/master
| 2023-03-25T02:42:19.003732
| 2021-03-24T06:55:50
| 2021-03-24T06:55:50
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 508
|
h
|
a.h
|
/*
* Copyright (C) Trunk Technology, Inc. - All Rights Reserved
*
* Unauthorized copying of this file, via any medium is strictly prohibited
* Proprietary and confidential
*
* Written by Huang Minhang <huangminhang@trunk.tech>, 2020/12/4 4:50 下午
*/
#ifndef MY_EXTEND_A_H
#define MY_EXTEND_A_H
#include <iostream>
#include <memory>
class TestA{
public:
TestA();
int v_a;
int v_b;
int v_c;
// std::shared_ptr<TestA> a_ptr;
public:
void get_v();
};
#endif //MY_EXTEND_A_H
|
4d0e8e88ce99261a0174eedf3d6516fcfe651b9a
|
b1ac00d4a73bd18976316d77fd4c4b89c5e9f3b7
|
/qualifier/book.cpp
|
bdac1f0cf6b903833f864da60ae2871ece081d69
|
[] |
no_license
|
Pratyush1014/CPP
|
35b66b1bc1d877af7cf8a65f2106d72ce2d1e07f
|
9f1fcb5e39fe11efa4eb9c30a391777701486d3b
|
refs/heads/master
| 2022-06-05T04:05:14.079933
| 2020-05-03T09:05:45
| 2020-05-03T09:05:45
| 260,859,957
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 712
|
cpp
|
book.cpp
|
#include"iostream"
using namespace std ;
struct book
{
char * name ;
char * author;
mutable int price;
mutable int page;
mutable int edition;
};
main()
{
const book var = {"book","author",450,234,1};
cout<<var.name<<endl;
cout<<var.author<<endl;
cout<<var.price<<endl;
cout<<var.page<<endl;
cout<<var.edition<<endl;
cout<<endl;
cout<<"enter the new price"<<endl;
cin>>var.price;
cout<<"enter the new number of pages"<<endl;
cin>>var.page;
cout<<"enter the new edition"<<endl;
cin>>var.edition;
cout<<var.name<<endl;
cout<<var.author<<endl;
cout<<var.price<<endl;
cout<<var.page<<endl;
cout<<var.edition<<endl;
cout<<endl;
}
|
22e59455799adfe97b34fbc9c416fa8098c753f7
|
e4afc5df1a31132d4963b67ea9d5d4ca8cc9407a
|
/Plugin/sources/UnityAudioGrabber.cpp
|
d6fc53fbe69a0d9580cfb58f1ed2cfda365929a5
|
[
"MIT"
] |
permissive
|
mrayy/mrayGStreamerUnity
|
8e1a201779f8f49498e28e408d5407cb0832cc3b
|
83577f36f68858afcba23a53c96f4d5bf8c67cdd
|
refs/heads/master
| 2023-09-01T11:57:28.270831
| 2023-03-20T02:57:19
| 2023-03-20T02:57:19
| 34,888,591
| 108
| 35
|
MIT
| 2023-09-11T11:46:12
| 2015-05-01T03:45:09
|
C
|
UTF-8
|
C++
| false
| false
| 1,972
|
cpp
|
UnityAudioGrabber.cpp
|
#include "stdafx.h"
#include "UnityAudioGrabber.h"
#include "IThreadManager.h"
#include "MutexLocks.h"
#include <cstring> // memcpy
namespace mray
{
namespace video
{
UnityAudioGrabber::UnityAudioGrabber()
{
m_mutex = OS::IThreadManager::getInstance().createMutex();;
_samplingRate = 44100;
_channels = 1;
_bufferLength = 1000;
_started = false;
}
UnityAudioGrabber::~UnityAudioGrabber()
{
for (float* v : _graveyard)
{
delete[] v;
}
for (float* v : _samples)
{
delete[] v;
}
}
void UnityAudioGrabber::Init(int bufferLength, int channels, int samplingrate)
{
_bufferLength = bufferLength;
_channels= channels;
_samplingRate = samplingrate;
int buffers = 2*samplingrate / bufferLength;
if (buffers < 3)
buffers = 3;
for (int i = 0; i < buffers; ++i)
{
_graveyard.push_back(new float[bufferLength]);
}
}
void UnityAudioGrabber::AddFrame(float* data)
{
OS::ScopedLock l(m_mutex);
float* ptr = 0;
if (_graveyard.size() > 0)
{
ptr=_graveyard.front();
_graveyard.pop_front();
}
else
{
ptr = new float[_bufferLength];
}
memcpy(ptr, data, _bufferLength*sizeof(float));
_samples.push_back(ptr);
}
bool UnityAudioGrabber::Start()
{
_started = true;
return true;
}
void UnityAudioGrabber::Pause()
{
_started = false;
}
void UnityAudioGrabber::Close()
{
_started = false;
}
bool UnityAudioGrabber::IsStarted()
{
return _started;
}
void UnityAudioGrabber::SetVolume(float vol)
{
}
uint UnityAudioGrabber::GetSamplingRate()
{
return _samplingRate;
}
uint UnityAudioGrabber::GetChannelsCount()
{
return _channels;
}
bool UnityAudioGrabber::GrabFrame()
{
OS::ScopedLock l(m_mutex);
return _samples.size() > 0;
}
float* UnityAudioGrabber::GetAudioFrame()
{
OS::ScopedLock l(m_mutex);
if (_samples.size() > 0)
{
float* ptr=_samples.front();
_graveyard.push_back(ptr);
_samples.pop_front();
return ptr;
}
return 0;
}
uint UnityAudioGrabber::GetAudioFrameSize()
{
return _bufferLength;
}
}
}
|
04c3839ca4ee3b8c0c952ceb8dadecf61ba6205f
|
e5ad5b35aee51bd58b05f86d797d6e9b02a12f44
|
/DMOJ&MCPT/PHP/PHP.cpp
|
c92e5a99a8a687edb1ed251122b47c30f64f619f
|
[] |
no_license
|
jtyliu/Competitive-Programming
|
2c1b1d554e60c781b4aecd3ab0ff683decb23f04
|
eb3a8071e84e9f495617c02e37bfa65b73382aa1
|
refs/heads/master
| 2023-01-19T19:39:23.700082
| 2020-11-22T02:01:29
| 2020-11-22T02:01:29
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 638
|
cpp
|
PHP.cpp
|
#include <bits/stdc++.h>
using namespace std;
int pointingTo[5010];
int main() {
memset(pointingTo,-1,sizeof(pointingTo));
scanf("%d",&n);
for(int i=1,a; i<=n; i++){
//Check if any are going into i
//If not i is not apart of loop
for(int j=1; j<=n; j++){
if(j!=i&&pointingTo[j]!=0){
printf("? %d %d\n",j,i);
scanf("%d",&a);
if(a){
if(pointingTo[i]==-1)pointingTo[i]=1;
else pointingTo[i]++;
}
}
}
if(pointingTo[i]==-1)pointingTo[i]=0;
}
return 0;
}
|
19daf6757469cc4664690d32f867b62e6bd08266
|
e2f4959c4a6bd008c271294e6eae7ef0e207e8c6
|
/28.cpp
|
a10f09031afb31a7750d48eb2b63b7a0b5748796
|
[] |
no_license
|
axknightroad/code-of-leetcode
|
e32789d85a1dd6f2e509fe499ac884b36448d0b2
|
56b134a7d68e903336006bc86f20901a822b8da2
|
refs/heads/master
| 2016-08-12T02:41:51.405829
| 2016-01-20T16:25:27
| 2016-01-20T16:25:27
| 47,251,412
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 559
|
cpp
|
28.cpp
|
#include <string>
#include <iostream>
using namespace std;
int strStr(string haystack, string needle) {
if(!needle.size()) return 0;
if (needle.size() > haystack.size()) return -1;
for(int i = 0; i < haystack.size() - needle.size() + 1; i++){
for(int j = 0; j < needle.size(); j++) {
if (i + j > haystack.size() - 1 || haystack[i+j] != needle[j]) {
break;
} else if (j == needle.size() - 1) {
return i;
}
}
}
return -1;
}
int main() {
int ans = strStr("abcd", "abdd");
std::cout << ans << std::endl;
return 0;
}
|
39886982dda41d214518550c69b6d66160ca09c9
|
076ba173f5b518977d30f4336c63b177a5a7f66d
|
/cases/adaptative_surfers/param/post/objects/surfer__us_1o0__surftimeprefactor_3o0/py/group/all/parameters.h
|
979aea0eca5b6570c51ae5533ca06ab456ecd95a
|
[
"MIT"
] |
permissive
|
C0PEP0D/sheld0n
|
a661b27ffee7b087731f0a3e9f92c2ee26d7d560
|
a1b9a065cfaa2e3faf5a749f14201a84baa41ce9
|
refs/heads/master
| 2023-04-28T20:53:27.684636
| 2023-04-18T21:20:00
| 2023-04-18T21:20:00
| 421,041,396
| 0
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 626
|
h
|
parameters.h
|
#ifndef C0P_PARAM_POST_OBJECTS_SURFER__US_1O0__SURFTIMEPREFACTOR_3O0_PY_GROUP_ALL_PARAMETERS_H
#define C0P_PARAM_POST_OBJECTS_SURFER__US_1O0__SURFTIMEPREFACTOR_3O0_PY_GROUP_ALL_PARAMETERS_H
#pragma once
// app include
#include "core/post/objects/object/post/group/all/prop.h"
// post member choice
#include "param/post/objects/surfer__us_1o0__surftimeprefactor_3o0/py/group/_member/choice.h"
namespace c0p {
struct PostSurferUs1O0Surftimeprefactor3O0PyGroupAllParameters {
template<typename TypeMemberStep>
using TypePostPostMember = PostSurferUs1O0Surftimeprefactor3O0PyGroupMember<TypeMemberStep>;
};
}
#endif
|
082f3fcd2c13174703f153c370c354d601692c02
|
3d8b9f4280f161f39c65bc0970a0e7522a36fad9
|
/Kỹ thuật lập trình - Programming Techniques/C4/9.cpp
|
c6303a6f700e64edfb2313a214bc653c4db40f3a
|
[] |
no_license
|
CaoHoaiTan/HCMUTE
|
972f2ff27ed1bb9e299e2009b4ee681710a78055
|
b643dfe2f7875e3809e19f078184e7a7fd011f08
|
refs/heads/master
| 2022-12-11T20:10:00.371946
| 2020-09-06T11:15:11
| 2020-09-06T11:15:11
| 293,289,417
| 0
| 1
| null | 2020-09-06T14:06:42
| 2020-09-06T14:06:42
| null |
UTF-8
|
C++
| false
| false
| 289
|
cpp
|
9.cpp
|
#include <stdio.h>
#include <string.h>
#define SIZE 1024
int isPalindrome(char s[]);
int main()
{
char s[SIZE];
gets(s);
printf("%d",isPalindrome(s));
return 0;
}
int isPalindrome(char s[])
{
int n=strlen(s);
for (int i=0;i<n/2;i++)
if (s[i]!=s[n-i-1])
return 0;
return 1;
}
|
7351603093ea0975c8e03443d7f1821cedb5dfd6
|
1c33b6fd7fbf966a961ccd679ad2ba344f2fc05f
|
/UVA/Princess Farida.cpp
|
1e93441a1976edae931d1f8b2779f3dcc395c33a
|
[] |
no_license
|
zim2510/Online-Judge-Solves
|
f57170e5bf14f339944079ed62bed01bdc5b27e3
|
949ab3cfba0cc7ec4ffaa6f2b3e5b0c517d9377a
|
refs/heads/master
| 2022-01-07T10:23:12.653572
| 2019-05-19T11:30:58
| 2019-05-19T11:30:58
| 135,351,009
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 564
|
cpp
|
Princess Farida.cpp
|
#include <bits/stdc++.h>
using namespace std;
long long dptable[10000];
int sz;
int golds[10000];
long long dp(int ci)
{
if(ci>=sz) return 0;
if(dptable[ci]!=-1) return dptable[ci];
dptable[ci] = max(golds[ci] + dp(ci+2), dp(ci+1));
return dptable[ci];
}
int main()
{
int tc;
scanf("%d", &tc);
for(int i = 1; i<=tc; i++){
scanf("%d", &sz);
for(int i = 0; i<sz; i++) scanf("%d", &golds[i]);
memset(dptable, -1, sizeof(dptable));
printf("Case %d: %lld\n", i, dp(0));
}
}
|
9b4974bedd54503afbdacfc1edbf742ecf918516
|
ac2d662df239581e80caff085a28158447fa584b
|
/UVA Online Judge/problem10755.cpp
|
f9573e1467cb126b02c97df16bf58e8cd6e94389
|
[] |
no_license
|
basimkhajwal/ProgrammingChallenges
|
4283b8a22c8ac2ccd6c0db642c607e9a5f0a797c
|
0f4ea3837a9085fc4fa4a9069b1e3fdfa124f442
|
refs/heads/master
| 2023-08-22T08:19:52.997699
| 2023-08-15T12:55:53
| 2023-08-15T12:55:53
| 72,464,921
| 0
| 1
| null | 2019-03-16T11:37:38
| 2016-10-31T18:14:39
|
C++
|
UTF-8
|
C++
| false
| false
| 2,580
|
cpp
|
problem10755.cpp
|
#include <cstdio>
#define ll long long
int main() {
int T, A, B, C;
ll grid[25][25][25], prefixSum[25][25][25];
scanf("%d", &T);
while (T--) {
scanf("%d %d %d", &A, &B, &C);
for (int i = 0; i < A; i++) {
for (int j = 0; j < B; j++) {
for (int k = 0; k < C; k++) {
scanf("%lld", &grid[i][j][k]);
prefixSum[i][j][k] = grid[i][j][k];
if (i) prefixSum[i][j][k] += prefixSum[i-1][j][k];
if (j) prefixSum[i][j][k] += prefixSum[i][j-1][k];
if (k) prefixSum[i][j][k] += prefixSum[i][j][k-1];
if (i && j) prefixSum[i][j][k] -= prefixSum[i-1][j-1][k];
if (i && k) prefixSum[i][j][k] -= prefixSum[i-1][j][k-1];
if (j && k) prefixSum[i][j][k] -= prefixSum[i][j-1][k-1];
if (i && j && k) prefixSum[i][j][k] += prefixSum[i-1][j-1][k-1];
}
}
}
ll currentValue = 0, maxValue = 0;
/*
* - Pick 2 points in A,B plane
* - Apply Kadanes algorithm in C plane
* -> O(n^5) = 20^5 * 15 ~ 50 million OK.
* */
#define PLANESUM(a, b, c) c == 0 ? prefixSum[a][b][0] : (prefixSum[a][b][c] - prefixSum[a][b][c-1])
for (int x = 0; x < A; x++) {
for (int y = 0; y < B; y++) {
for (int p = x; p < A; p++) {
for (int q = y; q < B; q++) {
currentValue = 0;
for (int i = 0; i < C; i++) {
currentValue += PLANESUM(p, q, i);
if (x) currentValue -= PLANESUM(x-1, q, i);
if (y) currentValue -= PLANESUM(p, y-1, i);
if (x && y) currentValue += PLANESUM(x-1, y-1, i);
if (currentValue < 0) currentValue = 0;
if (currentValue > maxValue) maxValue = currentValue;
}
}
}
}
}
if (maxValue == 0) {
maxValue = grid[0][0][0];
for (int i = 0; i < A; i++) {
for (int j = 0; j < B; j++) {
for (int k = 0; k < C; k++) {
if (grid[i][j][k] > maxValue) maxValue = grid[i][j][k];
}
}
}
}
printf("%lld\n", maxValue);
if (T) printf("\n");
}
return 0;
}
|
72852f2819da195ec457062bff2b41bd050359ce
|
5c7977bf9a81574010ab3ccafd28e22d048e9d32
|
/9663.cpp
|
0eb65091f212863107887a3c8c90ec6d1df8e324
|
[] |
no_license
|
PSKyun/Difficult
|
0e483569faf1bd802e648278ffcf32d2bc553eab
|
388c7a6694be13f299478e7fa03118801bc408b5
|
refs/heads/master
| 2022-11-21T13:34:37.699102
| 2020-07-17T11:25:38
| 2020-07-17T11:25:38
| 259,620,805
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 524
|
cpp
|
9663.cpp
|
#include <iostream>
using namespace std;
int n,col[15],count;
bool promising(int i){
int k=1;
bool s=true;
while(k < i && s){
if(col[i]==col[k] || abs(col[i]-col[k])==i-k)
s=false;
k++;
}
return s;
}
void queen(int i){
int j;
if(promising(i)){
if(i==n) count++;
else{
for(j=1;j<=n;j++){
col[i+1]=j;
queen(i+1);
}
}
}
}
int main (){
cin >> n;
queen(0);
cout << count;
}
|
e0a24c1f44de7269b7de3347b50183533087cd96
|
e5be4154ec50dfe2f9270ee6498f2529bedda77d
|
/buffer/buffer.hpp
|
2c6fc590ad9fe48a948c179835ccad1432e4fc15
|
[
"MIT"
] |
permissive
|
Tommoa/Snippets
|
78f7930ae4f4cdb419c3c13bc26a2fc9fa79e795
|
ceaa29b1486615abdbab0e6a7ad152353d3a3ccc
|
refs/heads/master
| 2021-01-25T06:44:31.070404
| 2018-04-25T11:14:12
| 2018-04-25T11:14:12
| 93,597,424
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,555
|
hpp
|
buffer.hpp
|
#ifndef __SNIPPETS_BUFFER_INC_HPP__
#define __SNIPPETS_BUFFER_INC_HPP__
#include "../abstractions/allocators.hpp"
#include "../abstractions/global.hpp"
#include <ios>
namespace Snippets {
class buffer {
char* buf;
struct malloc : public Allocator {
void* allocate(size_t size, void* v = nullptr);
void* reallocate(void* current, size_t size, void* v = nullptr);
void free(void* current, void* v = nullptr);
};
struct recursive : public Allocator {
void* allocate(size_t size, void* v);
void* reallocate(void* current, size_t size, void* v);
void free(void* current, void* v);
private:
void* worker;
};
protected:
Allocator* allocator;
size_t max_size;
size_t current_size;
public:
static malloc default_allocator;
static recursive recursive_allocator;
buffer(Allocator* allocator = &default_allocator,
void* allocateObject = nullptr);
buffer(size_t size, Allocator* allocator = &default_allocator,
void* allocateObject = nullptr);
buffer(std::istream& in, Allocator* allocator = &default_allocator,
void* allocateObject = nullptr);
~buffer();
void* alloc(size_t size);
template <typename T> void* alloc() {
if (sizeof(T) + current_size > max_size) {
throw AllocationError();
}
current_size += sizeof(T);
return buf + (current_size - (sizeof(T)));
}
void* offset(size_t offset);
void clear();
void resize(size_t new_size, bool allow_try = true);
void save(std::ostream& out);
int load(std::istream& in, size_t offset = 0);
};
}
#endif
|
e0619cbd78ae86dabae26918d4119aca8bdcf25e
|
1e8c820fe672d3a7392c5bfa7213a662ddc6c59e
|
/cpp/helper/external_api.h
|
e447576b5d7995a854cbaf88d506cd1c26bb67f3
|
[] |
no_license
|
Biceeeeepss/meta_fastdl
|
ef7632ded34ef711c8f4fe1823892a3bff0f86c6
|
437aa33f54cff758af3860278afd35cce794bbfe
|
refs/heads/master
| 2023-06-30T09:42:06.585210
| 2019-07-06T13:10:42
| 2019-07-06T13:26:59
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 684
|
h
|
external_api.h
|
#pragma once
#ifndef EXTERNAL_API_H
#define EXTERNAL_API_H
// This is some "hacky" way to avoid multiple "zero as null" errors in metamod and hlsdk headers
#ifndef CXXTEST_RUNNING // cxxtest generated runner.cpp file for some reason causes compile time errors.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
#include <extdll.h>
#include <meta_api.h>
#pragma GCC diagnostic pop
#endif
// SDK defines its own max/min, but it creates conflicts.
#if defined (max) || (min)
#include <algorithm>
#ifdef max
#undef max
using std::max;
#endif
#ifdef min
#undef min
using std::min;
#endif
#endif
#endif // EXTERNAL_API_H
|
ad3f85b64ab11f47aa3c38263681a707c3c02c2f
|
5ac4f358eef507d47bf17767c36fc55e5bff08b8
|
/board.h
|
ff60488cf409100f7442753294a45b6d519d1138
|
[] |
no_license
|
kamil0074/Reversi-CUDA
|
6d9589848bd60630be3bda757f7ed6429dd2dc30
|
a962d61f62517c65d965d1be6604989af9d22aa8
|
refs/heads/master
| 2020-05-26T02:16:33.320557
| 2018-03-09T15:59:32
| 2018-03-09T15:59:32
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,934
|
h
|
board.h
|
#ifndef BOARD
#define BOARD
#include <iostream>
#include <list>
#ifdef __CUDACC__
#include "cuda.h"
#define CUDA_CALLABLE_MEMBER __device__
#else
#define CUDA_CALLABLE_MEMBER
#endif
struct cell_t
{
int first,second;
CUDA_CALLABLE_MEMBER
cell_t(int first,int second):first(first),second(second)
{}
};
using namespace std;
typedef unsigned long long ull;
class Board
{
public:
ull player_pieces;
ull opponent_pieces;
enum Site
{
PLAYER,OPPONENT,NONE
};
static const int BOARD_SIZE;
static const cell_t DIRECTIONS[];
CUDA_CALLABLE_MEMBER
static int get_cell_number(int row,int column);
CUDA_CALLABLE_MEMBER
static cell_t get_cell_coordinates(int cell);
CUDA_CALLABLE_MEMBER
static bool is_correct_coordinate(int coordinate);
CUDA_CALLABLE_MEMBER
Board(ull player_pieces,ull opponent_pieces);
CUDA_CALLABLE_MEMBER
int get_empty_fields();
CUDA_CALLABLE_MEMBER
Site get_site(int cell);
CUDA_CALLABLE_MEMBER
Board pass_turn();
CUDA_CALLABLE_MEMBER
bool is_game_ended();
CUDA_CALLABLE_MEMBER
Board make_move(int cell);
CUDA_CALLABLE_MEMBER
bool is_correct_move(int cell);
CUDA_CALLABLE_MEMBER
bool can_player_put_piece();
#ifndef __CUDACC__
string text_representation(char player_sign='X',char opponent_sign='O');
#endif
CUDA_CALLABLE_MEMBER
Site get_dominating_site();
CUDA_CALLABLE_MEMBER
int get_score(Site site);
CUDA_CALLABLE_MEMBER
int get_move_value(int move);
private:
CUDA_CALLABLE_MEMBER
static int bit_count(ull value);
CUDA_CALLABLE_MEMBER
int get_nth_bit(ull value,int n);
CUDA_CALLABLE_MEMBER
bool is_correct_board();
CUDA_CALLABLE_MEMBER
ull get_flip_mask(int cell,cell_t direction);
CUDA_CALLABLE_MEMBER
bool is_players_piece_on_the_end(int cell,cell_t direction);
};
CUDA_CALLABLE_MEMBER
inline bool operator==(const Board&lhs,const Board&rhs)
{
return (lhs.player_pieces==rhs.player_pieces)&&(lhs.opponent_pieces==rhs.opponent_pieces);
}
#endif
|
2ea37229347ef919ece233c88d07e87ee8968455
|
a4fe99bd392f32d8ac91be42258e903fc2787f56
|
/src/leetcode/206_reverse_linked_list.cpp
|
22582e6524b8b9ea5c8be29841f1f761aee104dd
|
[] |
no_license
|
rickyggg/leetcode_and_swordoffer
|
4b1534baa532920b6dcb952e3f7f426af384ccea
|
447d28e6162ee406df4ab784602fb389dfabf0c7
|
refs/heads/master
| 2023-06-09T04:37:53.111477
| 2021-06-27T07:28:35
| 2021-06-27T07:28:35
| 294,115,817
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 323
|
cpp
|
206_reverse_linked_list.cpp
|
class Solution {
public:
ListNode *reverseList(ListNode *head) {
if (!head || !(head->next))
return head;
ListNode *first = nullptr, *second = head;
while (second) {
ListNode *tmp = second->next;
second->next = first;
first = second;
second = tmp;
}
return first;
}
};
|
420184278aa6a37eb7d323e9f8906b20c6ae17f9
|
5f85b78564048ca205e52d07266e1b78fdc92cc2
|
/test/test/Policia.cpp
|
75d89fcc3952b5b0dab212e5596daa7b4b71a0a7
|
[] |
no_license
|
sendim/AedaProj2.0
|
a20205d6605cf0a7c3ae8744e4451ac2533dea17
|
a1b68c3dd722664bee1cc5ab1910089fd6ab4bfe
|
refs/heads/master
| 2021-08-19T03:40:01.819980
| 2017-11-24T15:53:37
| 2017-11-24T15:53:37
| 111,933,161
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,802
|
cpp
|
Policia.cpp
|
#pragma once
#include "PostosDeSocorro.h"
Policia::Policia(int numSocorristas, int numVeiculos, string local, double x, double y, int numCarros, int numMotos) : PostoDeSocorro(numSocorristas, numVeiculos, local, x, y) {
setNumVeiculos(numCarros + numMotos);
this->numMotos = numMotos;
this->numCarros = numCarros;
}
double Policia::getProximidade(double x, double y) {
double distancia;
double x1 = coord.first;
double y1 = coord.second;
distancia = sqrt(((double)x - (double)x1)*((double)x - (double)x1) + ((double)y - (double)y1)*((double)y - (double)y1));
return distancia;
}
int Policia::tratamentoDeAssaltos(Acidente * a) {
int policias = a->getNumSocorristas();
int carros = a->getNumCarros();
bool noMotos = false;
bool noCarros = false;
if (numMotos < 1)
noMotos = true;
if (numCarros < 1)
noCarros = true;
if ((noMotos || noMotos) == false)
return 1;
if (carros == 2) { //se for num comercial
if (numCarros >= 1 && numMotos >= 2) {
numMotos -= 2;
numCarros -= 1;
numSocorristas -= 4;
numVeiculos -= 3;
cout << "Foram enviadas 2 motos e 1 carro.\n";
return 0;
}
if (noMotos && numCarros >= 2) {
numCarros -= 2;
numSocorristas -= 4;
numVeiculos -= 2;
cout << "Foram enviados 2 carros.\n";
return 0;
}
if (noCarros && numMotos >= 4) {
numCarros -= 4;
numSocorristas -= 4;
numVeiculos -= 4;
cout << "Foram enviados 4 motos.\n";
return 0;
}
}
if (carros == 1) { //se for num particular
if (numMotos >= 2) {
numMotos -= 2;
numSocorristas -= 2;
numVeiculos -= 2;
cout << "Foram enviadas 2 motos.\n";
return 0;
}
if (numMotos <= 1 && numCarros >= 1) {
numCarros -= 1;
numSocorristas -= 2;
numVeiculos -= 1;
cout << "Foi enviado 1 carro.\n";
return 0;
}
}
return 1;
}
|
c6b842c56789b5db76ebcd7bc89d7eef16d4ca4d
|
d17d5053089151c676a8fcbe683f0334e0396c32
|
/Project26/Check.h
|
0fce6f12bfb7bc40713dcf230a4066388ec0bfd1
|
[] |
no_license
|
neonmag/Check
|
fec05493957877b6fc2d6e485e448b2ec8f5f1b0
|
bac7ddbce9c2046185af36af62058d978e171556
|
refs/heads/master
| 2023-08-25T10:48:27.087340
| 2021-09-29T17:21:40
| 2021-09-29T17:21:40
| 411,766,815
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,707
|
h
|
Check.h
|
#include <iostream>
using namespace std;
class Check
{
private:
char* str;
public:
Check();
Check(const char* str);
Check(Check& obj);
void Test();
void Output();
void Input();
const char* GetStr();
void SetStr(const char* str);
~Check();
};
Check::Check()
{
this->str = nullptr;
}
Check::Check(const char* str)
{
if (this->str != nullptr)
{
delete[]this->str;
}
this->str = new char[strlen(str) + 1];
strcpy_s(this->str, strlen(str) + 1, str);
}
Check::Check(Check& obj)
{
delete[]this->str;
this->str = nullptr;
this->str = new char[strlen(obj.str) + 1];
strcpy_s(this->str, strlen(obj.str) + 1, obj.str);
}
void Check::Test()
{
char test[11] = { '(',')','+' ,'-','*','/',';','{','}','[',']' };
int counter[6]{ 0 };
for (int i = 0; i < strlen(this->str) + 1; i++)
{
if (this->str[i] == test[0])
{
counter[0] += 1;
}
if (this->str[i] == test[1])
{
counter[1] += 1;
}
if (this->str[i] == test[10])
{
counter[2] += 1;
}
if (this->str[i] == test[9])
{
counter[3] += 1;
}
if (this->str[i] == test[8])
{
counter[4] += 1;
}
if (this->str[i] == test[7])
{
counter[5] += 1;
}
}
if (counter[0] != counter[1] || counter[2] != counter[3] || counter[4] != counter[5])
{
cout << "\nError\n";
return;
}
for (int i = 0; i < strlen(this->str) + 1; i++)
{
for (int j = 0; j < strlen(this->str) + 1; j++)
{
if (this->str[i] == test[0] && this->str[i] == test[1])
{
break;
}
if (this->str[i] == test[0] && this->str[j] == test[10] || this->str[i] == test[0] && this->str[i] == test[8])
{
cout << "\nError\n";
return;
}
}
}
if (this->str[strlen(this->str) - 1] != test[6])
{
cout << "\nError\n";
return;
}
if (this->str[0] == test[1] || this->str[0] == test[2] || this->str[0] == test[3] || this->str[0] == test[4] ||
this->str[0] == test[5] || this->str[0] == test[6] || this->str[0] == test[8] || this->str[0] == test[9])
{
return;
}
for (int i = 0; i < strlen(this->str) - 1; i++)
{
if (this->str[i] == test[6])
{
return;
}
}
for (int i = 0; i < strlen(this->str); i++)
{
if (this->str[i] == test[0])
{
for (int j = i + 1; j < strlen(this->str); j++)
{
if (this->str[j] == test[1])
{
break;
}
else if (j == strlen(this->str) - 1 && this->str[j] != test[1])
{
for (int j = 0; j <= i; j++)
{
cout << this->str[j];
}
cout << "<-";
cout << endl;
return;
}
}
}
else if (this->str[i] == test[7])
{
for (int j = i + 1; j < strlen(this->str); j++)
{
if (this->str[j] == test[8])
{
break;
}
else if (j == strlen(this->str) - 1 && this->str[j] != test[8])
{
for (int j = 0; j <= i; j++)
{
cout << this->str[j];
}
cout << "<-";
cout << endl;
return;
}
}
}
else if (this->str[i] == test[9])
{
for (int j = i + 1; j < strlen(this->str); j++)
{
if (this->str[j] == test[10])
{
break;
}
else if (j == strlen(this->str) - 1 && this->str[j] != test[10])
{
for (int j = 0; j <= i; j++)
{
cout << this->str[j];
}
cout << "<-";
cout << endl;
return;
}
}
}
else if (this->str[i] == test[10])
{
for (int j = 0; j < i; j++)
{
if (this->str[j] == test[9])
{
break;
}
else if (j == i - 1 && this->str[j] != test[9])
{
for (int j = 0; j <= i; j++)
{
cout << this->str[j];
}
cout << "<-";
cout << endl;
return;
}
}
}
else if (this->str[i] == test[8])
{
for (int j = 0; j < i; j++)
{
if (this->str[j] == test[7])
{
break;
}
else if (j == i - 1 && this->str[j] != test[9])
{
for (int j = 0; j <= i; j++)
{
cout << this->str[j];
}
cout << "<-";
cout << endl;
return;
}
}
}
else if (this->str[i] == test[1])
{
for (int j = 0; j < i; j++)
{
if (this->str[j] == test[0])
{
break;
}
else if (j == i - 1 && this->str[j] != test[9])
{
for (int j = 0; j <= i; j++)
{
cout << this->str[j];
}
cout << "<-";
cout << endl;
return;
}
}
}
}
return;
}
inline void Check::Output()
{
cout << this->str;
}
inline void Check::Input()
{
this->str = new char[20];
cout << "\nEnter string: ";
cin.getline(this->str, 19);
}
inline const char* Check::GetStr()
{
return this->str;
}
inline void Check::SetStr(const char* str)
{
delete[]this->str;
this->str = nullptr;
this->str = new char[strlen(str) + 1];
strcpy_s(this->str, strlen(str) + 1, str);
}
inline Check::~Check()
{
delete[]this->str;
this->str = nullptr;
}
|
af49759e49c964471f9889e06832c647f32830c2
|
8dccfb43df8f8ac7d2d8a06717d378a231152bd7
|
/CygniCompiler/StringBuilder.hpp
|
12d728efecc91940e60ac11a46a3e567fbeef18e
|
[] |
no_license
|
YanjieHe/CygniCompiler
|
b87612de4cc5e439e0eee848e2a82ef56686d5ea
|
c84ee5e039d5c79d87a354bfa995bc7a999a0508
|
refs/heads/master
| 2020-03-21T12:25:45.989757
| 2018-11-04T17:47:21
| 2018-11-04T17:47:21
| 138,551,718
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 664
|
hpp
|
StringBuilder.hpp
|
#ifndef STRING_BUILDER_HPP
#define STRING_BUILDER_HPP
#include <string>
#include <vector>
using std::vector;
using std::wstring;
class StringBuilder
{
public:
void Append(wchar_t c);
void AppendStr(wstring s);
void Clear();
wstring ToString();
private:
vector<wchar_t> characters;
};
inline void StringBuilder::Append(wchar_t c)
{
characters.push_back(c);
}
inline void StringBuilder::Clear()
{
characters.clear();
}
inline wstring StringBuilder::ToString()
{
return wstring(characters.begin(), characters.end());
}
inline void StringBuilder::AppendStr(wstring s)
{
characters.insert(characters.end(), s.begin(), s.end());
}
#endif // STRING_BUILDER_HPP
|
c227aea940dcbccac616114568870e6d9f6f6b07
|
fe43035ae28bdee729990660c5f35fe5329e9a1d
|
/HW9/0110813_09_33.cpp
|
4606727b09f6f820294c9f9421330532234a3cf3
|
[] |
no_license
|
whereitisvc/DataStructure
|
711333344c5cb3485d5412b462c67c3c56c823e3
|
f0180f38d31638ea2f420b9d4a3edfb05d7c753a
|
refs/heads/master
| 2020-03-28T07:32:15.501372
| 2018-09-08T06:29:31
| 2018-09-08T06:29:31
| 147,908,075
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,619
|
cpp
|
0110813_09_33.cpp
|
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include "0110813_09_33.h"
typedef struct data
{
char name[100];
int priority;
}DATA;
int compare( void* p1, void* p2 )
{
int x1,x2;
x1 = ((DATA*)p1)->priority;
x2 = ((DATA*)p2)->priority;
if(x1>x2) return 1;
else if(x1==x2) return 0;
else return -1;
}
int main()
{
char name1[50],name2[50];
int A,B,C;
DATA* datap;
HEAP* heap = heapCreate(100,compare);
FILE* fp;
/////////////////////////////////////////////////////////////////////////// build heap
fp = fopen("9_33.txt","r");
while( fscanf( fp,"%s %s %d %d %d", &name1, &name2, &A, &B, &C ) != EOF )
{
strcat(name1," ");
strcat(name1,name2);
printf("%-20s %-5d %d %2d --> ",name1,A,B,C);
datap = (DATA*)malloc( sizeof(DATA) );
strcpy( datap->name, name1 );
datap->priority = A/1000+B-C;
heapInsert(heap, datap);
printf("%d\n", datap->priority);
}
////////////////////////////////////////////////////////////////////////// heap sort
int last = heap->last;
int count = 1;
printf("\n\n");
while( last > 0 )
{
datap = (DATA*)(heap->heapAry[0]);
printf("%2d. %-20s %d\n",count, datap->name, datap->priority);
last = heap->last;
heap->heapAry[0] = (DATA*)(heap->heapAry[last]);
heap->heapAry[last] = datap;
heap->last--;
_reheapDown (heap, 0);
count++;
}
getch();
return 0;
}
|
4fb44280e0c7a268a1c0f20509e5c7fffdc4b82d
|
bc6b55224c05e7f662c4147d499989609ff8cd1c
|
/ZCWebServer/JsonRequest/IJSONRequestHandler.h
|
895495fafef609555896070b134910b152a618f3
|
[] |
no_license
|
lossed1990/jinying
|
76fb2aabfbc9ca240549a00046d02e2100cddaf4
|
0d4131d773ff3b2a872a37a87b29064ee32e9e80
|
refs/heads/master
| 2021-09-02T11:38:41.390743
| 2018-01-02T09:26:35
| 2018-01-02T09:26:35
| 114,993,525
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 1,130
|
h
|
IJSONRequestHandler.h
|
#pragma once
#include <string>
using std::string;
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0501
#endif
#include <boost/asio/streambuf.hpp>
using boost::asio::streambuf;
#include "document.h"
#include "writer.h"
#include "stringbuffer.h"
using namespace rapidjson;
#include "EncodingToolsClass.h"
#define CUR_MAX_VIDEO_CHANS 256 //最大通道数
#define ERR_CODE_WRONG_PARAM 100 //参数错误
#define ERR_HTTP_REQUEST 101 //通信错误
#define ERR_BAD_RESPONSE 102 //服务器错误
#define ERR_EXCUTE_FAILED 103 //执行失败
#define ERR_LIST_INDEX_OVER 104 //下标越界
#define ERR_INTERFACE_DEPRECATED 105 //接口已弃用
class IJSONRequestHandler
{
public:
IJSONRequestHandler(void);
virtual ~IJSONRequestHandler(void) {}
protected:
streambuf m_sbRecvBuff;
static size_t json_write_callback(char *ptr, size_t size, size_t nmemb, void *userdata);
Document m_doc;
SizeType m_szResultCount;
SizeType m_szResultPos;
public:
int DoRequest(const char* pcURL, bool bIsPost, const char* pcContentOrParam, int nContSize);
};
typedef IJSONRequestHandler* (*PF_CREATEINSTANCE)();
|
a62b62e1a5e9c85c86c4d46c2b21af0c234ac87f
|
92bcac8dc852edfac54afbb3d7864fb9b2766cbc
|
/example/main.cpp
|
1afee905e655ad08eb07c7042afa114f4ad16d14
|
[] |
no_license
|
ForwardLoopLLC/amg8833
|
8305068658e50b8820b709d905d99e776fbaf5cf
|
0e712093a1f5fb6f2cab50011ed3abc859e3aa9e
|
refs/heads/master
| 2020-03-19T18:11:02.616673
| 2018-06-29T10:34:11
| 2018-06-29T10:34:11
| 136,797,810
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,465
|
cpp
|
main.cpp
|
#include "amg8833/amg8833.h" //drivers
#include <stdlib.h> // getenv
int main() {
AMG8833 amg8833(getenv("AMG8833_BUS")[0] - '0');
if (amg8833.error()) {
printf("Error: AMG8833 did not initialize\n");
return 1;
}
// reset all registers and settings
if(!amg8833.resetInitial()) {
printf("Error: failed to reset registers\n");
}
// turn off moving average mode
if(!amg8833.setNormalMode()) {
printf("Error: failed to set normal mode\n");
}
// disable interrupt, so the sensor reads the temperature values
// (instead of triggering an interrupt if the temperature fails below
// or above a certain threshold)
if(!amg8833.disableInterrupt()) {
printf("Error: failed to disable interrupt\n");
}
// the sensor will sample ten times per second
if(!amg8833.setFrameRate10Hz()) {
printf("Error: failed to set frame rate\n");
}
printf("AMG8833 initialized\n");
// Thermistor (sensor board) temperature
printf("Thermistor temperature: %f\n", amg8833.thermistorTemperature());
// Grid temperature for all pixels
double grid[64];
printf("Grid Temperature\n");
amg8833.gridTemperature(grid);
for (int row = 0; row < 8; row++) {
for (int col = 0; col < 8; col++) {
printf("%2.6f ", grid[row*col + col]);
}
printf("\n");
}
printf("AMG8833 installation succeeded.\n");
return 0;
}
|
8595a492007b45071aa7d1b58cedfd22a7360e95
|
1a03bbd8c602ee68a094f7ff5a35e59a3c28c756
|
/include/lua_vm.h
|
712a63a17a4ae1d8453cf3f881eb3ce2c549fe35
|
[] |
no_license
|
Joco223/Electronics
|
95f563346dca4a0e72095ebb43edebeea1290784
|
a13717241f7f75d8ce5bb40f06dbfff55f69261f
|
refs/heads/master
| 2022-11-19T05:35:17.029089
| 2020-07-21T17:31:33
| 2020-07-21T17:31:33
| 280,533,104
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 257
|
h
|
lua_vm.h
|
#pragma once
#include "sol.hpp"
#include <string>
#include <iostream>
#include <array>
#include <vector>
#include <fstream>
#include <sstream>
#include "tile.h"
namespace luaVM {
void initVM();
void updateTile(tile& t, std::array<tile*, 8>& sTiles);
}
|
f57eadd96b76e617f889980c6bfa41eb6de607e4
|
5b7e69802b8075da18dc14b94ea968a4a2a275ad
|
/DRG-SDK/SDK/DRG_BP_StickyFlame_classes.hpp
|
04ecb5290b3b69a672c6566328ab539ed0195a88
|
[] |
no_license
|
ue4sdk/DRG-SDK
|
7effecf98a08282e07d5190467c71b1021732a00
|
15cc1f8507ccab588480528c65b9623390643abd
|
refs/heads/master
| 2022-07-13T15:34:38.499953
| 2019-03-16T19:29:44
| 2019-03-16T19:29:44
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,141
|
hpp
|
DRG_BP_StickyFlame_classes.hpp
|
#pragma once
// Deep Rock Galactic (0.22) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "DRG_BP_StickyFlame_structs.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass BP_StickyFlame.BP_StickyFlame_C
// 0x0010 (0x0380 - 0x0370)
class ABP_StickyFlame_C : public AStickyFlame
{
public:
class UPathfinderCollisionComponent* PathfinderCollision; // 0x0370(0x0008) (CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_InstancedReference, CPF_IsPlainOldData)
class USphereComponent* Sphere; // 0x0378(0x0008) (CPF_BlueprintVisible, CPF_ZeroConstructor, CPF_InstancedReference, CPF_IsPlainOldData)
static UClass* StaticClass()
{
static auto ptr = UObject::FindObject<UClass>("BlueprintGeneratedClass BP_StickyFlame.BP_StickyFlame_C");
return ptr;
}
void UserConstructionScript();
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
b2a5a93621b1780405debdc3ac8e24cda5ca292c
|
ac9d24fedee3ca997f9fb036b43c7482c83b6be3
|
/src/operators/source/backend/gdal_source.h
|
4e28127470b79f433825910ff0f5819bf7a4552d
|
[
"MIT"
] |
permissive
|
SoerenHoffstedt/raster-time-series
|
80948fedaee03bbdd1364af51b52d897d241a210
|
b6b763c741fa8655e42ec38ae6c3fe1524bb5d28
|
refs/heads/master
| 2020-03-28T14:15:54.259358
| 2019-04-03T09:16:47
| 2019-04-03T09:16:47
| 148,472,691
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,040
|
h
|
gdal_source.h
|
#ifndef RASTER_TIME_SERIES_GDAL_SOURCE_H
#define RASTER_TIME_SERIES_GDAL_SOURCE_H
#include "operators/source/source_operator.h"
#include "util/gdal_util.h"
#include "util/time_interval.h"
#include <gdal_priv.h>
#include <boost/date_time/posix_time/posix_time.hpp>
namespace rts {
/**
* Source operator loading rasters with the GDAL library. This supports any raster format supported by GDAL.
* A GDALSource dataset is defined by a start and end point, and a time interval (time unit and value).
* Therefore it represents rasters that are valid in regular time intervals.
*/
class GDALSource : public SourceBackend {
public:
GDALSource(const QueryRectangle &qrect, const Json::Value ¶ms);
void initialize() override;
bool supportsOrder(Order o) const override;
OptionalDescriptor createDescriptor(double time, int pixelStartX, int pixelStartY, int tileIndex, const Resolution &rasterWorldPixelStart, const Scale &scale, const Origin &origin, const Resolution &tileCount) override;
double getCurrentTimeEnd(double currTime) const override;
void increaseCurrentTime(double &currTime) override;
void beforeTemporalIncrease() override;
Origin getOrigin() const override;
private:
std::shared_ptr<GDALDataset> currDataset;
GDALRasterBand *currRasterband; //this can stay a normal ptr, because it is handled by the dataset. The dataset now always has to live as long as the rasterband. maybe put them in one structure?
double currDatasetTime;
TimeInterval timeInterval;
std::string timeFormat;
std::string baseFileName;
std::string path;
int channel;
Origin origin;
std::map<std::string, std::shared_ptr<GDALDataset>> openDatasets;
Json::Value loadDatasetJson(const std::string &name);
double parseIsoTime(const std::string &str) const;
void loadCurrentGdalDataset(double time);
};
}
#endif //RASTER_TIME_SERIES_GDAL_SOURCE_H
|
bdcf0813e827da96d4010188c422bb08fa718695
|
54b4b6e7494ab4e133ec908a7832c3c0aadeb6ec
|
/main.cpp
|
01346b790e0ab7db10458504ec4fa4373e3eb380
|
[] |
no_license
|
xxvms/Lab3
|
d307cc14829128b84cd66c618228d1c6994a517e
|
ac8048a8a00c2799fcad43c9057525712255eb0b
|
refs/heads/master
| 2021-01-02T22:59:38.902659
| 2017-08-05T15:47:52
| 2017-08-05T15:47:52
| 99,432,268
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,447
|
cpp
|
main.cpp
|
#include <iostream>
/*
*
1. Create a Person base class with common attributes for a person (first_name, last_name, age, race, phone, as examples)
2. Make the age variable private
3. Make the phone variable protected
4. In the Person class, create a pure virtual function called OutputIdentity() that accepts no parameters and returns void
5. Also in the Person class, implement a virtual function called OutputAge() that displays "I am X years old", where X is the value of the Person's age attribute
6. Create a Student and a Teacher class that each inherit from the Person base class using public inheritance
7. In your main.cpp file, instantiate an Student object and initialize the member variables with valid data
8. Override the Student's OutputIdentity() pure virtual method to display the text "I am a student" to the console
9. Override the Student's OutputAge() virtual method to display the text "I am a student and" then calls the Person class's OutputAge() method
10. Instantiate a Teacher object in main.cpp and assign valid data to the member variables
11. Override the Teacher's OutputIdentity pure virtual method to display the text "I am a teacher" to the console
12. Override the Teacher's OutputAge() virtual method to display the text "I am a teacher and" then calls the Person class's OutputAge() method
*/
#include "Student.h"
#include "Teacher.h"
int main() {
Student student1();
Person person()
return 0;
}
|
5091210c30a8f0c862849cdffe7be26d3fe30184
|
7311568cf895f7e2e79b81f805c970f7a0211294
|
/clusterizer/miniBall.hh
|
583ef32bef4de8c5a2fa7b3327686c5f630cd1e1
|
[] |
no_license
|
ggrocca/vcont-ssp
|
fe5f79946e37f89c518528bcec9b1d4e148fe2b5
|
84dd37542f27ef6d90dabc335b7e0b7d30c2f8ed
|
refs/heads/master
| 2021-07-08T22:21:54.835511
| 2015-06-09T02:36:46
| 2015-06-09T02:36:46
| 106,338,052
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 821
|
hh
|
miniBall.hh
|
/* The following code is taken and adapted from BVH: https://code.google.com/p/bvh/ */
#ifndef MINSPHERE_H
#define MINSPHERE_H
#include "mtxlib.hh"
#include <math.h>
#include <vector>
#define radiusEpsilon 1e-4f
typedef vector3 Point3;
class miniBall
{
public:
miniBall();
miniBall(const Point3 &O);
miniBall(const Point3 &O, const Point3 &A);
miniBall(const Point3 &O, const Point3 &A, const Point3 &B);
miniBall(const Point3 &O, const Point3 &A, const Point3 &B, const Point3 &C);
float d2(const Point3 &P) const;
Point3 center;
float radius;
};
miniBall MinSphere(Point3 P[], unsigned int p);
miniBall RecurseMin(Point3 *P[], unsigned int p, unsigned int b=0);
float det(float m11, float m12, float m13,
float m21, float m22, float m23,
float m31, float m32, float m33);
#endif
|
d971d0c7075cbb50110f6cc211c7008710b45c1f
|
33f48429e074b4f52f42249e088b6f73e31b0a9b
|
/include/FileConstants.h
|
48f3fc5349f84d0890fbf5b20c3cc56fd3ec26a6
|
[
"MIT"
] |
permissive
|
forthommel/pps-tbrc
|
1e67cd04f47a35131fa019abfdabda23845e2a78
|
fcfac644c948790db6c646db73b2f66270b38feb
|
refs/heads/master
| 2020-12-24T16:32:27.898536
| 2015-10-31T17:42:38
| 2015-10-31T17:42:38
| 32,762,581
| 1
| 3
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,767
|
h
|
FileConstants.h
|
#ifndef FileConstants_h
#define FileConstants_h
#include <stdint.h>
#include <stdlib.h>
#include <string>
#include <map>
#include <fstream>
#include "VME_TDCEvent.h"
/**
* General header to store in each collected data file for offline readout. It
* enable any reader to retrieve the run/spill number, as well as the HPTDC
* configuration during data collection.
* \brief Header to the output files
* \author Laurent Forthomme <laurent.forthomme@cern.ch>
* \date 14 Apr 2015
*/
struct file_header_t {
uint32_t magic;
uint32_t run_id;
uint32_t spill_id;
uint8_t num_hptdc;
VME::AcquisitionMode acq_mode;
VME::DetectionMode det_mode;
};
/// Generate a random string of fixed length for file name
inline std::string GenerateString(const size_t len=5)
{
std::string out;
srand(time(NULL));
const char az[] =
"0123456789"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz";
out = "";
for (size_t i=0; i<len; i++) { out += az[rand()%(sizeof(az)-1)]; }
return out;
}
/**
* \brief Redirect outputs to another output stream
*/
class Logger
{
public:
inline Logger(std::ostream& lhs, std::ostream& rhs=std::cout) : fStream(rhs), fBuffer(fStream.rdbuf()) {
fStream.rdbuf(lhs.rdbuf());
}
inline ~Logger() { fStream.rdbuf(fBuffer); }
private:
std::ostream& fStream;
std::streambuf* const fBuffer;
};
/**
* \brief Redirect output stream to a string
* \author Laurent Forthomme <laurent.forthomme@cern.ch>
* \date 3 Aug 2015
*/
class LogRedirector
{
public:
inline LogRedirector(std::ostream& stm=std::cout) : fSS(), fRedirect(fSS, stm) {;}
inline std::string contents() const { return fSS.str(); }
private:
std::ostringstream fSS;
const Logger fRedirect;
};
#endif
|
61aeb582dddc12e0e4748401bbb0e94c69bb227a
|
3530657ad0df71dd18f16b4947be6f7fb4150341
|
/Homework 5 - Self-Balancing Trees/Red-Black Tree(Incomplete).cpp
|
07f8e7162a076c1c1cdd33b9038df4a39612f123
|
[] |
no_license
|
akatzuka/Algorithms-Practice
|
eb3fee07a71b26b4dca215302ea25e3ddbab9e44
|
4e02f4d3f66dd1397c9aa658ffd74426bb3200a5
|
refs/heads/master
| 2020-04-27T09:47:20.694035
| 2019-03-06T22:10:55
| 2019-03-06T22:10:55
| 174,228,863
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 6,139
|
cpp
|
Red-Black Tree(Incomplete).cpp
|
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
struct Node {
int data;
Node *left;
Node *right;
bool red;
Node *parent;
public:
Node(int d, Node *p) {
data = d;
parent = p;
red = true;
}
};
void swapColor(bool &a, bool &b)
{
bool tmp_color = a;
a = b;
b = tmp_color;
}
bool isRed(Node *curr) {
if (curr)
return curr->red;
return false;
}
class RedBlackTree {
private:
Node *root;
private:
Node *rotateLeft(Node *curr)
{
Node *temp = curr->right;
curr->right = temp->left;
temp->left = curr;
return temp;
}
Node *rotateRight(Node *curr)
{
Node *temp = curr->left;
curr->left = temp->right;
temp->right = curr;
return temp;
}
bool look(Node *root, int target) {
if (root == NULL)
return false;
if (root->data == target)
return true;
if (root->data < target)
return look(root->right, target);
else
return look(root->left, target);
}
Node* Min(Node *root){
if (root == NULL)
return NULL;
else if (root ->left)
return Min(root->left);
return root;
}
// think about return type
Node* fix(Node *curr)
{
if (!isRed(curr))
return curr;
if (curr == root)
{
curr->red = false;
return curr;
}
if (!isRed(curr->parent))
return curr;
Node *parent = curr->parent;
Node *gParent = parent->parent;
Node *uncle;
if (gParent->left == parent)
uncle = gParent->right;
else // gParent->right == parent
uncle = gParent->left;
//Case 1: The uncle of parent is also red, only need to recolor
if (isRed(uncle))
{
gParent->parent->red = true;
gParent->red = false;
uncle->parent->red = false;
parent = gParent->parent;
fix(gParent);
}
else
{
if (gParent->left == parent)
{ // Case 2: parent is right child of its parent, left rotate
if (parent->right == curr)
{
rotateLeft(root);
parent = gParent;
gParent = parent->parent;
}
// Case 3: Parent is left child of its parent, right rotate
rotateRight(root);
swapColor(gParent->red, gParent->parent->red);
parent = gParent;
}
else
{ // gParent->right == parent // right something case
if (parent->left == curr)
{
// Case 4: parent is left child of its parent, right rotate
rotateRight(root);
parent = gParent;
gParent = parent->parent;
}
// Case 5: parent is right child of its parent, left rotate
rotateLeft(root);
swapColor(gParent->red, gParent->parent->red);
parent = gParent;
}
}
curr->red = false;
return(curr);
}
Node *insert(Node *root, Node *parent, bool left, int data) {
if (!root)
{
Node *n = new Node(data, parent);
if (left)
parent->left = n;
else
parent->right = n;
fix(n);
return n;
}
if (root->data > data) {
insert(root->left, root, true, data);
}
else {
insert(root->right, root, false, data);
}
return root;
}
void level(Node *root) {
auto q = queue<Node *>();
q.push(root);
while(!q.empty()) {
Node *temp = q.front();
q.pop();
cout << temp->data << "("<< 0 << ") ";
if (temp->left)
q.push(temp->left);
if (temp->right)
q.push(temp->right);
}
}
Node *rem(Node *root, int target) {
Node* t;
if(root == NULL)
return NULL;
else if (root -> data > target)
{
root->left = rem(root -> left, target);
}
else if (root -> data < target)
{
root -> right = rem(root -> right, target);
}
else if (root -> right && root -> left)
{
t = Min(root->right);
root->data = t->data;
root->right = rem(root->right, root->data);
}
else {
t = root;
if(root->left == NULL)
root = root->right;
else if (root-> right == NULL)
root = root->left;
delete t;
}
if(root == NULL)
return NULL;
// Use same BST logic to find data and delete node
// Check balance of root
// If absolute value of balance is > 1:
//// Case 1: If balance is positive
//// Check balance of root->left
////// If negative, rotate root->left to the left; set root->left to result
//// Rotate root right; set root to result
//// Case 2: If balance is negative
//// Check balance of root->right
////// If positive, rotate root->right to the right; set root->right to result
//// Rotate root left; set root to result
//// Update height of root to be 1 + max(left, right)
return NULL;
}
public:
RedBlackTree()
{
root = NULL;
}
bool lookup(int target) {
return look(root, target);
}
void insert(int data) {
root = insert(root, nullptr, false, data);
}
void levelOrder(){
level(root);
}
void remove(int target){
//root = rem(root, target);
}
};
int main() {
//initialze variables
RedBlackTree n;
int dat, m;
string x;
cin >> m;
for (int i = 0; i < m; i++)
{
cin >> x;
if (x == "lookup")
{
cin >> dat;
cout << n.lookup(dat) << endl;
}
else if (x == "insert")
{
cin >> dat;
n.insert(dat);
}
else if (x == "delete")
{
cin >> dat;
n.remove(dat);
}
else if (x == "levelorder")
{
n.levelOrder();
cout << endl;
}
}
return 0;
}
|
6be8a8156b741e782c72921470777edc40a41881
|
dc7c38f1f91ab45c3047caf66c736454c429bc61
|
/Lib/Source/Interpreter.cpp
|
774f0303e680d5341bdf4cbebe69fd9886e7635c
|
[
"MIT"
] |
permissive
|
RcCreeperTech/V3DLib
|
83d76e2b252c3cc5143df4ea43aaf9c72642ad85
|
38eb8d55b8276de5cf703d8e13fb9b5f220c49f0
|
refs/heads/main
| 2023-07-17T18:21:20.855603
| 2021-08-21T05:02:22
| 2021-08-21T05:02:22
| 398,517,570
| 1
| 0
|
NOASSERTION
| 2021-08-21T09:28:05
| 2021-08-21T09:28:05
| null |
UTF-8
|
C++
| false
| false
| 16,240
|
cpp
|
Interpreter.cpp
|
#include "Source/Interpreter.h"
#include <algorithm> // reverse()
#include "Common/SharedArray.h"
#include "Source/Stmt.h"
#include "Common/BufferObject.h"
#include "Target/EmuSupport.h"
#include "Support/basics.h"
namespace V3DLib {
using ::operator<<; // C++ weirdness
namespace {
Vec const Always(1);
// State of a single core.
struct CoreState {
int id; // Core id
int nextUniform = -2; // Pointer to next uniform to read
Seq<Vec> loadBuffer; // Load buffer
int readStride = 0; // Read stride
int writeStride = 0; // Write stride
Stmts stack; // Control stack
Data emuHeap;
~CoreState() {
delete [] m_env;
}
void init_env(int numVars) {
assert(numVars >= 0);
m_env = new Vec [numVars + 1];
sizeEnv = numVars + 1;
}
Vec &env(int env_id) {
assert(0 <= env_id && env_id < sizeEnv);
assert(nullptr != m_env);
return m_env[env_id];
}
void store_to_heap(Vec const &index, Vec &val);
Vec load_from_heap(Vec const &index);
static void reset_count() {
load_show_count = 0;
store_show_count = 0;
}
private:
Vec *m_env = nullptr; // Environment mapping vars to values
int sizeEnv = -1; // Size of the environment
static int load_show_count;
static int store_show_count;
};
int CoreState::load_show_count = 0;
int CoreState::store_show_count = 0;
// State of the Interpreter.
struct InterpreterState : public EmuState {
CoreState core[MAX_QPUS]; // State of each core
InterpreterState(int in_num_qpus, IntList const &in_uniforms) : EmuState(in_num_qpus, in_uniforms) {}
};
void CoreState::store_to_heap(Vec const &index, Vec &val) {
assert(writeStride == 0); // usage of writeStride is probably wrong!
int const show_count = 3;
if (!index.is_uniform()) {
// NOTE: This part will not work for vc4 DMA output!
// Better to get rid of it
std::string msg;
msg << "store_to_heap(): index does not have all same values:" << index.dump();
if (store_show_count == (show_count - 1)) {
msg << "\n(this message not shown for further occurences)";
}
if (store_show_count < show_count) {
warning(msg);
}
store_show_count ++;
// The human has been warned, assume that she knows what she's doing
for (int i = 0; i < NUM_LANES; i++) {
uint32_t hp = (uint32_t) index[i].intVal + 4*i; // TODO examine why '4*i' is necessary
emuHeap.phy(hp>>2) = val[i].intVal;
}
} else {
uint32_t hp = (uint32_t) index[0].intVal; // NOTE: only first value used
for (int i = 0; i < NUM_LANES; i++) {
emuHeap.phy(hp>>2) = val[i].intVal;
hp += 4 + writeStride; // writeStride only relevant for DMA
}
}
}
Vec CoreState::load_from_heap(Vec const &index) {
assert(readStride == 0); // Usage of readStride is probably wrong!
Vec v;
int const show_count = 3;
if (!index.is_uniform()) {
std::string msg;
msg << "load_from_heap(): index does not have all same values: " << index.dump();
if (load_show_count == (show_count - 1)) {
msg << "\n(this message not shown for further occurences)";
}
if (load_show_count < show_count) {
warning(msg);
}
load_show_count ++;
// The human has been warned, assume that she knows what she's doing
for (int i = 0; i < NUM_LANES; i++) {
uint32_t hp = (uint32_t) index[i].intVal + 4*i;
v[i].intVal = emuHeap.phy((hp >> 2));
}
} else {
uint32_t hp = (uint32_t) index[0].intVal; // NOTE: only first value used
for (int i = 0; i < NUM_LANES; i++) {
v[i].intVal = emuHeap.phy((hp >> 2));
hp += 4 + readStride; // readStride only relevant for DMA
}
}
return v;
}
} // anon namespace
// ============================================================================
// Evaluate an arithmetic expression
// ============================================================================
Vec eval(InterpreterState &is, CoreState* s, Expr::Ptr e) {
Vec v;
switch (e->tag()) {
case Expr::INT_LIT: v = e->intLit; break;
case Expr::FLOAT_LIT: v = e->floatLit; break;
case Expr::APPLY: v.apply(e->apply_op(), eval(is, s, e->lhs()), eval(is, s, e->rhs())); break;
case Expr::DEREF: v = s->load_from_heap(eval(is, s, e->deref_ptr())); break;
case Expr::VAR: {
Var var = e->var();
switch (var.tag()) {
case STANDARD: v = s->env(var.id()); break;
case UNIFORM: v = is.get_uniform(s->id, s->nextUniform); break;
case ELEM_NUM: v = EmuState::index_vec; break;
default:
assertq(false, "eval(): unhandled var tag");
break;
}
}
break;
default:
assertq(false, "eval(): unhandled Expr tag");
break;
}
return v;
}
// ============================================================================
// Evaluate boolean expression
// ============================================================================
Vec evalBool(InterpreterState &is, CoreState* s, BExpr::Ptr e) {
Vec v;
switch (e->tag()) {
// Negation
case NOT:
v = evalBool(is, s, e->neg());
for (int i = 0; i < NUM_LANES; i++)
v[i].intVal = !v[i].intVal;
return v;
// Conjunction
case AND: {
Vec a = evalBool(is, s, e->lhs());
Vec b = evalBool(is, s, e->rhs());
for (int i = 0; i < NUM_LANES; i++)
v[i].intVal = a[i].intVal && b[i].intVal;
return v;
}
// Disjunction
case OR: {
Vec a = evalBool(is, s, e->lhs());
Vec b = evalBool(is, s, e->rhs());
for (int i = 0; i < NUM_LANES; i++)
v[i].intVal = a[i].intVal || b[i].intVal;
return v;
}
// Comparison
case CMP: {
Vec a = eval(is, s, e->cmp_lhs());
Vec b = eval(is, s, e->cmp_rhs());
if (e->cmp.type() == FLOAT) {
// Floating-point comparison
for (int i = 0; i < NUM_LANES; i++) {
float x = a[i].floatVal;
float y = b[i].floatVal;
switch (e->cmp.op()) {
case CmpOp::EQ: v[i].intVal = x == y; break;
case CmpOp::NEQ: v[i].intVal = x != y; break;
case CmpOp::LT: v[i].intVal = x < y; break;
case CmpOp::GT: v[i].intVal = x > y; break;
case CmpOp::LE: v[i].intVal = x <= y; break;
case CmpOp::GE: v[i].intVal = x >= y; break;
default: assert(false);
}
}
return v;
}
else {
// Integer comparison
for (int i = 0; i < NUM_LANES; i++) {
int32_t x = a[i].intVal;
int32_t y = b[i].intVal;
switch (e->cmp.op()) {
case CmpOp::EQ: v[i].intVal = x == y; break;
case CmpOp::NEQ: v[i].intVal = x != y; break;
// Ideally compiler would implement:
// case CmpOp::LT: v[i].intVal = x < y; break;
// case CmpOp::GT: v[i].intVal = x > y; break;
// case CmpOp::LE: v[i].intVal = x <= y; break;
// case CmpOp::GE: v[i].intVal = x >= y; break;
// But currently it implements:
case CmpOp::LT: v[i].intVal = ((x-y) & 0x80000000) != 0; break;
case CmpOp::GE: v[i].intVal = ((x-y) & 0x80000000) == 0; break;
case CmpOp::LE: v[i].intVal = ((y-x) & 0x80000000) == 0; break;
case CmpOp::GT: v[i].intVal = ((y-x) & 0x80000000) != 0; break;
default: assert(false);
}
}
return v;
}
}
}
// Unreachable
assert(false);
return Vec();
}
// ============================================================================
// Evaulate condition
// ============================================================================
bool evalCond(InterpreterState &is, CoreState* s, CExpr::Ptr e) {
Vec v = evalBool(is, s, e->bexpr());
switch (e->tag()) {
case ALL: {
bool b = true;
for (int i = 0; i < NUM_LANES; i++)
b = b && v[i].intVal;
return b;
}
case ANY: {
bool b = false;
for (int i = 0; i < NUM_LANES; i++)
b = b || v[i].intVal;
return b;
}
}
// Unreachable
assert(false);
return false;
}
/**
* Assign to a variable
*/
void assignToVar(CoreState* s, Vec cond, Var v, Vec x) {
switch (v.tag()) {
// Normal variable
case STANDARD:
for (int i = 0; i < NUM_LANES; i++) {
if (cond[i].intVal) {
s->env(v.id())[i] = x[i];
}
}
break;
case TMU0_ADDR: { // Load via TMU
assert(s->loadBuffer.size() < 8);
Vec w = s->load_from_heap(x);
s->loadBuffer.append(w);
break;
}
default:
assertq(false, "assignToVar(): unhandled var-tag", true);
break;
}
}
/**
* Execute assignment
*/
void execAssign(InterpreterState &is, CoreState* s, Vec cond, Expr::Ptr lhs, Expr::Ptr rhs) {
Vec val = eval(is, s, rhs);
switch (lhs->tag()) {
case Expr::VAR:
assignToVar(s, cond, lhs->var(), val);
break;
case Expr::DEREF: {
Vec index = eval(is, s, lhs->deref_ptr());
s->store_to_heap(index, val);
}
break;
default:
assert(false);
break;
}
}
// ============================================================================
// Condition vector auxiliaries
// ============================================================================
/**
* And two condition vectors
*/
Vec vecAnd(Vec x, Vec y) {
Vec v;
for (int i = 0; i < NUM_LANES; i++)
v[i].intVal = x[i].intVal && y[i].intVal;
return v;
}
// ============================================================================
// Execute where statement
// ============================================================================
void execWhere(InterpreterState &is, CoreState *s, Vec cond, Stmt::Ptr stmt);
void execWhere(InterpreterState &is, CoreState *s, Vec cond, Stmt::Array const &stmts) {
for (int i = 0; i < (int) stmts.size(); i++) {
execWhere(is, s, cond, stmts[i]);
}
}
void execWhere(InterpreterState &is, CoreState *s, Vec cond, Stmt::Ptr stmt) {
if (!stmt) return;
switch (stmt->tag) {
// No-ops
case Stmt::GATHER_PREFETCH:
case Stmt::SKIP:
return;
// Sequential composition
case Stmt::SEQ: {
breakpoint
execWhere(is, s, cond, stmt->body());
return;
}
// Assignment
case Stmt::ASSIGN:
assertq(stmt->assign_lhs()->tag() == Expr::VAR, "V3DLib: only var assignments permitted in 'where'");
execAssign(is, s, cond, stmt->assign_lhs(), stmt->assign_rhs());
return;
// Nested where
case Stmt::WHERE: {
Vec b = evalBool(is, s, stmt->where_cond());
execWhere(is, s, vecAnd(b, cond), stmt->then_block());
execWhere(is, s, vecAnd(b.negate(), cond), stmt->else_block());
return;
}
default:
assertq(false, "V3DLib: only assignments and nested 'where' statements can occur in a 'where' statement");
return;
}
}
// ============================================================================
// Execute load receive & store request statements
// ============================================================================
void execLoadReceive(CoreState* s, Expr::Ptr e) {
assert(s->loadBuffer.size() > 0);
assert(e->tag() == Expr::VAR);
Vec val = s->loadBuffer.remove(0);
assignToVar(s, Always, e->var(), val);
}
// ============================================================================
// Execute code
// ============================================================================
bool dma_exec(InterpreterState &is, CoreState* s, Stmt::Ptr &stmt) {
bool ret = true;
switch (stmt->tag) {
case Stmt::SET_READ_STRIDE: {
Vec v = eval(is, s, stmt->dma.stride_internal());
s->readStride = v[0].intVal;
}
break;
case Stmt::SET_WRITE_STRIDE: {
Vec v = eval(is, s, stmt->dma.stride_internal());
s->writeStride = v[0].intVal;
}
break;
case Stmt::SEND_IRQ_TO_HOST:
case Stmt::DMA_READ_WAIT:
case Stmt::DMA_WRITE_WAIT:
case Stmt::SETUP_VPM_READ:
case Stmt::SETUP_VPM_WRITE:
case Stmt::SETUP_DMA_READ:
case Stmt::SETUP_DMA_WRITE:
// Interpreter ignores these
break;
case Stmt::DMA_START_READ:
case Stmt::DMA_START_WRITE:
fatal("V3DLib: DMA access not supported by interpreter\n");
break;
default:
ret = false;
break;
}
return ret;
}
void append_stack(CoreState &s, Stmt::Array const &stmts) {
// statements need to be placed reversed on the stack, which pushes and pops on the back
for (int i = (int) stmts.size() - 1; i >= 0; i--) {
s.stack << stmts[i];
}
}
void exec(InterpreterState &is, int core_index) {
CoreState *s = &is.core[core_index];
assert(s->stack.size() > 0);
// Get next statement
Stmt::Ptr stmt = s->stack.back();
s->stack.pop_back();
if (stmt == nullptr) { // Apparently this happened
assertq(false, " Interpreter: not expecting nullptr for stmt", true);
return;
}
if (stmt->do_break_point()) {
#ifdef DEBUG
printf("Interpreter: hit breakpoint for stmt: %s\n", stmt->dump().c_str());
breakpoint
#endif
}
switch (stmt->tag) {
case Stmt::GATHER_PREFETCH: // Ignore
case Stmt::SKIP:
break;
case Stmt::ASSIGN: // Assignment
execAssign(is, s, Always, stmt->assign_lhs(), stmt->assign_rhs());
break;
case Stmt::SEQ: // Sequential composition
append_stack(*s, stmt->body());
break;
case Stmt::WHERE: { // Conditional assignment
Vec b = evalBool(is, s, stmt->where_cond());
execWhere(is, s, b, stmt->then_block());
execWhere(is, s, b.negate(), stmt->else_block());
}
break;
case Stmt::IF:
if (evalCond(is, s, stmt->if_cond()))
append_stack(*s, stmt->then_block());
else if (!stmt->else_block().empty()) { // This test shouldn't matter much
append_stack(*s, stmt->else_block());
}
break;
case Stmt::WHILE:
if (evalCond(is, s, stmt->loop_cond())) {
s->stack << stmt;
append_stack(*s, stmt->body());
}
break;
case Stmt::LOAD_RECEIVE:
execLoadReceive(s, stmt->address());
break;
case Stmt::SEMA_INC: if (is.sema_inc(stmt->dma.semaId())) s->stack << stmt; break;
case Stmt::SEMA_DEC: if (is.sema_dec(stmt->dma.semaId())) s->stack << stmt; break;
default:
if (!dma_exec(is, s, stmt)) {
assertq(false, "interpreter: unexpected stmt-tag in exec()");
}
break;
}
}
// ============================================================================
// Interpreter
// ============================================================================
/**
* Run the interpreter
*
* The interpreter parses the CFG ('source code') directly.
*
* The interpreter works in a similar way to the emulator. The
* difference is that the interpreter operates on source code and the
* emulator on target code.
*
* @param numCores Number of cores active
* @param stmt Source code
* @param numVars Max var id used in source
* @param uniforms Kernel parameters
* @param heap
* @param output Output from print statements (if NULL, stdout is used)
*/
void interpreter(
int numCores,
Stmts const &stmts,
int numVars,
IntList &uniforms,
BufferObject &heap
) {
InterpreterState state(numCores, uniforms);
// Initialise state
for (int i = 0; i < numCores; i++) {
CoreState &s = state.core[i];
s.id = i;
s.init_env(numVars);
s.emuHeap.heap_view(heap);
}
// Put statement on each core's control stack
// Note the reversal, to use it as an actual stack
for (int i = 0; i < numCores; i++) {
auto &stack = state.core[i].stack;
stack = stmts;
std::reverse(stack.begin(), stack.end());
}
CoreState::reset_count();
// Run code
bool running = true;
while (running) {
running = false;
for (int i = 0; i < numCores; i++) {
if (state.core[i].stack.size() > 0) {
running = true;
exec(state, i);
}
}
}
}
} // namespace V3DLib
|
b07708df812c0e9984fb77fc9f939c2418900d83
|
558b456f7bf3e763517a44e91833962c6bb4a85a
|
/demo/proj/base_classes/policies/serialization.h
|
f167ebf5198eb44c98bd3e1ccfda05396964428d
|
[
"BSD-3-Clause"
] |
permissive
|
gui-works/opengl_gui
|
cdbbd13bb1b9d2de473a9649eb02fa2d0bdbc599
|
be90af5d5c351e3b2ed3be5d9f6ba2cf07ef8130
|
refs/heads/master
| 2020-07-03T22:53:29.305888
| 2018-06-03T23:15:14
| 2019-02-20T23:28:59
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 921
|
h
|
serialization.h
|
#pragma once
#include "code.h"
#include <cereal/archives/binary.hpp>
#include <cereal/types/unordered_map.hpp>
#include <cereal/types/memory.hpp>
#include <cereal/types/vector.hpp>
#include <cereal/types/array.hpp>
#include <sstream>
namespace code_policy
{
template<class...P> vector<char> serialize_into_vec(P &&...p)
{
std::stringstream s;
{
cereal::BinaryOutputArchive a(s);
a(forward<P>(p)...);
}
std::streamsize size = 0;
if(s.seekg(0, std::ios::end).good())
size = s.tellg();
if(s.seekg(0, std::ios::beg).good())
size -= s.tellg();
vector<char> data(size_t(size), 0);
if(size > 0)
s.read(data.data(), size);
return data;
}
template<class...P> void deserialize_from_vec(vector<char> const&data, P &&...p)
{
std::stringstream s;
s.write(data.data(), static_cast<std::streamsize>(data.size()));
{
cereal::BinaryInputArchive a(s);
a(forward<P>(p)...);
}
}
}
|
eea91d5b48b09d176134bb282242e69d379f1f42
|
316afd119d51b273a523f25844cfea4c6c820df7
|
/score/src/mainScore.cpp
|
f1d055e92d530abe852e8e7cb66371a87371d26e
|
[
"BSD-3-Clause"
] |
permissive
|
victoriapc/HockusPockus
|
1232f8256c67a781b046cd026e04ab9191a8693f
|
2130b462b0038a527061744ab7faf20c2996c04f
|
refs/heads/master
| 2020-12-12T10:35:58.058950
| 2020-04-20T20:49:37
| 2020-04-20T20:49:37
| 234,106,668
| 0
| 4
|
BSD-3-Clause
| 2020-04-09T17:21:01
| 2020-01-15T15:09:11
|
HTML
|
UTF-8
|
C++
| false
| false
| 2,845
|
cpp
|
mainScore.cpp
|
#include "Game.h"
#include "ROS_topicNames.h"
#include <ros/ros.h>
#include <std_msgs/Bool.h>
#include <iostream>
#include <vector>
#include <dynamic_reconfigure/server.h>
#include <score/scoreConfig.h>
ros::Subscriber _startSubscriber;
ros::Publisher _scorePublisher;
ros::Publisher _endOfGamePublisher ;
class NewGameListener
{
public:
//! NewGameListener's constructor
NewGameListener():m_pCurrentGame(nullptr),m_playerNames(),m_scoreToWin(10){};
//! callback to start a new game, this is triggered when a message is publish on the ROS_topicNames::GAME_STATE topic
/*!
\param i_msg :std_msgs::Bool that indicates if we should start a new game or stop the current one
*/
void callbackStartGame(const std_msgs::Bool::ConstPtr& i_msg)
{
if(m_pCurrentGame != nullptr) //stop score keeping of the current game, if there's one
{
delete m_pCurrentGame;
}
if(i_msg->data)
{
m_pCurrentGame = new Game(&m_playerNames,m_scoreToWin,&_scorePublisher,&_endOfGamePublisher);
}
}
//! method to refresh the players' names, this is triggered when a message is publish on the ROS_topicNames::PLAYERS_NAMES topic
/*!
\param i_playerNames : std::string that indicates the names of the players, elements are separated by ";"
*/
void updatePlayersNames(const std::string& i_playerNames)
{
if (!i_playerNames.empty())
{
std::string buffer;
std::istringstream ss(i_playerNames);
m_playerNames.clear();
while (std::getline(ss, buffer, ';'))
{
if(buffer.size() >0)
{
m_playerNames.push_back(buffer);
}
}
}
}
//! method to refresh the score to win, this is triggered when a message is publish on the ROS_topicNames::SCORE_TO_WIN topic
/*!
\param i_scoreToWin :int that indicates the new score to win
*/
void updateScoreToWin(int i_scoreToWin)
{
m_scoreToWin = i_scoreToWin;
}
void param_callback(score::scoreConfig &config, uint32_t level)
{
updateScoreToWin(config.goal_limit);
updatePlayersNames(config.name_players);
}
private:
Game * m_pCurrentGame;
std::vector<std::string> m_playerNames;
int m_scoreToWin ;
};
int main(int argc, char*argv[])
{
ros::init(argc, argv, "score");
dynamic_reconfigure::Server<score::scoreConfig> server;
dynamic_reconfigure::Server<score::scoreConfig>::CallbackType f;
ros::NodeHandle n;
NewGameListener newGameListener = NewGameListener();
_startSubscriber = n.subscribe(ROS_topicNames::GAME_STATE, 1000, &NewGameListener::callbackStartGame, &newGameListener);
_scorePublisher = n.advertise<std_msgs::String>(ROS_topicNames::SCORES, 1000);
_endOfGamePublisher = n.advertise<std_msgs::Bool>(ROS_topicNames::GAME_STATE, 1000);
f = boost::bind(&NewGameListener::param_callback, newGameListener, _1, _2);
server.setCallback(f);
ros::spin();
}
|
df154bcde91f157f6890944eb0dfc73976216639
|
62134f077506e836e5b8025f2ea0b6a5557f7d1f
|
/ConsoleApplication2/LA.cpp
|
ea28bcf5d8a8f0e164a93431bae9edd2b2014f0e
|
[] |
no_license
|
kang9kang/-
|
190b1c31357560bab82d6451cec90abce28b185d
|
b18da17aeea33d340438aca1e5d19998c0a90264
|
refs/heads/main
| 2022-12-25T06:21:19.109536
| 2020-10-09T07:06:13
| 2020-10-09T07:06:13
| 300,542,887
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 13,244
|
cpp
|
LA.cpp
|
#include <iostream>
#include "LA.h"
using namespace std;
LA::LA(const char* s) :fin(s), line(1), num(0), fg(0), ch('\0')
{
sin << fin.rdbuf();
txt = sin.str();
fin.close();
fin.clear();
}
void LA::scan()
{
int p = 0;
cout << " {\"ch\":[" << endl;
//读取第一个非空字符
do {
ch = txt[p++];
if (ch == 10)
line++;
} while (ch == ' ' || ch == 10);
// cout << "line " << line << " :" << endl;
while (ch != '\0') {
while (ch == ' ' || ch == 10) {
if (ch == 10) {
line++;
// cout << "line " << line << " :" << endl;
}
ch = txt[p++];
}
//处理'_'开头的变量
if (ch == '_') {
word += ch;
ch = txt[p++];
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_') {
fg = 2;
word += ch;
ch = txt[p++];
while ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_') {
word += ch;
ch = txt[p++];
}
}
else {
fg = -1;
word += ch;
ch = txt[p++];
while ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_') {
word += ch;
ch = txt[p++];
}
}
switch (fg) {
case -1: cout << "error: " << '<' << word << '>' << endl; break;
case 2: cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
default: break;
}
word.clear();
fg = 0;
}
//处理保留字和字母开头的变量
if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
fg = 1;
word += ch;
ch = txt[p++];
while ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_') {
word += ch;
ch = txt[p++];
}
for (int i = 0; i < 12; i++) {
if (/*i == 7 &&*/ word != rsv_words1[i]&&ch!='('&& (word != rsv_words2[i]))
fg=2;
if ( (word == rsv_words1[i])/*||ch=='('|| (word == rsv_words2[i])*/) {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
if ((word == rsv_words2[i])/*||ch=='('|| (word == rsv_words2[i])*/) {
fg = 7;
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
if (/*(word == rsv_words1[i])*//*||*/ch=='('/*|| (word == rsv_words2[i])*/) {
fg = 8;
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
if (/*i == 7 &&*/ word != rsv_words1[i] && ch != '(' && (word != rsv_words2[i]))
fg = 2;
}
}
if (fg == 2 && ch != '[') {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
fg = 0;
}
if (fg == 2 && ch == '[') {
fg = 9;
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
fg = 0;
}
}
//处理整数
if (ch >= '0' && ch <= '9') {
fg = 3;
num = 10 * num + (ch - '0');
ch = txt[p++];
while (ch >= '0' && ch <= '9') {
num = 10 * num + (ch - '0');
ch = txt[p++];
}
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << num << "\"}," << endl;
num = 0;
fg = 0;
}
//处理符号
switch (ch) {
//处理运算符
case '+':
fg = 4;
if (txt[p] == '=') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else if (txt[p] == '+') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case '-':
fg = 4;
if (txt[p] == '=') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else if (txt[p] == '-') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case '*':
fg = 4;
if (txt[p] == '=') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case '/':
fg = 4;
if (txt[p] == '=') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else if (txt[p] == '/') {
while (ch != '\0' && ch != '\n')
ch = txt[p++];
break;
}
else if (txt[p] == '*') {
ch = txt[p++];
do{
ch = txt[p++];
} while (ch != '*');
ch = txt[p++];
ch = txt[p++];
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case '%':
fg = 4;
if (txt[p] == '=') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case '=':
fg = 4;
if (txt[p] == '=') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case '<':
fg = 4;
if (txt[p] == '=') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
if (txt[p] == '<') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case '>':
fg = 4;
if (txt[p] == '=') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
if (txt[p] == '>') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case '!':
fg = 4;
if (txt[p] == '=') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case'&':
fg = 4;
if (txt[p] == '&') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
case'|':
fg = 4;
if (txt[p] == '|') {
word += ch;
ch = txt[p++];
word += ch;
ch = txt[p++];
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << word << "\"}," << endl;
word.clear();
break;
}
else {
cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl;
ch = txt[p++];
break;
}
//处理分隔符
case ',': fg = 5; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
case ';': fg = 5; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
case ':': fg = 5; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
//处理界符
case '(': fg = 6; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
case ')': fg = 6; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
case '[': fg = 6; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
case ']': fg = 6; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
case '{': fg = 6; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
case '}': fg = 6; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
case '"': fg = 6; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
case '\'': fg = 6; cout << "{\"type\":\"" << fg << "\",\"value\":\"" << ch << "\"}," << endl; ch = txt[p++]; break;
}
}
cout << "]}" << endl;
}
|
ebb404330c0573b820ce0088202520a814385fa3
|
2394fba0f77ea69fd7c2c36f7752ead4a991a694
|
/1erExParcA00815174.cpp
|
d3e6dab89fcbdfbaf3af2e76d847b8b29d0b2cdf
|
[] |
no_license
|
newold12/Algorithms-design
|
5dd56fb4e9e1247dd762bc53ccc3c07091184988
|
4cc6f81f05f60b5a03218c9ebef256c4c2624743
|
refs/heads/master
| 2022-02-13T07:04:44.859022
| 2017-10-26T01:12:09
| 2017-10-26T01:12:09
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,850
|
cpp
|
1erExParcA00815174.cpp
|
/*
Alumno: Gerardo Mauricio Gutiérrez Quintana
Matricula: A00815174
1er Examen Parcial
*/
#include <iostream>
#include <time.h>
using namespace std;
int n, m;
int terreno[20][20]; // Matriz original donde se plantaran las bombas
int terrenoAux[20][20]; // Matriz auxiliar
// Funcion que busca las minas en la matriz original y rellena la matriz auxiliar.
// Encuentra la posicion de la bomba en la matriz original si es un numero diferente a 0.
// Al encontrar la posicion, comenzara a llenar las casillas vecinas de la bomba con '1'
// Para llenar las casillas vecinas se formaron submatrices dentro de la matriz auxiliar
// siendo estas de tamaño 2n + 1 por 2n + 1 donde n es el numero de la bomba encontrada.
// Al final las casillas que queden con 0 seran las no afectadas.
// La matriz auxiliar se extendio 3 renglones y 3 columnas mas de la original para no tener problemas al ser llenada,
// en caso de que la bomba se encuentre en las orillas.
void buscaMinas(){
for (int i = 0; i < n; i++){
for (int j = 0; j < m; j++){
if (terreno[i][j] != 0){
for (int a = 0; a < (terreno[i][j] * 2) + 1; a++){
for (int b = 0; b < (terreno[i][j] * 2) + 1; b++){
if (i - terreno[i][j] + 3 + a < n + 3 && j - terreno[i][j] + 3 + b < m + 3){
terrenoAux[i - terreno[i][j] + 3 + a][j - terreno[i][j] + 3 + b] = 1;
}
}
}
}
}
}
}
void leyendoTerreno(int a, int b){
for (int i = 0; i < a; i++){
for (int j = 0; j < b; j++){
cin >> terreno[i][j];
}
}
cout << endl;
}
int main(){
cout << "Introduce n y m: ";
cin >> n >> m;
int celdasNoAfectadas = n*m;
cout << endl;
leyendoTerreno(n, m);
buscaMinas();
for (int i = 3; i < n + 3; i++){
for (int j = 3; j < m + 3; j++){
if (terrenoAux[i][j] != 0){
celdasNoAfectadas--;
}
}
}
cout << celdasNoAfectadas <<endl;
return 0;
}
|
181336c9480a613367a9bc6fa1d7b92bb75d2a7b
|
916eda757b1e239928011a46666e289072bbaeed
|
/Temp/StagingArea/Data/il2cppOutput/Il2CppCompilerCalculateTypeValues_24Table.cpp
|
2c03bb3cfbb53939a2a80c8517c0d44393466fe9
|
[] |
no_license
|
suisuisan/Atariya
|
bf7fa43b28e56f4d11a613371ed207a11a400839
|
d68dae5ee4299cdd7677f2f05e958b9e1a0bb830
|
refs/heads/master
| 2021-01-25T13:48:22.339663
| 2018-03-03T17:01:17
| 2018-03-03T17:01:17
| 123,617,158
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 251,088
|
cpp
|
Il2CppCompilerCalculateTypeValues_24Table.cpp
|
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include <stdint.h>
#include "il2cpp-class-internals.h"
#include "codegen/il2cpp-codegen.h"
#include "il2cpp-object-internals.h"
// UniRx.Subject`1<UniRx.Diagnostics.LogEntry>
struct Subject_1_t1230163500;
// System.String
struct String_t;
// System.Action`1<UniRx.Diagnostics.LogEntry>
struct Action_1_t1313974708;
// System.Collections.Generic.IEqualityComparer`1<System.Byte>
struct IEqualityComparer_1_t3241628394;
// UniRx.Subject`1<System.Byte>
struct Subject_1_t1222952763;
// System.IDisposable
struct IDisposable_t3640265483;
// System.Exception
struct Exception_t;
// System.Collections.Generic.IEqualityComparer`1<System.Int64>
struct IEqualityComparer_1_t1548932026;
// UniRx.Subject`1<System.Int64>
struct Subject_1_t3825223691;
// System.Collections.Generic.IEqualityComparer`1<System.Int32>
struct IEqualityComparer_1_t763310475;
// UniRx.Subject`1<System.Int32>
struct Subject_1_t3039602140;
// System.Collections.IEnumerator
struct IEnumerator_t1853284238;
// UnityEngine.Coroutine[]
struct CoroutineU5BU5D_t1698289742;
// UnityEngine.Coroutine
struct Coroutine_t3829159415;
// UniRx.MainThreadDispatcher
struct MainThreadDispatcher_t3684499304;
// System.Collections.Generic.IEqualityComparer`1<System.Double>
struct IEqualityComparer_1_t2701997381;
// UniRx.Subject`1<System.Double>
struct Subject_1_t683321750;
// System.Collections.Generic.IEqualityComparer`1<System.String>
struct IEqualityComparer_1_t3954782707;
// UniRx.Subject`1<System.String>
struct Subject_1_t1936107076;
// UniRx.Scheduler/<Schedule>c__AnonStorey0
struct U3CScheduleU3Ec__AnonStorey0_t1246538827;
// System.Action`1<System.Action>
struct Action_1_t1436845072;
// UniRx.IScheduler
struct IScheduler_t411218504;
// UniRx.CompositeDisposable
struct CompositeDisposable_t3924054141;
// System.Action
struct Action_t1264377477;
// UnityEngine.AsyncOperation
struct AsyncOperation_t1445031843;
// UniRx.IProgress`1<System.Single>
struct IProgress_1_t3968412695;
// System.Collections.Generic.IEqualityComparer`1<System.Boolean>
struct IEqualityComparer_1_t2204619983;
// UniRx.Subject`1<System.Boolean>
struct Subject_1_t185944352;
// System.Collections.Generic.IEqualityComparer`1<UnityEngine.AnimationCurve>
struct IEqualityComparer_1_t859119088;
// UnityEngine.AnimationCurve
struct AnimationCurve_t3046754366;
// UniRx.Subject`1<UnityEngine.AnimationCurve>
struct Subject_1_t3135410753;
// System.Action`1<System.Action`1<System.TimeSpan>>
struct Action_1_t1226094439;
// System.Collections.Generic.IEqualityComparer`1<System.Single>
struct IEqualityComparer_1_t3504598792;
// UniRx.Subject`1<System.Single>
struct Subject_1_t1485923161;
// UniRx.Scheduler/<Schedule>c__AnonStorey2
struct U3CScheduleU3Ec__AnonStorey2_t1628875851;
// System.Action`1<System.Action`1<System.DateTimeOffset>>
struct Action_1_t3574222697;
// UniRx.Scheduler/<Schedule>c__AnonStorey4
struct U3CScheduleU3Ec__AnonStorey4_t481864779;
// System.Char[]
struct CharU5BU5D_t3528271667;
// System.Void
struct Void_t1185182177;
// UniRx.ICancelable
struct ICancelable_t3440398893;
// System.Collections.Generic.IEqualityComparer`1<UnityEngine.Quaternion>
struct IEqualityComparer_1_t114293053;
// UniRx.Subject`1<UnityEngine.Quaternion>
struct Subject_1_t2390584718;
// System.Collections.Generic.IEqualityComparer`1<UnityEngine.Color>
struct IEqualityComparer_1_t368051046;
// UniRx.Subject`1<UnityEngine.Color>
struct Subject_1_t2644342711;
// System.Collections.Generic.IEqualityComparer`1<UnityEngine.Vector4>
struct IEqualityComparer_1_t1131393659;
// UniRx.Subject`1<UnityEngine.Vector4>
struct Subject_1_t3407685324;
// System.Collections.Generic.IEqualityComparer`1<UnityEngine.Rect>
struct IEqualityComparer_1_t172844581;
// UniRx.Subject`1<UnityEngine.Rect>
struct Subject_1_t2449136246;
// System.Collections.Generic.IEqualityComparer`1<UnityEngine.Vector2>
struct IEqualityComparer_1_t4263561541;
// UniRx.Subject`1<UnityEngine.Vector2>
struct Subject_1_t2244885910;
// System.Collections.Generic.IEqualityComparer`1<UnityEngine.Vector3>
struct IEqualityComparer_1_t1534678186;
// UniRx.Subject`1<UnityEngine.Vector3>
struct Subject_1_t3810969851;
// System.String[]
struct StringU5BU5D_t1281789340;
// System.Int32[]
struct Int32U5BU5D_t385246372;
// System.Collections.Generic.IEqualityComparer`1<UnityEngine.Bounds>
struct IEqualityComparer_1_t79202632;
// UniRx.Subject`1<UnityEngine.Bounds>
struct Subject_1_t2355494297;
// UniRx.BooleanDisposable
struct BooleanDisposable_t84760918;
// System.Func`2<UniRx.LazyTask,UnityEngine.Coroutine>
struct Func_2_t2678796183;
// UnityEngine.Object
struct Object_t631007953;
// UniRx.InternalUtil.ThreadSafeQueueWorker
struct ThreadSafeQueueWorker_t2171548691;
// System.Action`1<System.Exception>
struct Action_1_t1609204844;
// UniRx.InternalUtil.MicroCoroutine
struct MicroCoroutine_t3506682403;
// UniRx.Subject`1<UniRx.Unit>
struct Subject_1_t3450905854;
struct Object_t631007953_marshaled_com;
#ifndef RUNTIMEOBJECT_H
#define RUNTIMEOBJECT_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Object
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RUNTIMEOBJECT_H
#ifndef OBSERVABLEDEBUGEXTENSIONS_T2967164862_H
#define OBSERVABLEDEBUGEXTENSIONS_T2967164862_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Diagnostics.ObservableDebugExtensions
struct ObservableDebugExtensions_t2967164862 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OBSERVABLEDEBUGEXTENSIONS_T2967164862_H
#ifndef OBSERVABLELOGGER_T2665118834_H
#define OBSERVABLELOGGER_T2665118834_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Diagnostics.ObservableLogger
struct ObservableLogger_t2665118834 : public RuntimeObject
{
public:
public:
};
struct ObservableLogger_t2665118834_StaticFields
{
public:
// UniRx.Subject`1<UniRx.Diagnostics.LogEntry> UniRx.Diagnostics.ObservableLogger::logPublisher
Subject_1_t1230163500 * ___logPublisher_0;
// UniRx.Diagnostics.ObservableLogger UniRx.Diagnostics.ObservableLogger::Listener
ObservableLogger_t2665118834 * ___Listener_1;
public:
inline static int32_t get_offset_of_logPublisher_0() { return static_cast<int32_t>(offsetof(ObservableLogger_t2665118834_StaticFields, ___logPublisher_0)); }
inline Subject_1_t1230163500 * get_logPublisher_0() const { return ___logPublisher_0; }
inline Subject_1_t1230163500 ** get_address_of_logPublisher_0() { return &___logPublisher_0; }
inline void set_logPublisher_0(Subject_1_t1230163500 * value)
{
___logPublisher_0 = value;
Il2CppCodeGenWriteBarrier((&___logPublisher_0), value);
}
inline static int32_t get_offset_of_Listener_1() { return static_cast<int32_t>(offsetof(ObservableLogger_t2665118834_StaticFields, ___Listener_1)); }
inline ObservableLogger_t2665118834 * get_Listener_1() const { return ___Listener_1; }
inline ObservableLogger_t2665118834 ** get_address_of_Listener_1() { return &___Listener_1; }
inline void set_Listener_1(ObservableLogger_t2665118834 * value)
{
___Listener_1 = value;
Il2CppCodeGenWriteBarrier((&___Listener_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OBSERVABLELOGGER_T2665118834_H
#ifndef UNITYDEBUGSINK_T4250252982_H
#define UNITYDEBUGSINK_T4250252982_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Diagnostics.UnityDebugSink
struct UnityDebugSink_t4250252982 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNITYDEBUGSINK_T4250252982_H
#ifndef LOGGER_T3861635025_H
#define LOGGER_T3861635025_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Diagnostics.Logger
struct Logger_t3861635025 : public RuntimeObject
{
public:
// System.String UniRx.Diagnostics.Logger::<Name>k__BackingField
String_t* ___U3CNameU3Ek__BackingField_2;
// System.Action`1<UniRx.Diagnostics.LogEntry> UniRx.Diagnostics.Logger::logPublisher
Action_1_t1313974708 * ___logPublisher_3;
public:
inline static int32_t get_offset_of_U3CNameU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(Logger_t3861635025, ___U3CNameU3Ek__BackingField_2)); }
inline String_t* get_U3CNameU3Ek__BackingField_2() const { return ___U3CNameU3Ek__BackingField_2; }
inline String_t** get_address_of_U3CNameU3Ek__BackingField_2() { return &___U3CNameU3Ek__BackingField_2; }
inline void set_U3CNameU3Ek__BackingField_2(String_t* value)
{
___U3CNameU3Ek__BackingField_2 = value;
Il2CppCodeGenWriteBarrier((&___U3CNameU3Ek__BackingField_2), value);
}
inline static int32_t get_offset_of_logPublisher_3() { return static_cast<int32_t>(offsetof(Logger_t3861635025, ___logPublisher_3)); }
inline Action_1_t1313974708 * get_logPublisher_3() const { return ___logPublisher_3; }
inline Action_1_t1313974708 ** get_address_of_logPublisher_3() { return &___logPublisher_3; }
inline void set_logPublisher_3(Action_1_t1313974708 * value)
{
___logPublisher_3 = value;
Il2CppCodeGenWriteBarrier((&___logPublisher_3), value);
}
};
struct Logger_t3861635025_StaticFields
{
public:
// System.Boolean UniRx.Diagnostics.Logger::isInitialized
bool ___isInitialized_0;
// System.Boolean UniRx.Diagnostics.Logger::isDebugBuild
bool ___isDebugBuild_1;
public:
inline static int32_t get_offset_of_isInitialized_0() { return static_cast<int32_t>(offsetof(Logger_t3861635025_StaticFields, ___isInitialized_0)); }
inline bool get_isInitialized_0() const { return ___isInitialized_0; }
inline bool* get_address_of_isInitialized_0() { return &___isInitialized_0; }
inline void set_isInitialized_0(bool value)
{
___isInitialized_0 = value;
}
inline static int32_t get_offset_of_isDebugBuild_1() { return static_cast<int32_t>(offsetof(Logger_t3861635025_StaticFields, ___isDebugBuild_1)); }
inline bool get_isDebugBuild_1() const { return ___isDebugBuild_1; }
inline bool* get_address_of_isDebugBuild_1() { return &___isDebugBuild_1; }
inline void set_isDebugBuild_1(bool value)
{
___isDebugBuild_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // LOGGER_T3861635025_H
#ifndef REACTIVEPROPERTY_1_T369021270_H
#define REACTIVEPROPERTY_1_T369021270_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<System.Byte>
struct ReactiveProperty_1_t369021270 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
uint8_t ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t1222952763 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t369021270, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t369021270, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t369021270, ___value_3)); }
inline uint8_t get_value_3() const { return ___value_3; }
inline uint8_t* get_address_of_value_3() { return &___value_3; }
inline void set_value_3(uint8_t value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t369021270, ___publisher_4)); }
inline Subject_1_t1222952763 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t1222952763 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t1222952763 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t369021270, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t369021270, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t369021270_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t369021270_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T369021270_H
#ifndef ASYNCOPERATIONEXTENSIONS_T103671278_H
#define ASYNCOPERATIONEXTENSIONS_T103671278_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.AsyncOperationExtensions
struct AsyncOperationExtensions_t103671278 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASYNCOPERATIONEXTENSIONS_T103671278_H
#ifndef LOGENTRYEXTENSIONS_T2577791660_H
#define LOGENTRYEXTENSIONS_T2577791660_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Diagnostics.LogEntryExtensions
struct LogEntryExtensions_t2577791660 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // LOGENTRYEXTENSIONS_T2577791660_H
#ifndef REACTIVEPROPERTY_1_T2971292198_H
#define REACTIVEPROPERTY_1_T2971292198_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<System.Int64>
struct ReactiveProperty_1_t2971292198 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
int64_t ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t3825223691 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2971292198, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2971292198, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2971292198, ___value_3)); }
inline int64_t get_value_3() const { return ___value_3; }
inline int64_t* get_address_of_value_3() { return &___value_3; }
inline void set_value_3(int64_t value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2971292198, ___publisher_4)); }
inline Subject_1_t3825223691 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t3825223691 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t3825223691 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2971292198, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2971292198, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t2971292198_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2971292198_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T2971292198_H
#ifndef REACTIVEPROPERTY_1_T2185670647_H
#define REACTIVEPROPERTY_1_T2185670647_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<System.Int32>
struct ReactiveProperty_1_t2185670647 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
int32_t ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t3039602140 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2185670647, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2185670647, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2185670647, ___value_3)); }
inline int32_t get_value_3() const { return ___value_3; }
inline int32_t* get_address_of_value_3() { return &___value_3; }
inline void set_value_3(int32_t value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2185670647, ___publisher_4)); }
inline Subject_1_t3039602140 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t3039602140 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t3039602140 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2185670647, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2185670647, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t2185670647_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2185670647_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T2185670647_H
#ifndef U3CSENDSTARTCOROUTINEU3EC__ANONSTOREY3_T1416387401_H
#define U3CSENDSTARTCOROUTINEU3EC__ANONSTOREY3_T1416387401_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.MainThreadDispatcher/<SendStartCoroutine>c__AnonStorey3
struct U3CSendStartCoroutineU3Ec__AnonStorey3_t1416387401 : public RuntimeObject
{
public:
// System.Collections.IEnumerator UniRx.MainThreadDispatcher/<SendStartCoroutine>c__AnonStorey3::routine
RuntimeObject* ___routine_0;
public:
inline static int32_t get_offset_of_routine_0() { return static_cast<int32_t>(offsetof(U3CSendStartCoroutineU3Ec__AnonStorey3_t1416387401, ___routine_0)); }
inline RuntimeObject* get_routine_0() const { return ___routine_0; }
inline RuntimeObject** get_address_of_routine_0() { return &___routine_0; }
inline void set_routine_0(RuntimeObject* value)
{
___routine_0 = value;
Il2CppCodeGenWriteBarrier((&___routine_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CSENDSTARTCOROUTINEU3EC__ANONSTOREY3_T1416387401_H
#ifndef ATTRIBUTE_T861562559_H
#define ATTRIBUTE_T861562559_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Attribute
struct Attribute_t861562559 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ATTRIBUTE_T861562559_H
#ifndef LAZYTASKEXTENSIONS_T3183993102_H
#define LAZYTASKEXTENSIONS_T3183993102_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.LazyTaskExtensions
struct LazyTaskExtensions_t3183993102 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // LAZYTASKEXTENSIONS_T3183993102_H
#ifndef U3CWHENALLCOREU3EC__ITERATOR0_T2684419830_H
#define U3CWHENALLCOREU3EC__ITERATOR0_T2684419830_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.LazyTask/<WhenAllCore>c__Iterator0
struct U3CWhenAllCoreU3Ec__Iterator0_t2684419830 : public RuntimeObject
{
public:
// UnityEngine.Coroutine[] UniRx.LazyTask/<WhenAllCore>c__Iterator0::coroutines
CoroutineU5BU5D_t1698289742* ___coroutines_0;
// UnityEngine.Coroutine[] UniRx.LazyTask/<WhenAllCore>c__Iterator0::$locvar0
CoroutineU5BU5D_t1698289742* ___U24locvar0_1;
// System.Int32 UniRx.LazyTask/<WhenAllCore>c__Iterator0::$locvar1
int32_t ___U24locvar1_2;
// UnityEngine.Coroutine UniRx.LazyTask/<WhenAllCore>c__Iterator0::<item>__1
Coroutine_t3829159415 * ___U3CitemU3E__1_3;
// System.Object UniRx.LazyTask/<WhenAllCore>c__Iterator0::$current
RuntimeObject * ___U24current_4;
// System.Boolean UniRx.LazyTask/<WhenAllCore>c__Iterator0::$disposing
bool ___U24disposing_5;
// System.Int32 UniRx.LazyTask/<WhenAllCore>c__Iterator0::$PC
int32_t ___U24PC_6;
public:
inline static int32_t get_offset_of_coroutines_0() { return static_cast<int32_t>(offsetof(U3CWhenAllCoreU3Ec__Iterator0_t2684419830, ___coroutines_0)); }
inline CoroutineU5BU5D_t1698289742* get_coroutines_0() const { return ___coroutines_0; }
inline CoroutineU5BU5D_t1698289742** get_address_of_coroutines_0() { return &___coroutines_0; }
inline void set_coroutines_0(CoroutineU5BU5D_t1698289742* value)
{
___coroutines_0 = value;
Il2CppCodeGenWriteBarrier((&___coroutines_0), value);
}
inline static int32_t get_offset_of_U24locvar0_1() { return static_cast<int32_t>(offsetof(U3CWhenAllCoreU3Ec__Iterator0_t2684419830, ___U24locvar0_1)); }
inline CoroutineU5BU5D_t1698289742* get_U24locvar0_1() const { return ___U24locvar0_1; }
inline CoroutineU5BU5D_t1698289742** get_address_of_U24locvar0_1() { return &___U24locvar0_1; }
inline void set_U24locvar0_1(CoroutineU5BU5D_t1698289742* value)
{
___U24locvar0_1 = value;
Il2CppCodeGenWriteBarrier((&___U24locvar0_1), value);
}
inline static int32_t get_offset_of_U24locvar1_2() { return static_cast<int32_t>(offsetof(U3CWhenAllCoreU3Ec__Iterator0_t2684419830, ___U24locvar1_2)); }
inline int32_t get_U24locvar1_2() const { return ___U24locvar1_2; }
inline int32_t* get_address_of_U24locvar1_2() { return &___U24locvar1_2; }
inline void set_U24locvar1_2(int32_t value)
{
___U24locvar1_2 = value;
}
inline static int32_t get_offset_of_U3CitemU3E__1_3() { return static_cast<int32_t>(offsetof(U3CWhenAllCoreU3Ec__Iterator0_t2684419830, ___U3CitemU3E__1_3)); }
inline Coroutine_t3829159415 * get_U3CitemU3E__1_3() const { return ___U3CitemU3E__1_3; }
inline Coroutine_t3829159415 ** get_address_of_U3CitemU3E__1_3() { return &___U3CitemU3E__1_3; }
inline void set_U3CitemU3E__1_3(Coroutine_t3829159415 * value)
{
___U3CitemU3E__1_3 = value;
Il2CppCodeGenWriteBarrier((&___U3CitemU3E__1_3), value);
}
inline static int32_t get_offset_of_U24current_4() { return static_cast<int32_t>(offsetof(U3CWhenAllCoreU3Ec__Iterator0_t2684419830, ___U24current_4)); }
inline RuntimeObject * get_U24current_4() const { return ___U24current_4; }
inline RuntimeObject ** get_address_of_U24current_4() { return &___U24current_4; }
inline void set_U24current_4(RuntimeObject * value)
{
___U24current_4 = value;
Il2CppCodeGenWriteBarrier((&___U24current_4), value);
}
inline static int32_t get_offset_of_U24disposing_5() { return static_cast<int32_t>(offsetof(U3CWhenAllCoreU3Ec__Iterator0_t2684419830, ___U24disposing_5)); }
inline bool get_U24disposing_5() const { return ___U24disposing_5; }
inline bool* get_address_of_U24disposing_5() { return &___U24disposing_5; }
inline void set_U24disposing_5(bool value)
{
___U24disposing_5 = value;
}
inline static int32_t get_offset_of_U24PC_6() { return static_cast<int32_t>(offsetof(U3CWhenAllCoreU3Ec__Iterator0_t2684419830, ___U24PC_6)); }
inline int32_t get_U24PC_6() const { return ___U24PC_6; }
inline int32_t* get_address_of_U24PC_6() { return &___U24PC_6; }
inline void set_U24PC_6(int32_t value)
{
___U24PC_6 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CWHENALLCOREU3EC__ITERATOR0_T2684419830_H
#ifndef U3CRUNENDOFFRAMEMICROCOROUTINEU3EC__ITERATOR2_T4169616078_H
#define U3CRUNENDOFFRAMEMICROCOROUTINEU3EC__ITERATOR2_T4169616078_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.MainThreadDispatcher/<RunEndOfFrameMicroCoroutine>c__Iterator2
struct U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078 : public RuntimeObject
{
public:
// UniRx.MainThreadDispatcher UniRx.MainThreadDispatcher/<RunEndOfFrameMicroCoroutine>c__Iterator2::$this
MainThreadDispatcher_t3684499304 * ___U24this_0;
// System.Object UniRx.MainThreadDispatcher/<RunEndOfFrameMicroCoroutine>c__Iterator2::$current
RuntimeObject * ___U24current_1;
// System.Boolean UniRx.MainThreadDispatcher/<RunEndOfFrameMicroCoroutine>c__Iterator2::$disposing
bool ___U24disposing_2;
// System.Int32 UniRx.MainThreadDispatcher/<RunEndOfFrameMicroCoroutine>c__Iterator2::$PC
int32_t ___U24PC_3;
public:
inline static int32_t get_offset_of_U24this_0() { return static_cast<int32_t>(offsetof(U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078, ___U24this_0)); }
inline MainThreadDispatcher_t3684499304 * get_U24this_0() const { return ___U24this_0; }
inline MainThreadDispatcher_t3684499304 ** get_address_of_U24this_0() { return &___U24this_0; }
inline void set_U24this_0(MainThreadDispatcher_t3684499304 * value)
{
___U24this_0 = value;
Il2CppCodeGenWriteBarrier((&___U24this_0), value);
}
inline static int32_t get_offset_of_U24current_1() { return static_cast<int32_t>(offsetof(U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078, ___U24current_1)); }
inline RuntimeObject * get_U24current_1() const { return ___U24current_1; }
inline RuntimeObject ** get_address_of_U24current_1() { return &___U24current_1; }
inline void set_U24current_1(RuntimeObject * value)
{
___U24current_1 = value;
Il2CppCodeGenWriteBarrier((&___U24current_1), value);
}
inline static int32_t get_offset_of_U24disposing_2() { return static_cast<int32_t>(offsetof(U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078, ___U24disposing_2)); }
inline bool get_U24disposing_2() const { return ___U24disposing_2; }
inline bool* get_address_of_U24disposing_2() { return &___U24disposing_2; }
inline void set_U24disposing_2(bool value)
{
___U24disposing_2 = value;
}
inline static int32_t get_offset_of_U24PC_3() { return static_cast<int32_t>(offsetof(U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078, ___U24PC_3)); }
inline int32_t get_U24PC_3() const { return ___U24PC_3; }
inline int32_t* get_address_of_U24PC_3() { return &___U24PC_3; }
inline void set_U24PC_3(int32_t value)
{
___U24PC_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CRUNENDOFFRAMEMICROCOROUTINEU3EC__ITERATOR2_T4169616078_H
#ifndef VALUETYPE_T3640485471_H
#define VALUETYPE_T3640485471_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.ValueType
struct ValueType_t3640485471 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t3640485471_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t3640485471_marshaled_com
{
};
#endif // VALUETYPE_T3640485471_H
#ifndef U3CRUNUPDATEMICROCOROUTINEU3EC__ITERATOR0_T3229616799_H
#define U3CRUNUPDATEMICROCOROUTINEU3EC__ITERATOR0_T3229616799_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.MainThreadDispatcher/<RunUpdateMicroCoroutine>c__Iterator0
struct U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799 : public RuntimeObject
{
public:
// UniRx.MainThreadDispatcher UniRx.MainThreadDispatcher/<RunUpdateMicroCoroutine>c__Iterator0::$this
MainThreadDispatcher_t3684499304 * ___U24this_0;
// System.Object UniRx.MainThreadDispatcher/<RunUpdateMicroCoroutine>c__Iterator0::$current
RuntimeObject * ___U24current_1;
// System.Boolean UniRx.MainThreadDispatcher/<RunUpdateMicroCoroutine>c__Iterator0::$disposing
bool ___U24disposing_2;
// System.Int32 UniRx.MainThreadDispatcher/<RunUpdateMicroCoroutine>c__Iterator0::$PC
int32_t ___U24PC_3;
public:
inline static int32_t get_offset_of_U24this_0() { return static_cast<int32_t>(offsetof(U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799, ___U24this_0)); }
inline MainThreadDispatcher_t3684499304 * get_U24this_0() const { return ___U24this_0; }
inline MainThreadDispatcher_t3684499304 ** get_address_of_U24this_0() { return &___U24this_0; }
inline void set_U24this_0(MainThreadDispatcher_t3684499304 * value)
{
___U24this_0 = value;
Il2CppCodeGenWriteBarrier((&___U24this_0), value);
}
inline static int32_t get_offset_of_U24current_1() { return static_cast<int32_t>(offsetof(U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799, ___U24current_1)); }
inline RuntimeObject * get_U24current_1() const { return ___U24current_1; }
inline RuntimeObject ** get_address_of_U24current_1() { return &___U24current_1; }
inline void set_U24current_1(RuntimeObject * value)
{
___U24current_1 = value;
Il2CppCodeGenWriteBarrier((&___U24current_1), value);
}
inline static int32_t get_offset_of_U24disposing_2() { return static_cast<int32_t>(offsetof(U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799, ___U24disposing_2)); }
inline bool get_U24disposing_2() const { return ___U24disposing_2; }
inline bool* get_address_of_U24disposing_2() { return &___U24disposing_2; }
inline void set_U24disposing_2(bool value)
{
___U24disposing_2 = value;
}
inline static int32_t get_offset_of_U24PC_3() { return static_cast<int32_t>(offsetof(U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799, ___U24PC_3)); }
inline int32_t get_U24PC_3() const { return ___U24PC_3; }
inline int32_t* get_address_of_U24PC_3() { return &___U24PC_3; }
inline void set_U24PC_3(int32_t value)
{
___U24PC_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CRUNUPDATEMICROCOROUTINEU3EC__ITERATOR0_T3229616799_H
#ifndef U3CRUNFIXEDUPDATEMICROCOROUTINEU3EC__ITERATOR1_T4089570234_H
#define U3CRUNFIXEDUPDATEMICROCOROUTINEU3EC__ITERATOR1_T4089570234_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.MainThreadDispatcher/<RunFixedUpdateMicroCoroutine>c__Iterator1
struct U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234 : public RuntimeObject
{
public:
// UniRx.MainThreadDispatcher UniRx.MainThreadDispatcher/<RunFixedUpdateMicroCoroutine>c__Iterator1::$this
MainThreadDispatcher_t3684499304 * ___U24this_0;
// System.Object UniRx.MainThreadDispatcher/<RunFixedUpdateMicroCoroutine>c__Iterator1::$current
RuntimeObject * ___U24current_1;
// System.Boolean UniRx.MainThreadDispatcher/<RunFixedUpdateMicroCoroutine>c__Iterator1::$disposing
bool ___U24disposing_2;
// System.Int32 UniRx.MainThreadDispatcher/<RunFixedUpdateMicroCoroutine>c__Iterator1::$PC
int32_t ___U24PC_3;
public:
inline static int32_t get_offset_of_U24this_0() { return static_cast<int32_t>(offsetof(U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234, ___U24this_0)); }
inline MainThreadDispatcher_t3684499304 * get_U24this_0() const { return ___U24this_0; }
inline MainThreadDispatcher_t3684499304 ** get_address_of_U24this_0() { return &___U24this_0; }
inline void set_U24this_0(MainThreadDispatcher_t3684499304 * value)
{
___U24this_0 = value;
Il2CppCodeGenWriteBarrier((&___U24this_0), value);
}
inline static int32_t get_offset_of_U24current_1() { return static_cast<int32_t>(offsetof(U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234, ___U24current_1)); }
inline RuntimeObject * get_U24current_1() const { return ___U24current_1; }
inline RuntimeObject ** get_address_of_U24current_1() { return &___U24current_1; }
inline void set_U24current_1(RuntimeObject * value)
{
___U24current_1 = value;
Il2CppCodeGenWriteBarrier((&___U24current_1), value);
}
inline static int32_t get_offset_of_U24disposing_2() { return static_cast<int32_t>(offsetof(U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234, ___U24disposing_2)); }
inline bool get_U24disposing_2() const { return ___U24disposing_2; }
inline bool* get_address_of_U24disposing_2() { return &___U24disposing_2; }
inline void set_U24disposing_2(bool value)
{
___U24disposing_2 = value;
}
inline static int32_t get_offset_of_U24PC_3() { return static_cast<int32_t>(offsetof(U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234, ___U24PC_3)); }
inline int32_t get_U24PC_3() const { return ___U24PC_3; }
inline int32_t* get_address_of_U24PC_3() { return &___U24PC_3; }
inline void set_U24PC_3(int32_t value)
{
___U24PC_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CRUNFIXEDUPDATEMICROCOROUTINEU3EC__ITERATOR1_T4089570234_H
#ifndef AOTSAFEEXTENSIONS_T3690086409_H
#define AOTSAFEEXTENSIONS_T3690086409_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.AotSafeExtensions
struct AotSafeExtensions_t3690086409 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // AOTSAFEEXTENSIONS_T3690086409_H
#ifndef REACTIVEPROPERTY_1_T4124357553_H
#define REACTIVEPROPERTY_1_T4124357553_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<System.Double>
struct ReactiveProperty_1_t4124357553 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
double ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t683321750 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t4124357553, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t4124357553, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t4124357553, ___value_3)); }
inline double get_value_3() const { return ___value_3; }
inline double* get_address_of_value_3() { return &___value_3; }
inline void set_value_3(double value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t4124357553, ___publisher_4)); }
inline Subject_1_t683321750 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t683321750 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t683321750 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t4124357553, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t4124357553, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t4124357553_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t4124357553_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T4124357553_H
#ifndef REACTIVEPROPERTY_1_T1082175583_H
#define REACTIVEPROPERTY_1_T1082175583_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<System.String>
struct ReactiveProperty_1_t1082175583 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
String_t* ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t1936107076 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1082175583, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1082175583, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1082175583, ___value_3)); }
inline String_t* get_value_3() const { return ___value_3; }
inline String_t** get_address_of_value_3() { return &___value_3; }
inline void set_value_3(String_t* value)
{
___value_3 = value;
Il2CppCodeGenWriteBarrier((&___value_3), value);
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1082175583, ___publisher_4)); }
inline Subject_1_t1936107076 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t1936107076 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t1936107076 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1082175583, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1082175583, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t1082175583_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1082175583_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T1082175583_H
#ifndef U3CSCHEDULEU3EC__ANONSTOREY1_T2063910649_H
#define U3CSCHEDULEU3EC__ANONSTOREY1_T2063910649_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/<Schedule>c__AnonStorey0/<Schedule>c__AnonStorey1
struct U3CScheduleU3Ec__AnonStorey1_t2063910649 : public RuntimeObject
{
public:
// System.Boolean UniRx.Scheduler/<Schedule>c__AnonStorey0/<Schedule>c__AnonStorey1::isAdded
bool ___isAdded_0;
// System.IDisposable UniRx.Scheduler/<Schedule>c__AnonStorey0/<Schedule>c__AnonStorey1::d
RuntimeObject* ___d_1;
// System.Boolean UniRx.Scheduler/<Schedule>c__AnonStorey0/<Schedule>c__AnonStorey1::isDone
bool ___isDone_2;
// UniRx.Scheduler/<Schedule>c__AnonStorey0 UniRx.Scheduler/<Schedule>c__AnonStorey0/<Schedule>c__AnonStorey1::<>f__ref$0
U3CScheduleU3Ec__AnonStorey0_t1246538827 * ___U3CU3Ef__refU240_3;
public:
inline static int32_t get_offset_of_isAdded_0() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey1_t2063910649, ___isAdded_0)); }
inline bool get_isAdded_0() const { return ___isAdded_0; }
inline bool* get_address_of_isAdded_0() { return &___isAdded_0; }
inline void set_isAdded_0(bool value)
{
___isAdded_0 = value;
}
inline static int32_t get_offset_of_d_1() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey1_t2063910649, ___d_1)); }
inline RuntimeObject* get_d_1() const { return ___d_1; }
inline RuntimeObject** get_address_of_d_1() { return &___d_1; }
inline void set_d_1(RuntimeObject* value)
{
___d_1 = value;
Il2CppCodeGenWriteBarrier((&___d_1), value);
}
inline static int32_t get_offset_of_isDone_2() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey1_t2063910649, ___isDone_2)); }
inline bool get_isDone_2() const { return ___isDone_2; }
inline bool* get_address_of_isDone_2() { return &___isDone_2; }
inline void set_isDone_2(bool value)
{
___isDone_2 = value;
}
inline static int32_t get_offset_of_U3CU3Ef__refU240_3() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey1_t2063910649, ___U3CU3Ef__refU240_3)); }
inline U3CScheduleU3Ec__AnonStorey0_t1246538827 * get_U3CU3Ef__refU240_3() const { return ___U3CU3Ef__refU240_3; }
inline U3CScheduleU3Ec__AnonStorey0_t1246538827 ** get_address_of_U3CU3Ef__refU240_3() { return &___U3CU3Ef__refU240_3; }
inline void set_U3CU3Ef__refU240_3(U3CScheduleU3Ec__AnonStorey0_t1246538827 * value)
{
___U3CU3Ef__refU240_3 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3Ef__refU240_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CSCHEDULEU3EC__ANONSTOREY1_T2063910649_H
#ifndef U3CSCHEDULEU3EC__ANONSTOREY0_T1246538827_H
#define U3CSCHEDULEU3EC__ANONSTOREY0_T1246538827_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/<Schedule>c__AnonStorey0
struct U3CScheduleU3Ec__AnonStorey0_t1246538827 : public RuntimeObject
{
public:
// System.Action`1<System.Action> UniRx.Scheduler/<Schedule>c__AnonStorey0::action
Action_1_t1436845072 * ___action_0;
// UniRx.IScheduler UniRx.Scheduler/<Schedule>c__AnonStorey0::scheduler
RuntimeObject* ___scheduler_1;
// System.Object UniRx.Scheduler/<Schedule>c__AnonStorey0::gate
RuntimeObject * ___gate_2;
// UniRx.CompositeDisposable UniRx.Scheduler/<Schedule>c__AnonStorey0::group
CompositeDisposable_t3924054141 * ___group_3;
// System.Action UniRx.Scheduler/<Schedule>c__AnonStorey0::recursiveAction
Action_t1264377477 * ___recursiveAction_4;
public:
inline static int32_t get_offset_of_action_0() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey0_t1246538827, ___action_0)); }
inline Action_1_t1436845072 * get_action_0() const { return ___action_0; }
inline Action_1_t1436845072 ** get_address_of_action_0() { return &___action_0; }
inline void set_action_0(Action_1_t1436845072 * value)
{
___action_0 = value;
Il2CppCodeGenWriteBarrier((&___action_0), value);
}
inline static int32_t get_offset_of_scheduler_1() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey0_t1246538827, ___scheduler_1)); }
inline RuntimeObject* get_scheduler_1() const { return ___scheduler_1; }
inline RuntimeObject** get_address_of_scheduler_1() { return &___scheduler_1; }
inline void set_scheduler_1(RuntimeObject* value)
{
___scheduler_1 = value;
Il2CppCodeGenWriteBarrier((&___scheduler_1), value);
}
inline static int32_t get_offset_of_gate_2() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey0_t1246538827, ___gate_2)); }
inline RuntimeObject * get_gate_2() const { return ___gate_2; }
inline RuntimeObject ** get_address_of_gate_2() { return &___gate_2; }
inline void set_gate_2(RuntimeObject * value)
{
___gate_2 = value;
Il2CppCodeGenWriteBarrier((&___gate_2), value);
}
inline static int32_t get_offset_of_group_3() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey0_t1246538827, ___group_3)); }
inline CompositeDisposable_t3924054141 * get_group_3() const { return ___group_3; }
inline CompositeDisposable_t3924054141 ** get_address_of_group_3() { return &___group_3; }
inline void set_group_3(CompositeDisposable_t3924054141 * value)
{
___group_3 = value;
Il2CppCodeGenWriteBarrier((&___group_3), value);
}
inline static int32_t get_offset_of_recursiveAction_4() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey0_t1246538827, ___recursiveAction_4)); }
inline Action_t1264377477 * get_recursiveAction_4() const { return ___recursiveAction_4; }
inline Action_t1264377477 ** get_address_of_recursiveAction_4() { return &___recursiveAction_4; }
inline void set_recursiveAction_4(Action_t1264377477 * value)
{
___recursiveAction_4 = value;
Il2CppCodeGenWriteBarrier((&___recursiveAction_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CSCHEDULEU3EC__ANONSTOREY0_T1246538827_H
#ifndef ENDOFFRAMEMAINTHREADSCHEDULER_T3512639697_H
#define ENDOFFRAMEMAINTHREADSCHEDULER_T3512639697_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/EndOfFrameMainThreadScheduler
struct EndOfFrameMainThreadScheduler_t3512639697 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ENDOFFRAMEMAINTHREADSCHEDULER_T3512639697_H
#ifndef FIXEDUPDATEMAINTHREADSCHEDULER_T1759960949_H
#define FIXEDUPDATEMAINTHREADSCHEDULER_T1759960949_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/FixedUpdateMainThreadScheduler
struct FixedUpdateMainThreadScheduler_t1759960949 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FIXEDUPDATEMAINTHREADSCHEDULER_T1759960949_H
#ifndef U3CASOBSERVABLEU3EC__ANONSTOREY1_T2816429619_H
#define U3CASOBSERVABLEU3EC__ANONSTOREY1_T2816429619_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.AsyncOperationExtensions/<AsObservable>c__AnonStorey1
struct U3CAsObservableU3Ec__AnonStorey1_t2816429619 : public RuntimeObject
{
public:
// UnityEngine.AsyncOperation UniRx.AsyncOperationExtensions/<AsObservable>c__AnonStorey1::asyncOperation
AsyncOperation_t1445031843 * ___asyncOperation_0;
// UniRx.IProgress`1<System.Single> UniRx.AsyncOperationExtensions/<AsObservable>c__AnonStorey1::progress
RuntimeObject* ___progress_1;
public:
inline static int32_t get_offset_of_asyncOperation_0() { return static_cast<int32_t>(offsetof(U3CAsObservableU3Ec__AnonStorey1_t2816429619, ___asyncOperation_0)); }
inline AsyncOperation_t1445031843 * get_asyncOperation_0() const { return ___asyncOperation_0; }
inline AsyncOperation_t1445031843 ** get_address_of_asyncOperation_0() { return &___asyncOperation_0; }
inline void set_asyncOperation_0(AsyncOperation_t1445031843 * value)
{
___asyncOperation_0 = value;
Il2CppCodeGenWriteBarrier((&___asyncOperation_0), value);
}
inline static int32_t get_offset_of_progress_1() { return static_cast<int32_t>(offsetof(U3CAsObservableU3Ec__AnonStorey1_t2816429619, ___progress_1)); }
inline RuntimeObject* get_progress_1() const { return ___progress_1; }
inline RuntimeObject** get_address_of_progress_1() { return &___progress_1; }
inline void set_progress_1(RuntimeObject* value)
{
___progress_1 = value;
Il2CppCodeGenWriteBarrier((&___progress_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CASOBSERVABLEU3EC__ANONSTOREY1_T2816429619_H
#ifndef REACTIVEPROPERTY_1_T3626980155_H
#define REACTIVEPROPERTY_1_T3626980155_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<System.Boolean>
struct ReactiveProperty_1_t3626980155 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
bool ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t185944352 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t3626980155, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t3626980155, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t3626980155, ___value_3)); }
inline bool get_value_3() const { return ___value_3; }
inline bool* get_address_of_value_3() { return &___value_3; }
inline void set_value_3(bool value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t3626980155, ___publisher_4)); }
inline Subject_1_t185944352 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t185944352 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t185944352 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t3626980155, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t3626980155, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t3626980155_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t3626980155_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T3626980155_H
#ifndef REACTIVEPROPERTY_1_T2281479260_H
#define REACTIVEPROPERTY_1_T2281479260_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<UnityEngine.AnimationCurve>
struct ReactiveProperty_1_t2281479260 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
AnimationCurve_t3046754366 * ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t3135410753 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2281479260, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2281479260, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2281479260, ___value_3)); }
inline AnimationCurve_t3046754366 * get_value_3() const { return ___value_3; }
inline AnimationCurve_t3046754366 ** get_address_of_value_3() { return &___value_3; }
inline void set_value_3(AnimationCurve_t3046754366 * value)
{
___value_3 = value;
Il2CppCodeGenWriteBarrier((&___value_3), value);
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2281479260, ___publisher_4)); }
inline Subject_1_t3135410753 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t3135410753 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t3135410753 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2281479260, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2281479260, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t2281479260_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2281479260_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T2281479260_H
#ifndef U3CSCHEDULEU3EC__ANONSTOREY2_T1628875851_H
#define U3CSCHEDULEU3EC__ANONSTOREY2_T1628875851_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/<Schedule>c__AnonStorey2
struct U3CScheduleU3Ec__AnonStorey2_t1628875851 : public RuntimeObject
{
public:
// System.Action`1<System.Action`1<System.TimeSpan>> UniRx.Scheduler/<Schedule>c__AnonStorey2::action
Action_1_t1226094439 * ___action_0;
// UniRx.IScheduler UniRx.Scheduler/<Schedule>c__AnonStorey2::scheduler
RuntimeObject* ___scheduler_1;
// System.Object UniRx.Scheduler/<Schedule>c__AnonStorey2::gate
RuntimeObject * ___gate_2;
// UniRx.CompositeDisposable UniRx.Scheduler/<Schedule>c__AnonStorey2::group
CompositeDisposable_t3924054141 * ___group_3;
// System.Action UniRx.Scheduler/<Schedule>c__AnonStorey2::recursiveAction
Action_t1264377477 * ___recursiveAction_4;
public:
inline static int32_t get_offset_of_action_0() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey2_t1628875851, ___action_0)); }
inline Action_1_t1226094439 * get_action_0() const { return ___action_0; }
inline Action_1_t1226094439 ** get_address_of_action_0() { return &___action_0; }
inline void set_action_0(Action_1_t1226094439 * value)
{
___action_0 = value;
Il2CppCodeGenWriteBarrier((&___action_0), value);
}
inline static int32_t get_offset_of_scheduler_1() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey2_t1628875851, ___scheduler_1)); }
inline RuntimeObject* get_scheduler_1() const { return ___scheduler_1; }
inline RuntimeObject** get_address_of_scheduler_1() { return &___scheduler_1; }
inline void set_scheduler_1(RuntimeObject* value)
{
___scheduler_1 = value;
Il2CppCodeGenWriteBarrier((&___scheduler_1), value);
}
inline static int32_t get_offset_of_gate_2() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey2_t1628875851, ___gate_2)); }
inline RuntimeObject * get_gate_2() const { return ___gate_2; }
inline RuntimeObject ** get_address_of_gate_2() { return &___gate_2; }
inline void set_gate_2(RuntimeObject * value)
{
___gate_2 = value;
Il2CppCodeGenWriteBarrier((&___gate_2), value);
}
inline static int32_t get_offset_of_group_3() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey2_t1628875851, ___group_3)); }
inline CompositeDisposable_t3924054141 * get_group_3() const { return ___group_3; }
inline CompositeDisposable_t3924054141 ** get_address_of_group_3() { return &___group_3; }
inline void set_group_3(CompositeDisposable_t3924054141 * value)
{
___group_3 = value;
Il2CppCodeGenWriteBarrier((&___group_3), value);
}
inline static int32_t get_offset_of_recursiveAction_4() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey2_t1628875851, ___recursiveAction_4)); }
inline Action_t1264377477 * get_recursiveAction_4() const { return ___recursiveAction_4; }
inline Action_t1264377477 ** get_address_of_recursiveAction_4() { return &___recursiveAction_4; }
inline void set_recursiveAction_4(Action_t1264377477 * value)
{
___recursiveAction_4 = value;
Il2CppCodeGenWriteBarrier((&___recursiveAction_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CSCHEDULEU3EC__ANONSTOREY2_T1628875851_H
#ifndef TUPLE_T1757971014_H
#define TUPLE_T1757971014_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Tuple
struct Tuple_t1757971014 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TUPLE_T1757971014_H
#ifndef OPTIMIZEDOBSERVABLEEXTENSIONS_T1647498745_H
#define OPTIMIZEDOBSERVABLEEXTENSIONS_T1647498745_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.OptimizedObservableExtensions
struct OptimizedObservableExtensions_t1647498745 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OPTIMIZEDOBSERVABLEEXTENSIONS_T1647498745_H
#ifndef TIMESTAMPED_T555880859_H
#define TIMESTAMPED_T555880859_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Timestamped
struct Timestamped_t555880859 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TIMESTAMPED_T555880859_H
#ifndef REACTIVEPROPERTY_1_T631991668_H
#define REACTIVEPROPERTY_1_T631991668_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<System.Single>
struct ReactiveProperty_1_t631991668 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
float ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t1485923161 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t631991668, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t631991668, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t631991668, ___value_3)); }
inline float get_value_3() const { return ___value_3; }
inline float* get_address_of_value_3() { return &___value_3; }
inline void set_value_3(float value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t631991668, ___publisher_4)); }
inline Subject_1_t1485923161 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t1485923161 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t1485923161 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t631991668, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t631991668, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t631991668_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t631991668_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T631991668_H
#ifndef SUBJECTEXTENSIONS_T2134319452_H
#define SUBJECTEXTENSIONS_T2134319452_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.SubjectExtensions
struct SubjectExtensions_t2134319452 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SUBJECTEXTENSIONS_T2134319452_H
#ifndef U3CSCHEDULEU3EC__ANONSTOREY3_T342939487_H
#define U3CSCHEDULEU3EC__ANONSTOREY3_T342939487_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/<Schedule>c__AnonStorey2/<Schedule>c__AnonStorey3
struct U3CScheduleU3Ec__AnonStorey3_t342939487 : public RuntimeObject
{
public:
// System.Boolean UniRx.Scheduler/<Schedule>c__AnonStorey2/<Schedule>c__AnonStorey3::isAdded
bool ___isAdded_0;
// System.IDisposable UniRx.Scheduler/<Schedule>c__AnonStorey2/<Schedule>c__AnonStorey3::d
RuntimeObject* ___d_1;
// System.Boolean UniRx.Scheduler/<Schedule>c__AnonStorey2/<Schedule>c__AnonStorey3::isDone
bool ___isDone_2;
// UniRx.Scheduler/<Schedule>c__AnonStorey2 UniRx.Scheduler/<Schedule>c__AnonStorey2/<Schedule>c__AnonStorey3::<>f__ref$2
U3CScheduleU3Ec__AnonStorey2_t1628875851 * ___U3CU3Ef__refU242_3;
public:
inline static int32_t get_offset_of_isAdded_0() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey3_t342939487, ___isAdded_0)); }
inline bool get_isAdded_0() const { return ___isAdded_0; }
inline bool* get_address_of_isAdded_0() { return &___isAdded_0; }
inline void set_isAdded_0(bool value)
{
___isAdded_0 = value;
}
inline static int32_t get_offset_of_d_1() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey3_t342939487, ___d_1)); }
inline RuntimeObject* get_d_1() const { return ___d_1; }
inline RuntimeObject** get_address_of_d_1() { return &___d_1; }
inline void set_d_1(RuntimeObject* value)
{
___d_1 = value;
Il2CppCodeGenWriteBarrier((&___d_1), value);
}
inline static int32_t get_offset_of_isDone_2() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey3_t342939487, ___isDone_2)); }
inline bool get_isDone_2() const { return ___isDone_2; }
inline bool* get_address_of_isDone_2() { return &___isDone_2; }
inline void set_isDone_2(bool value)
{
___isDone_2 = value;
}
inline static int32_t get_offset_of_U3CU3Ef__refU242_3() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey3_t342939487, ___U3CU3Ef__refU242_3)); }
inline U3CScheduleU3Ec__AnonStorey2_t1628875851 * get_U3CU3Ef__refU242_3() const { return ___U3CU3Ef__refU242_3; }
inline U3CScheduleU3Ec__AnonStorey2_t1628875851 ** get_address_of_U3CU3Ef__refU242_3() { return &___U3CU3Ef__refU242_3; }
inline void set_U3CU3Ef__refU242_3(U3CScheduleU3Ec__AnonStorey2_t1628875851 * value)
{
___U3CU3Ef__refU242_3 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3Ef__refU242_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CSCHEDULEU3EC__ANONSTOREY3_T342939487_H
#ifndef U3CSCHEDULEU3EC__ANONSTOREY4_T481864779_H
#define U3CSCHEDULEU3EC__ANONSTOREY4_T481864779_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/<Schedule>c__AnonStorey4
struct U3CScheduleU3Ec__AnonStorey4_t481864779 : public RuntimeObject
{
public:
// System.Action`1<System.Action`1<System.DateTimeOffset>> UniRx.Scheduler/<Schedule>c__AnonStorey4::action
Action_1_t3574222697 * ___action_0;
// UniRx.IScheduler UniRx.Scheduler/<Schedule>c__AnonStorey4::scheduler
RuntimeObject* ___scheduler_1;
// System.Object UniRx.Scheduler/<Schedule>c__AnonStorey4::gate
RuntimeObject * ___gate_2;
// UniRx.CompositeDisposable UniRx.Scheduler/<Schedule>c__AnonStorey4::group
CompositeDisposable_t3924054141 * ___group_3;
// System.Action UniRx.Scheduler/<Schedule>c__AnonStorey4::recursiveAction
Action_t1264377477 * ___recursiveAction_4;
public:
inline static int32_t get_offset_of_action_0() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey4_t481864779, ___action_0)); }
inline Action_1_t3574222697 * get_action_0() const { return ___action_0; }
inline Action_1_t3574222697 ** get_address_of_action_0() { return &___action_0; }
inline void set_action_0(Action_1_t3574222697 * value)
{
___action_0 = value;
Il2CppCodeGenWriteBarrier((&___action_0), value);
}
inline static int32_t get_offset_of_scheduler_1() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey4_t481864779, ___scheduler_1)); }
inline RuntimeObject* get_scheduler_1() const { return ___scheduler_1; }
inline RuntimeObject** get_address_of_scheduler_1() { return &___scheduler_1; }
inline void set_scheduler_1(RuntimeObject* value)
{
___scheduler_1 = value;
Il2CppCodeGenWriteBarrier((&___scheduler_1), value);
}
inline static int32_t get_offset_of_gate_2() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey4_t481864779, ___gate_2)); }
inline RuntimeObject * get_gate_2() const { return ___gate_2; }
inline RuntimeObject ** get_address_of_gate_2() { return &___gate_2; }
inline void set_gate_2(RuntimeObject * value)
{
___gate_2 = value;
Il2CppCodeGenWriteBarrier((&___gate_2), value);
}
inline static int32_t get_offset_of_group_3() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey4_t481864779, ___group_3)); }
inline CompositeDisposable_t3924054141 * get_group_3() const { return ___group_3; }
inline CompositeDisposable_t3924054141 ** get_address_of_group_3() { return &___group_3; }
inline void set_group_3(CompositeDisposable_t3924054141 * value)
{
___group_3 = value;
Il2CppCodeGenWriteBarrier((&___group_3), value);
}
inline static int32_t get_offset_of_recursiveAction_4() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey4_t481864779, ___recursiveAction_4)); }
inline Action_t1264377477 * get_recursiveAction_4() const { return ___recursiveAction_4; }
inline Action_t1264377477 ** get_address_of_recursiveAction_4() { return &___recursiveAction_4; }
inline void set_recursiveAction_4(Action_t1264377477 * value)
{
___recursiveAction_4 = value;
Il2CppCodeGenWriteBarrier((&___recursiveAction_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CSCHEDULEU3EC__ANONSTOREY4_T481864779_H
#ifndef U3CSCHEDULEU3EC__ANONSTOREY5_T849780234_H
#define U3CSCHEDULEU3EC__ANONSTOREY5_T849780234_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/<Schedule>c__AnonStorey4/<Schedule>c__AnonStorey5
struct U3CScheduleU3Ec__AnonStorey5_t849780234 : public RuntimeObject
{
public:
// System.Boolean UniRx.Scheduler/<Schedule>c__AnonStorey4/<Schedule>c__AnonStorey5::isAdded
bool ___isAdded_0;
// System.IDisposable UniRx.Scheduler/<Schedule>c__AnonStorey4/<Schedule>c__AnonStorey5::d
RuntimeObject* ___d_1;
// System.Boolean UniRx.Scheduler/<Schedule>c__AnonStorey4/<Schedule>c__AnonStorey5::isDone
bool ___isDone_2;
// UniRx.Scheduler/<Schedule>c__AnonStorey4 UniRx.Scheduler/<Schedule>c__AnonStorey4/<Schedule>c__AnonStorey5::<>f__ref$4
U3CScheduleU3Ec__AnonStorey4_t481864779 * ___U3CU3Ef__refU244_3;
public:
inline static int32_t get_offset_of_isAdded_0() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey5_t849780234, ___isAdded_0)); }
inline bool get_isAdded_0() const { return ___isAdded_0; }
inline bool* get_address_of_isAdded_0() { return &___isAdded_0; }
inline void set_isAdded_0(bool value)
{
___isAdded_0 = value;
}
inline static int32_t get_offset_of_d_1() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey5_t849780234, ___d_1)); }
inline RuntimeObject* get_d_1() const { return ___d_1; }
inline RuntimeObject** get_address_of_d_1() { return &___d_1; }
inline void set_d_1(RuntimeObject* value)
{
___d_1 = value;
Il2CppCodeGenWriteBarrier((&___d_1), value);
}
inline static int32_t get_offset_of_isDone_2() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey5_t849780234, ___isDone_2)); }
inline bool get_isDone_2() const { return ___isDone_2; }
inline bool* get_address_of_isDone_2() { return &___isDone_2; }
inline void set_isDone_2(bool value)
{
___isDone_2 = value;
}
inline static int32_t get_offset_of_U3CU3Ef__refU244_3() { return static_cast<int32_t>(offsetof(U3CScheduleU3Ec__AnonStorey5_t849780234, ___U3CU3Ef__refU244_3)); }
inline U3CScheduleU3Ec__AnonStorey4_t481864779 * get_U3CU3Ef__refU244_3() const { return ___U3CU3Ef__refU244_3; }
inline U3CScheduleU3Ec__AnonStorey4_t481864779 ** get_address_of_U3CU3Ef__refU244_3() { return &___U3CU3Ef__refU244_3; }
inline void set_U3CU3Ef__refU244_3(U3CScheduleU3Ec__AnonStorey4_t481864779 * value)
{
___U3CU3Ef__refU244_3 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3Ef__refU244_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CSCHEDULEU3EC__ANONSTOREY5_T849780234_H
#ifndef VECTOR2_T2156229523_H
#define VECTOR2_T2156229523_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector2
struct Vector2_t2156229523
{
public:
// System.Single UnityEngine.Vector2::x
float ___x_0;
// System.Single UnityEngine.Vector2::y
float ___y_1;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Vector2_t2156229523, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Vector2_t2156229523, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
};
struct Vector2_t2156229523_StaticFields
{
public:
// UnityEngine.Vector2 UnityEngine.Vector2::zeroVector
Vector2_t2156229523 ___zeroVector_2;
// UnityEngine.Vector2 UnityEngine.Vector2::oneVector
Vector2_t2156229523 ___oneVector_3;
// UnityEngine.Vector2 UnityEngine.Vector2::upVector
Vector2_t2156229523 ___upVector_4;
// UnityEngine.Vector2 UnityEngine.Vector2::downVector
Vector2_t2156229523 ___downVector_5;
// UnityEngine.Vector2 UnityEngine.Vector2::leftVector
Vector2_t2156229523 ___leftVector_6;
// UnityEngine.Vector2 UnityEngine.Vector2::rightVector
Vector2_t2156229523 ___rightVector_7;
// UnityEngine.Vector2 UnityEngine.Vector2::positiveInfinityVector
Vector2_t2156229523 ___positiveInfinityVector_8;
// UnityEngine.Vector2 UnityEngine.Vector2::negativeInfinityVector
Vector2_t2156229523 ___negativeInfinityVector_9;
public:
inline static int32_t get_offset_of_zeroVector_2() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___zeroVector_2)); }
inline Vector2_t2156229523 get_zeroVector_2() const { return ___zeroVector_2; }
inline Vector2_t2156229523 * get_address_of_zeroVector_2() { return &___zeroVector_2; }
inline void set_zeroVector_2(Vector2_t2156229523 value)
{
___zeroVector_2 = value;
}
inline static int32_t get_offset_of_oneVector_3() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___oneVector_3)); }
inline Vector2_t2156229523 get_oneVector_3() const { return ___oneVector_3; }
inline Vector2_t2156229523 * get_address_of_oneVector_3() { return &___oneVector_3; }
inline void set_oneVector_3(Vector2_t2156229523 value)
{
___oneVector_3 = value;
}
inline static int32_t get_offset_of_upVector_4() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___upVector_4)); }
inline Vector2_t2156229523 get_upVector_4() const { return ___upVector_4; }
inline Vector2_t2156229523 * get_address_of_upVector_4() { return &___upVector_4; }
inline void set_upVector_4(Vector2_t2156229523 value)
{
___upVector_4 = value;
}
inline static int32_t get_offset_of_downVector_5() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___downVector_5)); }
inline Vector2_t2156229523 get_downVector_5() const { return ___downVector_5; }
inline Vector2_t2156229523 * get_address_of_downVector_5() { return &___downVector_5; }
inline void set_downVector_5(Vector2_t2156229523 value)
{
___downVector_5 = value;
}
inline static int32_t get_offset_of_leftVector_6() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___leftVector_6)); }
inline Vector2_t2156229523 get_leftVector_6() const { return ___leftVector_6; }
inline Vector2_t2156229523 * get_address_of_leftVector_6() { return &___leftVector_6; }
inline void set_leftVector_6(Vector2_t2156229523 value)
{
___leftVector_6 = value;
}
inline static int32_t get_offset_of_rightVector_7() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___rightVector_7)); }
inline Vector2_t2156229523 get_rightVector_7() const { return ___rightVector_7; }
inline Vector2_t2156229523 * get_address_of_rightVector_7() { return &___rightVector_7; }
inline void set_rightVector_7(Vector2_t2156229523 value)
{
___rightVector_7 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___positiveInfinityVector_8)); }
inline Vector2_t2156229523 get_positiveInfinityVector_8() const { return ___positiveInfinityVector_8; }
inline Vector2_t2156229523 * get_address_of_positiveInfinityVector_8() { return &___positiveInfinityVector_8; }
inline void set_positiveInfinityVector_8(Vector2_t2156229523 value)
{
___positiveInfinityVector_8 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_9() { return static_cast<int32_t>(offsetof(Vector2_t2156229523_StaticFields, ___negativeInfinityVector_9)); }
inline Vector2_t2156229523 get_negativeInfinityVector_9() const { return ___negativeInfinityVector_9; }
inline Vector2_t2156229523 * get_address_of_negativeInfinityVector_9() { return &___negativeInfinityVector_9; }
inline void set_negativeInfinityVector_9(Vector2_t2156229523 value)
{
___negativeInfinityVector_9 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VECTOR2_T2156229523_H
#ifndef VECTOR3_T3722313464_H
#define VECTOR3_T3722313464_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector3
struct Vector3_t3722313464
{
public:
// System.Single UnityEngine.Vector3::x
float ___x_1;
// System.Single UnityEngine.Vector3::y
float ___y_2;
// System.Single UnityEngine.Vector3::z
float ___z_3;
public:
inline static int32_t get_offset_of_x_1() { return static_cast<int32_t>(offsetof(Vector3_t3722313464, ___x_1)); }
inline float get_x_1() const { return ___x_1; }
inline float* get_address_of_x_1() { return &___x_1; }
inline void set_x_1(float value)
{
___x_1 = value;
}
inline static int32_t get_offset_of_y_2() { return static_cast<int32_t>(offsetof(Vector3_t3722313464, ___y_2)); }
inline float get_y_2() const { return ___y_2; }
inline float* get_address_of_y_2() { return &___y_2; }
inline void set_y_2(float value)
{
___y_2 = value;
}
inline static int32_t get_offset_of_z_3() { return static_cast<int32_t>(offsetof(Vector3_t3722313464, ___z_3)); }
inline float get_z_3() const { return ___z_3; }
inline float* get_address_of_z_3() { return &___z_3; }
inline void set_z_3(float value)
{
___z_3 = value;
}
};
struct Vector3_t3722313464_StaticFields
{
public:
// UnityEngine.Vector3 UnityEngine.Vector3::zeroVector
Vector3_t3722313464 ___zeroVector_4;
// UnityEngine.Vector3 UnityEngine.Vector3::oneVector
Vector3_t3722313464 ___oneVector_5;
// UnityEngine.Vector3 UnityEngine.Vector3::upVector
Vector3_t3722313464 ___upVector_6;
// UnityEngine.Vector3 UnityEngine.Vector3::downVector
Vector3_t3722313464 ___downVector_7;
// UnityEngine.Vector3 UnityEngine.Vector3::leftVector
Vector3_t3722313464 ___leftVector_8;
// UnityEngine.Vector3 UnityEngine.Vector3::rightVector
Vector3_t3722313464 ___rightVector_9;
// UnityEngine.Vector3 UnityEngine.Vector3::forwardVector
Vector3_t3722313464 ___forwardVector_10;
// UnityEngine.Vector3 UnityEngine.Vector3::backVector
Vector3_t3722313464 ___backVector_11;
// UnityEngine.Vector3 UnityEngine.Vector3::positiveInfinityVector
Vector3_t3722313464 ___positiveInfinityVector_12;
// UnityEngine.Vector3 UnityEngine.Vector3::negativeInfinityVector
Vector3_t3722313464 ___negativeInfinityVector_13;
public:
inline static int32_t get_offset_of_zeroVector_4() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___zeroVector_4)); }
inline Vector3_t3722313464 get_zeroVector_4() const { return ___zeroVector_4; }
inline Vector3_t3722313464 * get_address_of_zeroVector_4() { return &___zeroVector_4; }
inline void set_zeroVector_4(Vector3_t3722313464 value)
{
___zeroVector_4 = value;
}
inline static int32_t get_offset_of_oneVector_5() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___oneVector_5)); }
inline Vector3_t3722313464 get_oneVector_5() const { return ___oneVector_5; }
inline Vector3_t3722313464 * get_address_of_oneVector_5() { return &___oneVector_5; }
inline void set_oneVector_5(Vector3_t3722313464 value)
{
___oneVector_5 = value;
}
inline static int32_t get_offset_of_upVector_6() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___upVector_6)); }
inline Vector3_t3722313464 get_upVector_6() const { return ___upVector_6; }
inline Vector3_t3722313464 * get_address_of_upVector_6() { return &___upVector_6; }
inline void set_upVector_6(Vector3_t3722313464 value)
{
___upVector_6 = value;
}
inline static int32_t get_offset_of_downVector_7() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___downVector_7)); }
inline Vector3_t3722313464 get_downVector_7() const { return ___downVector_7; }
inline Vector3_t3722313464 * get_address_of_downVector_7() { return &___downVector_7; }
inline void set_downVector_7(Vector3_t3722313464 value)
{
___downVector_7 = value;
}
inline static int32_t get_offset_of_leftVector_8() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___leftVector_8)); }
inline Vector3_t3722313464 get_leftVector_8() const { return ___leftVector_8; }
inline Vector3_t3722313464 * get_address_of_leftVector_8() { return &___leftVector_8; }
inline void set_leftVector_8(Vector3_t3722313464 value)
{
___leftVector_8 = value;
}
inline static int32_t get_offset_of_rightVector_9() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___rightVector_9)); }
inline Vector3_t3722313464 get_rightVector_9() const { return ___rightVector_9; }
inline Vector3_t3722313464 * get_address_of_rightVector_9() { return &___rightVector_9; }
inline void set_rightVector_9(Vector3_t3722313464 value)
{
___rightVector_9 = value;
}
inline static int32_t get_offset_of_forwardVector_10() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___forwardVector_10)); }
inline Vector3_t3722313464 get_forwardVector_10() const { return ___forwardVector_10; }
inline Vector3_t3722313464 * get_address_of_forwardVector_10() { return &___forwardVector_10; }
inline void set_forwardVector_10(Vector3_t3722313464 value)
{
___forwardVector_10 = value;
}
inline static int32_t get_offset_of_backVector_11() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___backVector_11)); }
inline Vector3_t3722313464 get_backVector_11() const { return ___backVector_11; }
inline Vector3_t3722313464 * get_address_of_backVector_11() { return &___backVector_11; }
inline void set_backVector_11(Vector3_t3722313464 value)
{
___backVector_11 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_12() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___positiveInfinityVector_12)); }
inline Vector3_t3722313464 get_positiveInfinityVector_12() const { return ___positiveInfinityVector_12; }
inline Vector3_t3722313464 * get_address_of_positiveInfinityVector_12() { return &___positiveInfinityVector_12; }
inline void set_positiveInfinityVector_12(Vector3_t3722313464 value)
{
___positiveInfinityVector_12 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_13() { return static_cast<int32_t>(offsetof(Vector3_t3722313464_StaticFields, ___negativeInfinityVector_13)); }
inline Vector3_t3722313464 get_negativeInfinityVector_13() const { return ___negativeInfinityVector_13; }
inline Vector3_t3722313464 * get_address_of_negativeInfinityVector_13() { return &___negativeInfinityVector_13; }
inline void set_negativeInfinityVector_13(Vector3_t3722313464 value)
{
___negativeInfinityVector_13 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VECTOR3_T3722313464_H
#ifndef ENUM_T4135868527_H
#define ENUM_T4135868527_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Enum
struct Enum_t4135868527 : public ValueType_t3640485471
{
public:
public:
};
struct Enum_t4135868527_StaticFields
{
public:
// System.Char[] System.Enum::split_char
CharU5BU5D_t3528271667* ___split_char_0;
public:
inline static int32_t get_offset_of_split_char_0() { return static_cast<int32_t>(offsetof(Enum_t4135868527_StaticFields, ___split_char_0)); }
inline CharU5BU5D_t3528271667* get_split_char_0() const { return ___split_char_0; }
inline CharU5BU5D_t3528271667** get_address_of_split_char_0() { return &___split_char_0; }
inline void set_split_char_0(CharU5BU5D_t3528271667* value)
{
___split_char_0 = value;
Il2CppCodeGenWriteBarrier((&___split_char_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t4135868527_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t4135868527_marshaled_com
{
};
#endif // ENUM_T4135868527_H
#ifndef TIMESPAN_T881159249_H
#define TIMESPAN_T881159249_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.TimeSpan
struct TimeSpan_t881159249
{
public:
// System.Int64 System.TimeSpan::_ticks
int64_t ____ticks_3;
public:
inline static int32_t get_offset_of__ticks_3() { return static_cast<int32_t>(offsetof(TimeSpan_t881159249, ____ticks_3)); }
inline int64_t get__ticks_3() const { return ____ticks_3; }
inline int64_t* get_address_of__ticks_3() { return &____ticks_3; }
inline void set__ticks_3(int64_t value)
{
____ticks_3 = value;
}
};
struct TimeSpan_t881159249_StaticFields
{
public:
// System.TimeSpan System.TimeSpan::MaxValue
TimeSpan_t881159249 ___MaxValue_0;
// System.TimeSpan System.TimeSpan::MinValue
TimeSpan_t881159249 ___MinValue_1;
// System.TimeSpan System.TimeSpan::Zero
TimeSpan_t881159249 ___Zero_2;
public:
inline static int32_t get_offset_of_MaxValue_0() { return static_cast<int32_t>(offsetof(TimeSpan_t881159249_StaticFields, ___MaxValue_0)); }
inline TimeSpan_t881159249 get_MaxValue_0() const { return ___MaxValue_0; }
inline TimeSpan_t881159249 * get_address_of_MaxValue_0() { return &___MaxValue_0; }
inline void set_MaxValue_0(TimeSpan_t881159249 value)
{
___MaxValue_0 = value;
}
inline static int32_t get_offset_of_MinValue_1() { return static_cast<int32_t>(offsetof(TimeSpan_t881159249_StaticFields, ___MinValue_1)); }
inline TimeSpan_t881159249 get_MinValue_1() const { return ___MinValue_1; }
inline TimeSpan_t881159249 * get_address_of_MinValue_1() { return &___MinValue_1; }
inline void set_MinValue_1(TimeSpan_t881159249 value)
{
___MinValue_1 = value;
}
inline static int32_t get_offset_of_Zero_2() { return static_cast<int32_t>(offsetof(TimeSpan_t881159249_StaticFields, ___Zero_2)); }
inline TimeSpan_t881159249 get_Zero_2() const { return ___Zero_2; }
inline TimeSpan_t881159249 * get_address_of_Zero_2() { return &___Zero_2; }
inline void set_Zero_2(TimeSpan_t881159249 value)
{
___Zero_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TIMESPAN_T881159249_H
#ifndef INTPTR_T_H
#define INTPTR_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// 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;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INTPTR_T_H
#ifndef DOUBLEREACTIVEPROPERTY_T3731678748_H
#define DOUBLEREACTIVEPROPERTY_T3731678748_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.DoubleReactiveProperty
struct DoubleReactiveProperty_t3731678748 : public ReactiveProperty_1_t4124357553
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DOUBLEREACTIVEPROPERTY_T3731678748_H
#ifndef FLOATREACTIVEPROPERTY_T2159343209_H
#define FLOATREACTIVEPROPERTY_T2159343209_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.FloatReactiveProperty
struct FloatReactiveProperty_t2159343209 : public ReactiveProperty_1_t631991668
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FLOATREACTIVEPROPERTY_T2159343209_H
#ifndef STRINGREACTIVEPROPERTY_T3302058057_H
#define STRINGREACTIVEPROPERTY_T3302058057_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.StringReactiveProperty
struct StringReactiveProperty_t3302058057 : public ReactiveProperty_1_t1082175583
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STRINGREACTIVEPROPERTY_T3302058057_H
#ifndef QUATERNION_T2301928331_H
#define QUATERNION_T2301928331_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Quaternion
struct Quaternion_t2301928331
{
public:
// System.Single UnityEngine.Quaternion::x
float ___x_0;
// System.Single UnityEngine.Quaternion::y
float ___y_1;
// System.Single UnityEngine.Quaternion::z
float ___z_2;
// System.Single UnityEngine.Quaternion::w
float ___w_3;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Quaternion_t2301928331, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Quaternion_t2301928331, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
inline static int32_t get_offset_of_z_2() { return static_cast<int32_t>(offsetof(Quaternion_t2301928331, ___z_2)); }
inline float get_z_2() const { return ___z_2; }
inline float* get_address_of_z_2() { return &___z_2; }
inline void set_z_2(float value)
{
___z_2 = value;
}
inline static int32_t get_offset_of_w_3() { return static_cast<int32_t>(offsetof(Quaternion_t2301928331, ___w_3)); }
inline float get_w_3() const { return ___w_3; }
inline float* get_address_of_w_3() { return &___w_3; }
inline void set_w_3(float value)
{
___w_3 = value;
}
};
struct Quaternion_t2301928331_StaticFields
{
public:
// UnityEngine.Quaternion UnityEngine.Quaternion::identityQuaternion
Quaternion_t2301928331 ___identityQuaternion_4;
public:
inline static int32_t get_offset_of_identityQuaternion_4() { return static_cast<int32_t>(offsetof(Quaternion_t2301928331_StaticFields, ___identityQuaternion_4)); }
inline Quaternion_t2301928331 get_identityQuaternion_4() const { return ___identityQuaternion_4; }
inline Quaternion_t2301928331 * get_address_of_identityQuaternion_4() { return &___identityQuaternion_4; }
inline void set_identityQuaternion_4(Quaternion_t2301928331 value)
{
___identityQuaternion_4 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // QUATERNION_T2301928331_H
#ifndef BOOLREACTIVEPROPERTY_T700220569_H
#define BOOLREACTIVEPROPERTY_T700220569_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.BoolReactiveProperty
struct BoolReactiveProperty_t700220569 : public ReactiveProperty_1_t3626980155
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BOOLREACTIVEPROPERTY_T700220569_H
#ifndef CANCELLATIONTOKEN_T1265546479_H
#define CANCELLATIONTOKEN_T1265546479_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.CancellationToken
struct CancellationToken_t1265546479
{
public:
// UniRx.ICancelable UniRx.CancellationToken::source
RuntimeObject* ___source_0;
public:
inline static int32_t get_offset_of_source_0() { return static_cast<int32_t>(offsetof(CancellationToken_t1265546479, ___source_0)); }
inline RuntimeObject* get_source_0() const { return ___source_0; }
inline RuntimeObject** get_address_of_source_0() { return &___source_0; }
inline void set_source_0(RuntimeObject* value)
{
___source_0 = value;
Il2CppCodeGenWriteBarrier((&___source_0), value);
}
};
struct CancellationToken_t1265546479_StaticFields
{
public:
// UniRx.CancellationToken UniRx.CancellationToken::Empty
CancellationToken_t1265546479 ___Empty_1;
// UniRx.CancellationToken UniRx.CancellationToken::None
CancellationToken_t1265546479 ___None_2;
public:
inline static int32_t get_offset_of_Empty_1() { return static_cast<int32_t>(offsetof(CancellationToken_t1265546479_StaticFields, ___Empty_1)); }
inline CancellationToken_t1265546479 get_Empty_1() const { return ___Empty_1; }
inline CancellationToken_t1265546479 * get_address_of_Empty_1() { return &___Empty_1; }
inline void set_Empty_1(CancellationToken_t1265546479 value)
{
___Empty_1 = value;
}
inline static int32_t get_offset_of_None_2() { return static_cast<int32_t>(offsetof(CancellationToken_t1265546479_StaticFields, ___None_2)); }
inline CancellationToken_t1265546479 get_None_2() const { return ___None_2; }
inline CancellationToken_t1265546479 * get_address_of_None_2() { return &___None_2; }
inline void set_None_2(CancellationToken_t1265546479 value)
{
___None_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of UniRx.CancellationToken
struct CancellationToken_t1265546479_marshaled_pinvoke
{
RuntimeObject* ___source_0;
};
// Native definition for COM marshalling of UniRx.CancellationToken
struct CancellationToken_t1265546479_marshaled_com
{
RuntimeObject* ___source_0;
};
#endif // CANCELLATIONTOKEN_T1265546479_H
#ifndef UNIT_T3362249467_H
#define UNIT_T3362249467_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Unit
struct Unit_t3362249467
{
public:
union
{
struct
{
};
uint8_t Unit_t3362249467__padding[1];
};
public:
};
struct Unit_t3362249467_StaticFields
{
public:
// UniRx.Unit UniRx.Unit::default
Unit_t3362249467 ___default_0;
public:
inline static int32_t get_offset_of_default_0() { return static_cast<int32_t>(offsetof(Unit_t3362249467_StaticFields, ___default_0)); }
inline Unit_t3362249467 get_default_0() const { return ___default_0; }
inline Unit_t3362249467 * get_address_of_default_0() { return &___default_0; }
inline void set_default_0(Unit_t3362249467 value)
{
___default_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UNIT_T3362249467_H
#ifndef INTREACTIVEPROPERTY_T3243525985_H
#define INTREACTIVEPROPERTY_T3243525985_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.IntReactiveProperty
struct IntReactiveProperty_t3243525985 : public ReactiveProperty_1_t2185670647
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INTREACTIVEPROPERTY_T3243525985_H
#ifndef BYTEREACTIVEPROPERTY_T1600986847_H
#define BYTEREACTIVEPROPERTY_T1600986847_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ByteReactiveProperty
struct ByteReactiveProperty_t1600986847 : public ReactiveProperty_1_t369021270
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BYTEREACTIVEPROPERTY_T1600986847_H
#ifndef LONGREACTIVEPROPERTY_T2823960147_H
#define LONGREACTIVEPROPERTY_T2823960147_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.LongReactiveProperty
struct LongReactiveProperty_t2823960147 : public ReactiveProperty_1_t2971292198
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // LONGREACTIVEPROPERTY_T2823960147_H
#ifndef PROPERTYATTRIBUTE_T3677895545_H
#define PROPERTYATTRIBUTE_T3677895545_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.PropertyAttribute
struct PropertyAttribute_t3677895545 : public Attribute_t861562559
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PROPERTYATTRIBUTE_T3677895545_H
#ifndef ANIMATIONCURVEREACTIVEPROPERTY_T44630468_H
#define ANIMATIONCURVEREACTIVEPROPERTY_T44630468_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.AnimationCurveReactiveProperty
struct AnimationCurveReactiveProperty_t44630468 : public ReactiveProperty_1_t2281479260
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ANIMATIONCURVEREACTIVEPROPERTY_T44630468_H
#ifndef VECTOR4_T3319028937_H
#define VECTOR4_T3319028937_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Vector4
struct Vector4_t3319028937
{
public:
// System.Single UnityEngine.Vector4::x
float ___x_1;
// System.Single UnityEngine.Vector4::y
float ___y_2;
// System.Single UnityEngine.Vector4::z
float ___z_3;
// System.Single UnityEngine.Vector4::w
float ___w_4;
public:
inline static int32_t get_offset_of_x_1() { return static_cast<int32_t>(offsetof(Vector4_t3319028937, ___x_1)); }
inline float get_x_1() const { return ___x_1; }
inline float* get_address_of_x_1() { return &___x_1; }
inline void set_x_1(float value)
{
___x_1 = value;
}
inline static int32_t get_offset_of_y_2() { return static_cast<int32_t>(offsetof(Vector4_t3319028937, ___y_2)); }
inline float get_y_2() const { return ___y_2; }
inline float* get_address_of_y_2() { return &___y_2; }
inline void set_y_2(float value)
{
___y_2 = value;
}
inline static int32_t get_offset_of_z_3() { return static_cast<int32_t>(offsetof(Vector4_t3319028937, ___z_3)); }
inline float get_z_3() const { return ___z_3; }
inline float* get_address_of_z_3() { return &___z_3; }
inline void set_z_3(float value)
{
___z_3 = value;
}
inline static int32_t get_offset_of_w_4() { return static_cast<int32_t>(offsetof(Vector4_t3319028937, ___w_4)); }
inline float get_w_4() const { return ___w_4; }
inline float* get_address_of_w_4() { return &___w_4; }
inline void set_w_4(float value)
{
___w_4 = value;
}
};
struct Vector4_t3319028937_StaticFields
{
public:
// UnityEngine.Vector4 UnityEngine.Vector4::zeroVector
Vector4_t3319028937 ___zeroVector_5;
// UnityEngine.Vector4 UnityEngine.Vector4::oneVector
Vector4_t3319028937 ___oneVector_6;
// UnityEngine.Vector4 UnityEngine.Vector4::positiveInfinityVector
Vector4_t3319028937 ___positiveInfinityVector_7;
// UnityEngine.Vector4 UnityEngine.Vector4::negativeInfinityVector
Vector4_t3319028937 ___negativeInfinityVector_8;
public:
inline static int32_t get_offset_of_zeroVector_5() { return static_cast<int32_t>(offsetof(Vector4_t3319028937_StaticFields, ___zeroVector_5)); }
inline Vector4_t3319028937 get_zeroVector_5() const { return ___zeroVector_5; }
inline Vector4_t3319028937 * get_address_of_zeroVector_5() { return &___zeroVector_5; }
inline void set_zeroVector_5(Vector4_t3319028937 value)
{
___zeroVector_5 = value;
}
inline static int32_t get_offset_of_oneVector_6() { return static_cast<int32_t>(offsetof(Vector4_t3319028937_StaticFields, ___oneVector_6)); }
inline Vector4_t3319028937 get_oneVector_6() const { return ___oneVector_6; }
inline Vector4_t3319028937 * get_address_of_oneVector_6() { return &___oneVector_6; }
inline void set_oneVector_6(Vector4_t3319028937 value)
{
___oneVector_6 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_7() { return static_cast<int32_t>(offsetof(Vector4_t3319028937_StaticFields, ___positiveInfinityVector_7)); }
inline Vector4_t3319028937 get_positiveInfinityVector_7() const { return ___positiveInfinityVector_7; }
inline Vector4_t3319028937 * get_address_of_positiveInfinityVector_7() { return &___positiveInfinityVector_7; }
inline void set_positiveInfinityVector_7(Vector4_t3319028937 value)
{
___positiveInfinityVector_7 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector4_t3319028937_StaticFields, ___negativeInfinityVector_8)); }
inline Vector4_t3319028937 get_negativeInfinityVector_8() const { return ___negativeInfinityVector_8; }
inline Vector4_t3319028937 * get_address_of_negativeInfinityVector_8() { return &___negativeInfinityVector_8; }
inline void set_negativeInfinityVector_8(Vector4_t3319028937 value)
{
___negativeInfinityVector_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VECTOR4_T3319028937_H
#ifndef COLOR_T2555686324_H
#define COLOR_T2555686324_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Color
struct Color_t2555686324
{
public:
// System.Single UnityEngine.Color::r
float ___r_0;
// System.Single UnityEngine.Color::g
float ___g_1;
// System.Single UnityEngine.Color::b
float ___b_2;
// System.Single UnityEngine.Color::a
float ___a_3;
public:
inline static int32_t get_offset_of_r_0() { return static_cast<int32_t>(offsetof(Color_t2555686324, ___r_0)); }
inline float get_r_0() const { return ___r_0; }
inline float* get_address_of_r_0() { return &___r_0; }
inline void set_r_0(float value)
{
___r_0 = value;
}
inline static int32_t get_offset_of_g_1() { return static_cast<int32_t>(offsetof(Color_t2555686324, ___g_1)); }
inline float get_g_1() const { return ___g_1; }
inline float* get_address_of_g_1() { return &___g_1; }
inline void set_g_1(float value)
{
___g_1 = value;
}
inline static int32_t get_offset_of_b_2() { return static_cast<int32_t>(offsetof(Color_t2555686324, ___b_2)); }
inline float get_b_2() const { return ___b_2; }
inline float* get_address_of_b_2() { return &___b_2; }
inline void set_b_2(float value)
{
___b_2 = value;
}
inline static int32_t get_offset_of_a_3() { return static_cast<int32_t>(offsetof(Color_t2555686324, ___a_3)); }
inline float get_a_3() const { return ___a_3; }
inline float* get_address_of_a_3() { return &___a_3; }
inline void set_a_3(float value)
{
___a_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COLOR_T2555686324_H
#ifndef RECT_T2360479859_H
#define RECT_T2360479859_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Rect
struct Rect_t2360479859
{
public:
// System.Single UnityEngine.Rect::m_XMin
float ___m_XMin_0;
// System.Single UnityEngine.Rect::m_YMin
float ___m_YMin_1;
// System.Single UnityEngine.Rect::m_Width
float ___m_Width_2;
// System.Single UnityEngine.Rect::m_Height
float ___m_Height_3;
public:
inline static int32_t get_offset_of_m_XMin_0() { return static_cast<int32_t>(offsetof(Rect_t2360479859, ___m_XMin_0)); }
inline float get_m_XMin_0() const { return ___m_XMin_0; }
inline float* get_address_of_m_XMin_0() { return &___m_XMin_0; }
inline void set_m_XMin_0(float value)
{
___m_XMin_0 = value;
}
inline static int32_t get_offset_of_m_YMin_1() { return static_cast<int32_t>(offsetof(Rect_t2360479859, ___m_YMin_1)); }
inline float get_m_YMin_1() const { return ___m_YMin_1; }
inline float* get_address_of_m_YMin_1() { return &___m_YMin_1; }
inline void set_m_YMin_1(float value)
{
___m_YMin_1 = value;
}
inline static int32_t get_offset_of_m_Width_2() { return static_cast<int32_t>(offsetof(Rect_t2360479859, ___m_Width_2)); }
inline float get_m_Width_2() const { return ___m_Width_2; }
inline float* get_address_of_m_Width_2() { return &___m_Width_2; }
inline void set_m_Width_2(float value)
{
___m_Width_2 = value;
}
inline static int32_t get_offset_of_m_Height_3() { return static_cast<int32_t>(offsetof(Rect_t2360479859, ___m_Height_3)); }
inline float get_m_Height_3() const { return ___m_Height_3; }
inline float* get_address_of_m_Height_3() { return &___m_Height_3; }
inline void set_m_Height_3(float value)
{
___m_Height_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RECT_T2360479859_H
#ifndef U3CPERIODICACTIONU3EC__ITERATOR2_T2169154091_H
#define U3CPERIODICACTIONU3EC__ITERATOR2_T2169154091_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2
struct U3CPeriodicActionU3Ec__Iterator2_t2169154091 : public RuntimeObject
{
public:
// System.TimeSpan UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::period
TimeSpan_t881159249 ___period_0;
// UniRx.ICancelable UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::cancellation
RuntimeObject* ___cancellation_1;
// System.Action UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::action
Action_t1264377477 * ___action_2;
// System.Single UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::<startTime>__1
float ___U3CstartTimeU3E__1_3;
// System.Single UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::<dt>__1
float ___U3CdtU3E__1_4;
// System.Single UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::<ft>__2
float ___U3CftU3E__2_5;
// System.Single UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::<elapsed>__2
float ___U3CelapsedU3E__2_6;
// System.Object UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::$current
RuntimeObject * ___U24current_7;
// System.Boolean UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::$disposing
bool ___U24disposing_8;
// System.Int32 UniRx.Scheduler/FixedUpdateMainThreadScheduler/<PeriodicAction>c__Iterator2::$PC
int32_t ___U24PC_9;
public:
inline static int32_t get_offset_of_period_0() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___period_0)); }
inline TimeSpan_t881159249 get_period_0() const { return ___period_0; }
inline TimeSpan_t881159249 * get_address_of_period_0() { return &___period_0; }
inline void set_period_0(TimeSpan_t881159249 value)
{
___period_0 = value;
}
inline static int32_t get_offset_of_cancellation_1() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___cancellation_1)); }
inline RuntimeObject* get_cancellation_1() const { return ___cancellation_1; }
inline RuntimeObject** get_address_of_cancellation_1() { return &___cancellation_1; }
inline void set_cancellation_1(RuntimeObject* value)
{
___cancellation_1 = value;
Il2CppCodeGenWriteBarrier((&___cancellation_1), value);
}
inline static int32_t get_offset_of_action_2() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___action_2)); }
inline Action_t1264377477 * get_action_2() const { return ___action_2; }
inline Action_t1264377477 ** get_address_of_action_2() { return &___action_2; }
inline void set_action_2(Action_t1264377477 * value)
{
___action_2 = value;
Il2CppCodeGenWriteBarrier((&___action_2), value);
}
inline static int32_t get_offset_of_U3CstartTimeU3E__1_3() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___U3CstartTimeU3E__1_3)); }
inline float get_U3CstartTimeU3E__1_3() const { return ___U3CstartTimeU3E__1_3; }
inline float* get_address_of_U3CstartTimeU3E__1_3() { return &___U3CstartTimeU3E__1_3; }
inline void set_U3CstartTimeU3E__1_3(float value)
{
___U3CstartTimeU3E__1_3 = value;
}
inline static int32_t get_offset_of_U3CdtU3E__1_4() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___U3CdtU3E__1_4)); }
inline float get_U3CdtU3E__1_4() const { return ___U3CdtU3E__1_4; }
inline float* get_address_of_U3CdtU3E__1_4() { return &___U3CdtU3E__1_4; }
inline void set_U3CdtU3E__1_4(float value)
{
___U3CdtU3E__1_4 = value;
}
inline static int32_t get_offset_of_U3CftU3E__2_5() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___U3CftU3E__2_5)); }
inline float get_U3CftU3E__2_5() const { return ___U3CftU3E__2_5; }
inline float* get_address_of_U3CftU3E__2_5() { return &___U3CftU3E__2_5; }
inline void set_U3CftU3E__2_5(float value)
{
___U3CftU3E__2_5 = value;
}
inline static int32_t get_offset_of_U3CelapsedU3E__2_6() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___U3CelapsedU3E__2_6)); }
inline float get_U3CelapsedU3E__2_6() const { return ___U3CelapsedU3E__2_6; }
inline float* get_address_of_U3CelapsedU3E__2_6() { return &___U3CelapsedU3E__2_6; }
inline void set_U3CelapsedU3E__2_6(float value)
{
___U3CelapsedU3E__2_6 = value;
}
inline static int32_t get_offset_of_U24current_7() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___U24current_7)); }
inline RuntimeObject * get_U24current_7() const { return ___U24current_7; }
inline RuntimeObject ** get_address_of_U24current_7() { return &___U24current_7; }
inline void set_U24current_7(RuntimeObject * value)
{
___U24current_7 = value;
Il2CppCodeGenWriteBarrier((&___U24current_7), value);
}
inline static int32_t get_offset_of_U24disposing_8() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___U24disposing_8)); }
inline bool get_U24disposing_8() const { return ___U24disposing_8; }
inline bool* get_address_of_U24disposing_8() { return &___U24disposing_8; }
inline void set_U24disposing_8(bool value)
{
___U24disposing_8 = value;
}
inline static int32_t get_offset_of_U24PC_9() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2169154091, ___U24PC_9)); }
inline int32_t get_U24PC_9() const { return ___U24PC_9; }
inline int32_t* get_address_of_U24PC_9() { return &___U24PC_9; }
inline void set_U24PC_9(int32_t value)
{
___U24PC_9 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CPERIODICACTIONU3EC__ITERATOR2_T2169154091_H
#ifndef REACTIVEPROPERTY_1_T1536653225_H
#define REACTIVEPROPERTY_1_T1536653225_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<UnityEngine.Quaternion>
struct ReactiveProperty_1_t1536653225 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
Quaternion_t2301928331 ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t2390584718 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1536653225, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1536653225, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1536653225, ___value_3)); }
inline Quaternion_t2301928331 get_value_3() const { return ___value_3; }
inline Quaternion_t2301928331 * get_address_of_value_3() { return &___value_3; }
inline void set_value_3(Quaternion_t2301928331 value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1536653225, ___publisher_4)); }
inline Subject_1_t2390584718 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t2390584718 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t2390584718 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1536653225, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1536653225, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t1536653225_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1536653225_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T1536653225_H
#ifndef REACTIVEPROPERTY_1_T1790411218_H
#define REACTIVEPROPERTY_1_T1790411218_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<UnityEngine.Color>
struct ReactiveProperty_1_t1790411218 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
Color_t2555686324 ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t2644342711 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1790411218, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1790411218, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1790411218, ___value_3)); }
inline Color_t2555686324 get_value_3() const { return ___value_3; }
inline Color_t2555686324 * get_address_of_value_3() { return &___value_3; }
inline void set_value_3(Color_t2555686324 value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1790411218, ___publisher_4)); }
inline Subject_1_t2644342711 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t2644342711 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t2644342711 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1790411218, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1790411218, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t1790411218_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1790411218_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T1790411218_H
#ifndef U3CPERIODICACTIONU3EC__ITERATOR1_T2287198350_H
#define U3CPERIODICACTIONU3EC__ITERATOR1_T2287198350_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/IgnoreTimeScaleMainThreadScheduler/<PeriodicAction>c__Iterator1
struct U3CPeriodicActionU3Ec__Iterator1_t2287198350 : public RuntimeObject
{
public:
// System.TimeSpan UniRx.Scheduler/IgnoreTimeScaleMainThreadScheduler/<PeriodicAction>c__Iterator1::period
TimeSpan_t881159249 ___period_0;
// UniRx.ICancelable UniRx.Scheduler/IgnoreTimeScaleMainThreadScheduler/<PeriodicAction>c__Iterator1::cancellation
RuntimeObject* ___cancellation_1;
// System.Action UniRx.Scheduler/IgnoreTimeScaleMainThreadScheduler/<PeriodicAction>c__Iterator1::action
Action_t1264377477 * ___action_2;
// System.Single UniRx.Scheduler/IgnoreTimeScaleMainThreadScheduler/<PeriodicAction>c__Iterator1::<elapsed>__1
float ___U3CelapsedU3E__1_3;
// System.Single UniRx.Scheduler/IgnoreTimeScaleMainThreadScheduler/<PeriodicAction>c__Iterator1::<dt>__1
float ___U3CdtU3E__1_4;
// System.Object UniRx.Scheduler/IgnoreTimeScaleMainThreadScheduler/<PeriodicAction>c__Iterator1::$current
RuntimeObject * ___U24current_5;
// System.Boolean UniRx.Scheduler/IgnoreTimeScaleMainThreadScheduler/<PeriodicAction>c__Iterator1::$disposing
bool ___U24disposing_6;
// System.Int32 UniRx.Scheduler/IgnoreTimeScaleMainThreadScheduler/<PeriodicAction>c__Iterator1::$PC
int32_t ___U24PC_7;
public:
inline static int32_t get_offset_of_period_0() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator1_t2287198350, ___period_0)); }
inline TimeSpan_t881159249 get_period_0() const { return ___period_0; }
inline TimeSpan_t881159249 * get_address_of_period_0() { return &___period_0; }
inline void set_period_0(TimeSpan_t881159249 value)
{
___period_0 = value;
}
inline static int32_t get_offset_of_cancellation_1() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator1_t2287198350, ___cancellation_1)); }
inline RuntimeObject* get_cancellation_1() const { return ___cancellation_1; }
inline RuntimeObject** get_address_of_cancellation_1() { return &___cancellation_1; }
inline void set_cancellation_1(RuntimeObject* value)
{
___cancellation_1 = value;
Il2CppCodeGenWriteBarrier((&___cancellation_1), value);
}
inline static int32_t get_offset_of_action_2() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator1_t2287198350, ___action_2)); }
inline Action_t1264377477 * get_action_2() const { return ___action_2; }
inline Action_t1264377477 ** get_address_of_action_2() { return &___action_2; }
inline void set_action_2(Action_t1264377477 * value)
{
___action_2 = value;
Il2CppCodeGenWriteBarrier((&___action_2), value);
}
inline static int32_t get_offset_of_U3CelapsedU3E__1_3() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator1_t2287198350, ___U3CelapsedU3E__1_3)); }
inline float get_U3CelapsedU3E__1_3() const { return ___U3CelapsedU3E__1_3; }
inline float* get_address_of_U3CelapsedU3E__1_3() { return &___U3CelapsedU3E__1_3; }
inline void set_U3CelapsedU3E__1_3(float value)
{
___U3CelapsedU3E__1_3 = value;
}
inline static int32_t get_offset_of_U3CdtU3E__1_4() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator1_t2287198350, ___U3CdtU3E__1_4)); }
inline float get_U3CdtU3E__1_4() const { return ___U3CdtU3E__1_4; }
inline float* get_address_of_U3CdtU3E__1_4() { return &___U3CdtU3E__1_4; }
inline void set_U3CdtU3E__1_4(float value)
{
___U3CdtU3E__1_4 = value;
}
inline static int32_t get_offset_of_U24current_5() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator1_t2287198350, ___U24current_5)); }
inline RuntimeObject * get_U24current_5() const { return ___U24current_5; }
inline RuntimeObject ** get_address_of_U24current_5() { return &___U24current_5; }
inline void set_U24current_5(RuntimeObject * value)
{
___U24current_5 = value;
Il2CppCodeGenWriteBarrier((&___U24current_5), value);
}
inline static int32_t get_offset_of_U24disposing_6() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator1_t2287198350, ___U24disposing_6)); }
inline bool get_U24disposing_6() const { return ___U24disposing_6; }
inline bool* get_address_of_U24disposing_6() { return &___U24disposing_6; }
inline void set_U24disposing_6(bool value)
{
___U24disposing_6 = value;
}
inline static int32_t get_offset_of_U24PC_7() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator1_t2287198350, ___U24PC_7)); }
inline int32_t get_U24PC_7() const { return ___U24PC_7; }
inline int32_t* get_address_of_U24PC_7() { return &___U24PC_7; }
inline void set_U24PC_7(int32_t value)
{
___U24PC_7 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CPERIODICACTIONU3EC__ITERATOR1_T2287198350_H
#ifndef U3CDELAYACTIONU3EC__ITERATOR1_T1566613126_H
#define U3CDELAYACTIONU3EC__ITERATOR1_T1566613126_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/EndOfFrameMainThreadScheduler/<DelayAction>c__Iterator1
struct U3CDelayActionU3Ec__Iterator1_t1566613126 : public RuntimeObject
{
public:
// System.TimeSpan UniRx.Scheduler/EndOfFrameMainThreadScheduler/<DelayAction>c__Iterator1::dueTime
TimeSpan_t881159249 ___dueTime_0;
// UniRx.ICancelable UniRx.Scheduler/EndOfFrameMainThreadScheduler/<DelayAction>c__Iterator1::cancellation
RuntimeObject* ___cancellation_1;
// System.Action UniRx.Scheduler/EndOfFrameMainThreadScheduler/<DelayAction>c__Iterator1::action
Action_t1264377477 * ___action_2;
// System.Single UniRx.Scheduler/EndOfFrameMainThreadScheduler/<DelayAction>c__Iterator1::<elapsed>__1
float ___U3CelapsedU3E__1_3;
// System.Single UniRx.Scheduler/EndOfFrameMainThreadScheduler/<DelayAction>c__Iterator1::<dt>__1
float ___U3CdtU3E__1_4;
// System.Object UniRx.Scheduler/EndOfFrameMainThreadScheduler/<DelayAction>c__Iterator1::$current
RuntimeObject * ___U24current_5;
// System.Boolean UniRx.Scheduler/EndOfFrameMainThreadScheduler/<DelayAction>c__Iterator1::$disposing
bool ___U24disposing_6;
// System.Int32 UniRx.Scheduler/EndOfFrameMainThreadScheduler/<DelayAction>c__Iterator1::$PC
int32_t ___U24PC_7;
public:
inline static int32_t get_offset_of_dueTime_0() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t1566613126, ___dueTime_0)); }
inline TimeSpan_t881159249 get_dueTime_0() const { return ___dueTime_0; }
inline TimeSpan_t881159249 * get_address_of_dueTime_0() { return &___dueTime_0; }
inline void set_dueTime_0(TimeSpan_t881159249 value)
{
___dueTime_0 = value;
}
inline static int32_t get_offset_of_cancellation_1() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t1566613126, ___cancellation_1)); }
inline RuntimeObject* get_cancellation_1() const { return ___cancellation_1; }
inline RuntimeObject** get_address_of_cancellation_1() { return &___cancellation_1; }
inline void set_cancellation_1(RuntimeObject* value)
{
___cancellation_1 = value;
Il2CppCodeGenWriteBarrier((&___cancellation_1), value);
}
inline static int32_t get_offset_of_action_2() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t1566613126, ___action_2)); }
inline Action_t1264377477 * get_action_2() const { return ___action_2; }
inline Action_t1264377477 ** get_address_of_action_2() { return &___action_2; }
inline void set_action_2(Action_t1264377477 * value)
{
___action_2 = value;
Il2CppCodeGenWriteBarrier((&___action_2), value);
}
inline static int32_t get_offset_of_U3CelapsedU3E__1_3() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t1566613126, ___U3CelapsedU3E__1_3)); }
inline float get_U3CelapsedU3E__1_3() const { return ___U3CelapsedU3E__1_3; }
inline float* get_address_of_U3CelapsedU3E__1_3() { return &___U3CelapsedU3E__1_3; }
inline void set_U3CelapsedU3E__1_3(float value)
{
___U3CelapsedU3E__1_3 = value;
}
inline static int32_t get_offset_of_U3CdtU3E__1_4() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t1566613126, ___U3CdtU3E__1_4)); }
inline float get_U3CdtU3E__1_4() const { return ___U3CdtU3E__1_4; }
inline float* get_address_of_U3CdtU3E__1_4() { return &___U3CdtU3E__1_4; }
inline void set_U3CdtU3E__1_4(float value)
{
___U3CdtU3E__1_4 = value;
}
inline static int32_t get_offset_of_U24current_5() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t1566613126, ___U24current_5)); }
inline RuntimeObject * get_U24current_5() const { return ___U24current_5; }
inline RuntimeObject ** get_address_of_U24current_5() { return &___U24current_5; }
inline void set_U24current_5(RuntimeObject * value)
{
___U24current_5 = value;
Il2CppCodeGenWriteBarrier((&___U24current_5), value);
}
inline static int32_t get_offset_of_U24disposing_6() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t1566613126, ___U24disposing_6)); }
inline bool get_U24disposing_6() const { return ___U24disposing_6; }
inline bool* get_address_of_U24disposing_6() { return &___U24disposing_6; }
inline void set_U24disposing_6(bool value)
{
___U24disposing_6 = value;
}
inline static int32_t get_offset_of_U24PC_7() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t1566613126, ___U24PC_7)); }
inline int32_t get_U24PC_7() const { return ___U24PC_7; }
inline int32_t* get_address_of_U24PC_7() { return &___U24PC_7; }
inline void set_U24PC_7(int32_t value)
{
___U24PC_7 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CDELAYACTIONU3EC__ITERATOR1_T1566613126_H
#ifndef U3CDELAYACTIONU3EC__ITERATOR1_T3218606553_H
#define U3CDELAYACTIONU3EC__ITERATOR1_T3218606553_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1
struct U3CDelayActionU3Ec__Iterator1_t3218606553 : public RuntimeObject
{
public:
// System.TimeSpan UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1::dueTime
TimeSpan_t881159249 ___dueTime_0;
// UniRx.ICancelable UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1::cancellation
RuntimeObject* ___cancellation_1;
// System.Action UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1::action
Action_t1264377477 * ___action_2;
// System.Single UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1::<startTime>__1
float ___U3CstartTimeU3E__1_3;
// System.Single UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1::<dt>__1
float ___U3CdtU3E__1_4;
// System.Single UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1::<elapsed>__2
float ___U3CelapsedU3E__2_5;
// System.Object UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1::$current
RuntimeObject * ___U24current_6;
// System.Boolean UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1::$disposing
bool ___U24disposing_7;
// System.Int32 UniRx.Scheduler/FixedUpdateMainThreadScheduler/<DelayAction>c__Iterator1::$PC
int32_t ___U24PC_8;
public:
inline static int32_t get_offset_of_dueTime_0() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t3218606553, ___dueTime_0)); }
inline TimeSpan_t881159249 get_dueTime_0() const { return ___dueTime_0; }
inline TimeSpan_t881159249 * get_address_of_dueTime_0() { return &___dueTime_0; }
inline void set_dueTime_0(TimeSpan_t881159249 value)
{
___dueTime_0 = value;
}
inline static int32_t get_offset_of_cancellation_1() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t3218606553, ___cancellation_1)); }
inline RuntimeObject* get_cancellation_1() const { return ___cancellation_1; }
inline RuntimeObject** get_address_of_cancellation_1() { return &___cancellation_1; }
inline void set_cancellation_1(RuntimeObject* value)
{
___cancellation_1 = value;
Il2CppCodeGenWriteBarrier((&___cancellation_1), value);
}
inline static int32_t get_offset_of_action_2() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t3218606553, ___action_2)); }
inline Action_t1264377477 * get_action_2() const { return ___action_2; }
inline Action_t1264377477 ** get_address_of_action_2() { return &___action_2; }
inline void set_action_2(Action_t1264377477 * value)
{
___action_2 = value;
Il2CppCodeGenWriteBarrier((&___action_2), value);
}
inline static int32_t get_offset_of_U3CstartTimeU3E__1_3() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t3218606553, ___U3CstartTimeU3E__1_3)); }
inline float get_U3CstartTimeU3E__1_3() const { return ___U3CstartTimeU3E__1_3; }
inline float* get_address_of_U3CstartTimeU3E__1_3() { return &___U3CstartTimeU3E__1_3; }
inline void set_U3CstartTimeU3E__1_3(float value)
{
___U3CstartTimeU3E__1_3 = value;
}
inline static int32_t get_offset_of_U3CdtU3E__1_4() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t3218606553, ___U3CdtU3E__1_4)); }
inline float get_U3CdtU3E__1_4() const { return ___U3CdtU3E__1_4; }
inline float* get_address_of_U3CdtU3E__1_4() { return &___U3CdtU3E__1_4; }
inline void set_U3CdtU3E__1_4(float value)
{
___U3CdtU3E__1_4 = value;
}
inline static int32_t get_offset_of_U3CelapsedU3E__2_5() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t3218606553, ___U3CelapsedU3E__2_5)); }
inline float get_U3CelapsedU3E__2_5() const { return ___U3CelapsedU3E__2_5; }
inline float* get_address_of_U3CelapsedU3E__2_5() { return &___U3CelapsedU3E__2_5; }
inline void set_U3CelapsedU3E__2_5(float value)
{
___U3CelapsedU3E__2_5 = value;
}
inline static int32_t get_offset_of_U24current_6() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t3218606553, ___U24current_6)); }
inline RuntimeObject * get_U24current_6() const { return ___U24current_6; }
inline RuntimeObject ** get_address_of_U24current_6() { return &___U24current_6; }
inline void set_U24current_6(RuntimeObject * value)
{
___U24current_6 = value;
Il2CppCodeGenWriteBarrier((&___U24current_6), value);
}
inline static int32_t get_offset_of_U24disposing_7() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t3218606553, ___U24disposing_7)); }
inline bool get_U24disposing_7() const { return ___U24disposing_7; }
inline bool* get_address_of_U24disposing_7() { return &___U24disposing_7; }
inline void set_U24disposing_7(bool value)
{
___U24disposing_7 = value;
}
inline static int32_t get_offset_of_U24PC_8() { return static_cast<int32_t>(offsetof(U3CDelayActionU3Ec__Iterator1_t3218606553, ___U24PC_8)); }
inline int32_t get_U24PC_8() const { return ___U24PC_8; }
inline int32_t* get_address_of_U24PC_8() { return &___U24PC_8; }
inline void set_U24PC_8(int32_t value)
{
___U24PC_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CDELAYACTIONU3EC__ITERATOR1_T3218606553_H
#ifndef REACTIVEPROPERTY_1_T2553753831_H
#define REACTIVEPROPERTY_1_T2553753831_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<UnityEngine.Vector4>
struct ReactiveProperty_1_t2553753831 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
Vector4_t3319028937 ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t3407685324 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2553753831, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2553753831, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2553753831, ___value_3)); }
inline Vector4_t3319028937 get_value_3() const { return ___value_3; }
inline Vector4_t3319028937 * get_address_of_value_3() { return &___value_3; }
inline void set_value_3(Vector4_t3319028937 value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2553753831, ___publisher_4)); }
inline Subject_1_t3407685324 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t3407685324 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t3407685324 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2553753831, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2553753831, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t2553753831_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2553753831_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T2553753831_H
#ifndef REACTIVEPROPERTY_1_T1595204753_H
#define REACTIVEPROPERTY_1_T1595204753_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<UnityEngine.Rect>
struct ReactiveProperty_1_t1595204753 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
Rect_t2360479859 ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t2449136246 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1595204753, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1595204753, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1595204753, ___value_3)); }
inline Rect_t2360479859 get_value_3() const { return ___value_3; }
inline Rect_t2360479859 * get_address_of_value_3() { return &___value_3; }
inline void set_value_3(Rect_t2360479859 value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1595204753, ___publisher_4)); }
inline Subject_1_t2449136246 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t2449136246 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t2449136246 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1595204753, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1595204753, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t1595204753_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1595204753_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T1595204753_H
#ifndef REACTIVEPROPERTY_1_T1390954417_H
#define REACTIVEPROPERTY_1_T1390954417_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<UnityEngine.Vector2>
struct ReactiveProperty_1_t1390954417 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
Vector2_t2156229523 ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t2244885910 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1390954417, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1390954417, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1390954417, ___value_3)); }
inline Vector2_t2156229523 get_value_3() const { return ___value_3; }
inline Vector2_t2156229523 * get_address_of_value_3() { return &___value_3; }
inline void set_value_3(Vector2_t2156229523 value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1390954417, ___publisher_4)); }
inline Subject_1_t2244885910 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t2244885910 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t2244885910 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1390954417, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1390954417, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t1390954417_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1390954417_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T1390954417_H
#ifndef REACTIVEPROPERTY_1_T2957038358_H
#define REACTIVEPROPERTY_1_T2957038358_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<UnityEngine.Vector3>
struct ReactiveProperty_1_t2957038358 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
Vector3_t3722313464 ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t3810969851 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2957038358, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2957038358, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2957038358, ___value_3)); }
inline Vector3_t3722313464 get_value_3() const { return ___value_3; }
inline Vector3_t3722313464 * get_address_of_value_3() { return &___value_3; }
inline void set_value_3(Vector3_t3722313464 value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2957038358, ___publisher_4)); }
inline Subject_1_t3810969851 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t3810969851 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t3810969851 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2957038358, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2957038358, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t2957038358_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t2957038358_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T2957038358_H
#ifndef U3CPERIODICACTIONU3EC__ITERATOR2_T2292180132_H
#define U3CPERIODICACTIONU3EC__ITERATOR2_T2292180132_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Scheduler/EndOfFrameMainThreadScheduler/<PeriodicAction>c__Iterator2
struct U3CPeriodicActionU3Ec__Iterator2_t2292180132 : public RuntimeObject
{
public:
// System.TimeSpan UniRx.Scheduler/EndOfFrameMainThreadScheduler/<PeriodicAction>c__Iterator2::period
TimeSpan_t881159249 ___period_0;
// UniRx.ICancelable UniRx.Scheduler/EndOfFrameMainThreadScheduler/<PeriodicAction>c__Iterator2::cancellation
RuntimeObject* ___cancellation_1;
// System.Action UniRx.Scheduler/EndOfFrameMainThreadScheduler/<PeriodicAction>c__Iterator2::action
Action_t1264377477 * ___action_2;
// System.Single UniRx.Scheduler/EndOfFrameMainThreadScheduler/<PeriodicAction>c__Iterator2::<elapsed>__1
float ___U3CelapsedU3E__1_3;
// System.Single UniRx.Scheduler/EndOfFrameMainThreadScheduler/<PeriodicAction>c__Iterator2::<dt>__1
float ___U3CdtU3E__1_4;
// System.Object UniRx.Scheduler/EndOfFrameMainThreadScheduler/<PeriodicAction>c__Iterator2::$current
RuntimeObject * ___U24current_5;
// System.Boolean UniRx.Scheduler/EndOfFrameMainThreadScheduler/<PeriodicAction>c__Iterator2::$disposing
bool ___U24disposing_6;
// System.Int32 UniRx.Scheduler/EndOfFrameMainThreadScheduler/<PeriodicAction>c__Iterator2::$PC
int32_t ___U24PC_7;
public:
inline static int32_t get_offset_of_period_0() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2292180132, ___period_0)); }
inline TimeSpan_t881159249 get_period_0() const { return ___period_0; }
inline TimeSpan_t881159249 * get_address_of_period_0() { return &___period_0; }
inline void set_period_0(TimeSpan_t881159249 value)
{
___period_0 = value;
}
inline static int32_t get_offset_of_cancellation_1() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2292180132, ___cancellation_1)); }
inline RuntimeObject* get_cancellation_1() const { return ___cancellation_1; }
inline RuntimeObject** get_address_of_cancellation_1() { return &___cancellation_1; }
inline void set_cancellation_1(RuntimeObject* value)
{
___cancellation_1 = value;
Il2CppCodeGenWriteBarrier((&___cancellation_1), value);
}
inline static int32_t get_offset_of_action_2() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2292180132, ___action_2)); }
inline Action_t1264377477 * get_action_2() const { return ___action_2; }
inline Action_t1264377477 ** get_address_of_action_2() { return &___action_2; }
inline void set_action_2(Action_t1264377477 * value)
{
___action_2 = value;
Il2CppCodeGenWriteBarrier((&___action_2), value);
}
inline static int32_t get_offset_of_U3CelapsedU3E__1_3() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2292180132, ___U3CelapsedU3E__1_3)); }
inline float get_U3CelapsedU3E__1_3() const { return ___U3CelapsedU3E__1_3; }
inline float* get_address_of_U3CelapsedU3E__1_3() { return &___U3CelapsedU3E__1_3; }
inline void set_U3CelapsedU3E__1_3(float value)
{
___U3CelapsedU3E__1_3 = value;
}
inline static int32_t get_offset_of_U3CdtU3E__1_4() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2292180132, ___U3CdtU3E__1_4)); }
inline float get_U3CdtU3E__1_4() const { return ___U3CdtU3E__1_4; }
inline float* get_address_of_U3CdtU3E__1_4() { return &___U3CdtU3E__1_4; }
inline void set_U3CdtU3E__1_4(float value)
{
___U3CdtU3E__1_4 = value;
}
inline static int32_t get_offset_of_U24current_5() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2292180132, ___U24current_5)); }
inline RuntimeObject * get_U24current_5() const { return ___U24current_5; }
inline RuntimeObject ** get_address_of_U24current_5() { return &___U24current_5; }
inline void set_U24current_5(RuntimeObject * value)
{
___U24current_5 = value;
Il2CppCodeGenWriteBarrier((&___U24current_5), value);
}
inline static int32_t get_offset_of_U24disposing_6() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2292180132, ___U24disposing_6)); }
inline bool get_U24disposing_6() const { return ___U24disposing_6; }
inline bool* get_address_of_U24disposing_6() { return &___U24disposing_6; }
inline void set_U24disposing_6(bool value)
{
___U24disposing_6 = value;
}
inline static int32_t get_offset_of_U24PC_7() { return static_cast<int32_t>(offsetof(U3CPeriodicActionU3Ec__Iterator2_t2292180132, ___U24PC_7)); }
inline int32_t get_U24PC_7() const { return ___U24PC_7; }
inline int32_t* get_address_of_U24PC_7() { return &___U24PC_7; }
inline void set_U24PC_7(int32_t value)
{
___U24PC_7 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CPERIODICACTIONU3EC__ITERATOR2_T2292180132_H
#ifndef BOUNDS_T2266837910_H
#define BOUNDS_T2266837910_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Bounds
struct Bounds_t2266837910
{
public:
// UnityEngine.Vector3 UnityEngine.Bounds::m_Center
Vector3_t3722313464 ___m_Center_0;
// UnityEngine.Vector3 UnityEngine.Bounds::m_Extents
Vector3_t3722313464 ___m_Extents_1;
public:
inline static int32_t get_offset_of_m_Center_0() { return static_cast<int32_t>(offsetof(Bounds_t2266837910, ___m_Center_0)); }
inline Vector3_t3722313464 get_m_Center_0() const { return ___m_Center_0; }
inline Vector3_t3722313464 * get_address_of_m_Center_0() { return &___m_Center_0; }
inline void set_m_Center_0(Vector3_t3722313464 value)
{
___m_Center_0 = value;
}
inline static int32_t get_offset_of_m_Extents_1() { return static_cast<int32_t>(offsetof(Bounds_t2266837910, ___m_Extents_1)); }
inline Vector3_t3722313464 get_m_Extents_1() const { return ___m_Extents_1; }
inline Vector3_t3722313464 * get_address_of_m_Extents_1() { return &___m_Extents_1; }
inline void set_m_Extents_1(Vector3_t3722313464 value)
{
___m_Extents_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BOUNDS_T2266837910_H
#ifndef INSPECTORDISPLAYATTRIBUTE_T2165086330_H
#define INSPECTORDISPLAYATTRIBUTE_T2165086330_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.InspectorDisplayAttribute
struct InspectorDisplayAttribute_t2165086330 : public PropertyAttribute_t3677895545
{
public:
// System.String UniRx.InspectorDisplayAttribute::<FieldName>k__BackingField
String_t* ___U3CFieldNameU3Ek__BackingField_0;
// System.Boolean UniRx.InspectorDisplayAttribute::<NotifyPropertyChanged>k__BackingField
bool ___U3CNotifyPropertyChangedU3Ek__BackingField_1;
public:
inline static int32_t get_offset_of_U3CFieldNameU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(InspectorDisplayAttribute_t2165086330, ___U3CFieldNameU3Ek__BackingField_0)); }
inline String_t* get_U3CFieldNameU3Ek__BackingField_0() const { return ___U3CFieldNameU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CFieldNameU3Ek__BackingField_0() { return &___U3CFieldNameU3Ek__BackingField_0; }
inline void set_U3CFieldNameU3Ek__BackingField_0(String_t* value)
{
___U3CFieldNameU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CFieldNameU3Ek__BackingField_0), value);
}
inline static int32_t get_offset_of_U3CNotifyPropertyChangedU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(InspectorDisplayAttribute_t2165086330, ___U3CNotifyPropertyChangedU3Ek__BackingField_1)); }
inline bool get_U3CNotifyPropertyChangedU3Ek__BackingField_1() const { return ___U3CNotifyPropertyChangedU3Ek__BackingField_1; }
inline bool* get_address_of_U3CNotifyPropertyChangedU3Ek__BackingField_1() { return &___U3CNotifyPropertyChangedU3Ek__BackingField_1; }
inline void set_U3CNotifyPropertyChangedU3Ek__BackingField_1(bool value)
{
___U3CNotifyPropertyChangedU3Ek__BackingField_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // INSPECTORDISPLAYATTRIBUTE_T2165086330_H
#ifndef TASKSTATUS_T4183509909_H
#define TASKSTATUS_T4183509909_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.LazyTask/TaskStatus
struct TaskStatus_t4183509909
{
public:
// System.Int32 UniRx.LazyTask/TaskStatus::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(TaskStatus_t4183509909, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TASKSTATUS_T4183509909_H
#ifndef MULTILINEREACTIVEPROPERTYATTRIBUTE_T2064446684_H
#define MULTILINEREACTIVEPROPERTYATTRIBUTE_T2064446684_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.MultilineReactivePropertyAttribute
struct MultilineReactivePropertyAttribute_t2064446684 : public PropertyAttribute_t3677895545
{
public:
// System.Int32 UniRx.MultilineReactivePropertyAttribute::<Lines>k__BackingField
int32_t ___U3CLinesU3Ek__BackingField_0;
public:
inline static int32_t get_offset_of_U3CLinesU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(MultilineReactivePropertyAttribute_t2064446684, ___U3CLinesU3Ek__BackingField_0)); }
inline int32_t get_U3CLinesU3Ek__BackingField_0() const { return ___U3CLinesU3Ek__BackingField_0; }
inline int32_t* get_address_of_U3CLinesU3Ek__BackingField_0() { return &___U3CLinesU3Ek__BackingField_0; }
inline void set_U3CLinesU3Ek__BackingField_0(int32_t value)
{
___U3CLinesU3Ek__BackingField_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MULTILINEREACTIVEPROPERTYATTRIBUTE_T2064446684_H
#ifndef RANGEREACTIVEPROPERTYATTRIBUTE_T2057313354_H
#define RANGEREACTIVEPROPERTYATTRIBUTE_T2057313354_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.RangeReactivePropertyAttribute
struct RangeReactivePropertyAttribute_t2057313354 : public PropertyAttribute_t3677895545
{
public:
// System.Single UniRx.RangeReactivePropertyAttribute::<Min>k__BackingField
float ___U3CMinU3Ek__BackingField_0;
// System.Single UniRx.RangeReactivePropertyAttribute::<Max>k__BackingField
float ___U3CMaxU3Ek__BackingField_1;
public:
inline static int32_t get_offset_of_U3CMinU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(RangeReactivePropertyAttribute_t2057313354, ___U3CMinU3Ek__BackingField_0)); }
inline float get_U3CMinU3Ek__BackingField_0() const { return ___U3CMinU3Ek__BackingField_0; }
inline float* get_address_of_U3CMinU3Ek__BackingField_0() { return &___U3CMinU3Ek__BackingField_0; }
inline void set_U3CMinU3Ek__BackingField_0(float value)
{
___U3CMinU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CMaxU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(RangeReactivePropertyAttribute_t2057313354, ___U3CMaxU3Ek__BackingField_1)); }
inline float get_U3CMaxU3Ek__BackingField_1() const { return ___U3CMaxU3Ek__BackingField_1; }
inline float* get_address_of_U3CMaxU3Ek__BackingField_1() { return &___U3CMaxU3Ek__BackingField_1; }
inline void set_U3CMaxU3Ek__BackingField_1(float value)
{
___U3CMaxU3Ek__BackingField_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RANGEREACTIVEPROPERTYATTRIBUTE_T2057313354_H
#ifndef OBJECT_T631007953_H
#define OBJECT_T631007953_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Object
struct Object_t631007953 : 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_t631007953, ___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_t631007953_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_t631007953_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;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of UnityEngine.Object
struct Object_t631007953_marshaled_pinvoke
{
intptr_t ___m_CachedPtr_0;
};
// Native definition for COM marshalling of UnityEngine.Object
struct Object_t631007953_marshaled_com
{
intptr_t ___m_CachedPtr_0;
};
#endif // OBJECT_T631007953_H
#ifndef CULLINGMODE_T3030417749_H
#define CULLINGMODE_T3030417749_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.MainThreadDispatcher/CullingMode
struct CullingMode_t3030417749
{
public:
// System.Int32 UniRx.MainThreadDispatcher/CullingMode::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(CullingMode_t3030417749, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CULLINGMODE_T3030417749_H
#ifndef DATETIMEKIND_T3468814247_H
#define DATETIMEKIND_T3468814247_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.DateTimeKind
struct DateTimeKind_t3468814247
{
public:
// System.Int32 System.DateTimeKind::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(DateTimeKind_t3468814247, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DATETIMEKIND_T3468814247_H
#ifndef FRAMECOUNTTYPE_T3331626185_H
#define FRAMECOUNTTYPE_T3331626185_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.FrameCountType
struct FrameCountType_t3331626185
{
public:
// System.Int32 UniRx.FrameCountType::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(FrameCountType_t3331626185, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FRAMECOUNTTYPE_T3331626185_H
#ifndef LOGTYPE_T73765434_H
#define LOGTYPE_T73765434_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.LogType
struct LogType_t73765434
{
public:
// System.Int32 UnityEngine.LogType::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(LogType_t73765434, ___value___1)); }
inline int32_t get_value___1() const { return ___value___1; }
inline int32_t* get_address_of_value___1() { return &___value___1; }
inline void set_value___1(int32_t value)
{
___value___1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // LOGTYPE_T73765434_H
#ifndef COMPONENT_T1923634451_H
#define COMPONENT_T1923634451_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Component
struct Component_t1923634451 : public Object_t631007953
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COMPONENT_T1923634451_H
#ifndef RECTREACTIVEPROPERTY_T1528095736_H
#define RECTREACTIVEPROPERTY_T1528095736_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.RectReactiveProperty
struct RectReactiveProperty_t1528095736 : public ReactiveProperty_1_t1595204753
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RECTREACTIVEPROPERTY_T1528095736_H
#ifndef VECTOR2REACTIVEPROPERTY_T1480206898_H
#define VECTOR2REACTIVEPROPERTY_T1480206898_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Vector2ReactiveProperty
struct Vector2ReactiveProperty_t1480206898 : public ReactiveProperty_1_t1390954417
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VECTOR2REACTIVEPROPERTY_T1480206898_H
#ifndef COLORREACTIVEPROPERTY_T3266332558_H
#define COLORREACTIVEPROPERTY_T3266332558_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ColorReactiveProperty
struct ColorReactiveProperty_t3266332558 : public ReactiveProperty_1_t1790411218
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // COLORREACTIVEPROPERTY_T3266332558_H
#ifndef VECTOR3REACTIVEPROPERTY_T1509712485_H
#define VECTOR3REACTIVEPROPERTY_T1509712485_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Vector3ReactiveProperty
struct Vector3ReactiveProperty_t1509712485 : public ReactiveProperty_1_t2957038358
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VECTOR3REACTIVEPROPERTY_T1509712485_H
#ifndef VECTOR4REACTIVEPROPERTY_T1508944816_H
#define VECTOR4REACTIVEPROPERTY_T1508944816_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Vector4ReactiveProperty
struct Vector4ReactiveProperty_t1508944816 : public ReactiveProperty_1_t2553753831
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VECTOR4REACTIVEPROPERTY_T1508944816_H
#ifndef QUATERNIONREACTIVEPROPERTY_T2539028965_H
#define QUATERNIONREACTIVEPROPERTY_T2539028965_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.QuaternionReactiveProperty
struct QuaternionReactiveProperty_t2539028965 : public ReactiveProperty_1_t1536653225
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // QUATERNIONREACTIVEPROPERTY_T2539028965_H
#ifndef DATETIME_T3738529785_H
#define DATETIME_T3738529785_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.DateTime
struct DateTime_t3738529785
{
public:
// System.TimeSpan System.DateTime::ticks
TimeSpan_t881159249 ___ticks_0;
// System.DateTimeKind System.DateTime::kind
int32_t ___kind_1;
public:
inline static int32_t get_offset_of_ticks_0() { return static_cast<int32_t>(offsetof(DateTime_t3738529785, ___ticks_0)); }
inline TimeSpan_t881159249 get_ticks_0() const { return ___ticks_0; }
inline TimeSpan_t881159249 * get_address_of_ticks_0() { return &___ticks_0; }
inline void set_ticks_0(TimeSpan_t881159249 value)
{
___ticks_0 = value;
}
inline static int32_t get_offset_of_kind_1() { return static_cast<int32_t>(offsetof(DateTime_t3738529785, ___kind_1)); }
inline int32_t get_kind_1() const { return ___kind_1; }
inline int32_t* get_address_of_kind_1() { return &___kind_1; }
inline void set_kind_1(int32_t value)
{
___kind_1 = value;
}
};
struct DateTime_t3738529785_StaticFields
{
public:
// System.DateTime System.DateTime::MaxValue
DateTime_t3738529785 ___MaxValue_2;
// System.DateTime System.DateTime::MinValue
DateTime_t3738529785 ___MinValue_3;
// System.String[] System.DateTime::ParseTimeFormats
StringU5BU5D_t1281789340* ___ParseTimeFormats_4;
// System.String[] System.DateTime::ParseYearDayMonthFormats
StringU5BU5D_t1281789340* ___ParseYearDayMonthFormats_5;
// System.String[] System.DateTime::ParseYearMonthDayFormats
StringU5BU5D_t1281789340* ___ParseYearMonthDayFormats_6;
// System.String[] System.DateTime::ParseDayMonthYearFormats
StringU5BU5D_t1281789340* ___ParseDayMonthYearFormats_7;
// System.String[] System.DateTime::ParseMonthDayYearFormats
StringU5BU5D_t1281789340* ___ParseMonthDayYearFormats_8;
// System.String[] System.DateTime::MonthDayShortFormats
StringU5BU5D_t1281789340* ___MonthDayShortFormats_9;
// System.String[] System.DateTime::DayMonthShortFormats
StringU5BU5D_t1281789340* ___DayMonthShortFormats_10;
// System.Int32[] System.DateTime::daysmonth
Int32U5BU5D_t385246372* ___daysmonth_11;
// System.Int32[] System.DateTime::daysmonthleap
Int32U5BU5D_t385246372* ___daysmonthleap_12;
// System.Object System.DateTime::to_local_time_span_object
RuntimeObject * ___to_local_time_span_object_13;
// System.Int64 System.DateTime::last_now
int64_t ___last_now_14;
public:
inline static int32_t get_offset_of_MaxValue_2() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___MaxValue_2)); }
inline DateTime_t3738529785 get_MaxValue_2() const { return ___MaxValue_2; }
inline DateTime_t3738529785 * get_address_of_MaxValue_2() { return &___MaxValue_2; }
inline void set_MaxValue_2(DateTime_t3738529785 value)
{
___MaxValue_2 = value;
}
inline static int32_t get_offset_of_MinValue_3() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___MinValue_3)); }
inline DateTime_t3738529785 get_MinValue_3() const { return ___MinValue_3; }
inline DateTime_t3738529785 * get_address_of_MinValue_3() { return &___MinValue_3; }
inline void set_MinValue_3(DateTime_t3738529785 value)
{
___MinValue_3 = value;
}
inline static int32_t get_offset_of_ParseTimeFormats_4() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___ParseTimeFormats_4)); }
inline StringU5BU5D_t1281789340* get_ParseTimeFormats_4() const { return ___ParseTimeFormats_4; }
inline StringU5BU5D_t1281789340** get_address_of_ParseTimeFormats_4() { return &___ParseTimeFormats_4; }
inline void set_ParseTimeFormats_4(StringU5BU5D_t1281789340* value)
{
___ParseTimeFormats_4 = value;
Il2CppCodeGenWriteBarrier((&___ParseTimeFormats_4), value);
}
inline static int32_t get_offset_of_ParseYearDayMonthFormats_5() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___ParseYearDayMonthFormats_5)); }
inline StringU5BU5D_t1281789340* get_ParseYearDayMonthFormats_5() const { return ___ParseYearDayMonthFormats_5; }
inline StringU5BU5D_t1281789340** get_address_of_ParseYearDayMonthFormats_5() { return &___ParseYearDayMonthFormats_5; }
inline void set_ParseYearDayMonthFormats_5(StringU5BU5D_t1281789340* value)
{
___ParseYearDayMonthFormats_5 = value;
Il2CppCodeGenWriteBarrier((&___ParseYearDayMonthFormats_5), value);
}
inline static int32_t get_offset_of_ParseYearMonthDayFormats_6() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___ParseYearMonthDayFormats_6)); }
inline StringU5BU5D_t1281789340* get_ParseYearMonthDayFormats_6() const { return ___ParseYearMonthDayFormats_6; }
inline StringU5BU5D_t1281789340** get_address_of_ParseYearMonthDayFormats_6() { return &___ParseYearMonthDayFormats_6; }
inline void set_ParseYearMonthDayFormats_6(StringU5BU5D_t1281789340* value)
{
___ParseYearMonthDayFormats_6 = value;
Il2CppCodeGenWriteBarrier((&___ParseYearMonthDayFormats_6), value);
}
inline static int32_t get_offset_of_ParseDayMonthYearFormats_7() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___ParseDayMonthYearFormats_7)); }
inline StringU5BU5D_t1281789340* get_ParseDayMonthYearFormats_7() const { return ___ParseDayMonthYearFormats_7; }
inline StringU5BU5D_t1281789340** get_address_of_ParseDayMonthYearFormats_7() { return &___ParseDayMonthYearFormats_7; }
inline void set_ParseDayMonthYearFormats_7(StringU5BU5D_t1281789340* value)
{
___ParseDayMonthYearFormats_7 = value;
Il2CppCodeGenWriteBarrier((&___ParseDayMonthYearFormats_7), value);
}
inline static int32_t get_offset_of_ParseMonthDayYearFormats_8() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___ParseMonthDayYearFormats_8)); }
inline StringU5BU5D_t1281789340* get_ParseMonthDayYearFormats_8() const { return ___ParseMonthDayYearFormats_8; }
inline StringU5BU5D_t1281789340** get_address_of_ParseMonthDayYearFormats_8() { return &___ParseMonthDayYearFormats_8; }
inline void set_ParseMonthDayYearFormats_8(StringU5BU5D_t1281789340* value)
{
___ParseMonthDayYearFormats_8 = value;
Il2CppCodeGenWriteBarrier((&___ParseMonthDayYearFormats_8), value);
}
inline static int32_t get_offset_of_MonthDayShortFormats_9() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___MonthDayShortFormats_9)); }
inline StringU5BU5D_t1281789340* get_MonthDayShortFormats_9() const { return ___MonthDayShortFormats_9; }
inline StringU5BU5D_t1281789340** get_address_of_MonthDayShortFormats_9() { return &___MonthDayShortFormats_9; }
inline void set_MonthDayShortFormats_9(StringU5BU5D_t1281789340* value)
{
___MonthDayShortFormats_9 = value;
Il2CppCodeGenWriteBarrier((&___MonthDayShortFormats_9), value);
}
inline static int32_t get_offset_of_DayMonthShortFormats_10() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___DayMonthShortFormats_10)); }
inline StringU5BU5D_t1281789340* get_DayMonthShortFormats_10() const { return ___DayMonthShortFormats_10; }
inline StringU5BU5D_t1281789340** get_address_of_DayMonthShortFormats_10() { return &___DayMonthShortFormats_10; }
inline void set_DayMonthShortFormats_10(StringU5BU5D_t1281789340* value)
{
___DayMonthShortFormats_10 = value;
Il2CppCodeGenWriteBarrier((&___DayMonthShortFormats_10), value);
}
inline static int32_t get_offset_of_daysmonth_11() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___daysmonth_11)); }
inline Int32U5BU5D_t385246372* get_daysmonth_11() const { return ___daysmonth_11; }
inline Int32U5BU5D_t385246372** get_address_of_daysmonth_11() { return &___daysmonth_11; }
inline void set_daysmonth_11(Int32U5BU5D_t385246372* value)
{
___daysmonth_11 = value;
Il2CppCodeGenWriteBarrier((&___daysmonth_11), value);
}
inline static int32_t get_offset_of_daysmonthleap_12() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___daysmonthleap_12)); }
inline Int32U5BU5D_t385246372* get_daysmonthleap_12() const { return ___daysmonthleap_12; }
inline Int32U5BU5D_t385246372** get_address_of_daysmonthleap_12() { return &___daysmonthleap_12; }
inline void set_daysmonthleap_12(Int32U5BU5D_t385246372* value)
{
___daysmonthleap_12 = value;
Il2CppCodeGenWriteBarrier((&___daysmonthleap_12), value);
}
inline static int32_t get_offset_of_to_local_time_span_object_13() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___to_local_time_span_object_13)); }
inline RuntimeObject * get_to_local_time_span_object_13() const { return ___to_local_time_span_object_13; }
inline RuntimeObject ** get_address_of_to_local_time_span_object_13() { return &___to_local_time_span_object_13; }
inline void set_to_local_time_span_object_13(RuntimeObject * value)
{
___to_local_time_span_object_13 = value;
Il2CppCodeGenWriteBarrier((&___to_local_time_span_object_13), value);
}
inline static int32_t get_offset_of_last_now_14() { return static_cast<int32_t>(offsetof(DateTime_t3738529785_StaticFields, ___last_now_14)); }
inline int64_t get_last_now_14() const { return ___last_now_14; }
inline int64_t* get_address_of_last_now_14() { return &___last_now_14; }
inline void set_last_now_14(int64_t value)
{
___last_now_14 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DATETIME_T3738529785_H
#ifndef REACTIVEPROPERTY_1_T1501562804_H
#define REACTIVEPROPERTY_1_T1501562804_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.ReactiveProperty`1<UnityEngine.Bounds>
struct ReactiveProperty_1_t1501562804 : public RuntimeObject
{
public:
// System.Boolean UniRx.ReactiveProperty`1::canPublishValueOnSubscribe
bool ___canPublishValueOnSubscribe_1;
// System.Boolean UniRx.ReactiveProperty`1::isDisposed
bool ___isDisposed_2;
// T UniRx.ReactiveProperty`1::value
Bounds_t2266837910 ___value_3;
// UniRx.Subject`1<T> UniRx.ReactiveProperty`1::publisher
Subject_1_t2355494297 * ___publisher_4;
// System.IDisposable UniRx.ReactiveProperty`1::sourceConnection
RuntimeObject* ___sourceConnection_5;
// System.Exception UniRx.ReactiveProperty`1::lastException
Exception_t * ___lastException_6;
public:
inline static int32_t get_offset_of_canPublishValueOnSubscribe_1() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1501562804, ___canPublishValueOnSubscribe_1)); }
inline bool get_canPublishValueOnSubscribe_1() const { return ___canPublishValueOnSubscribe_1; }
inline bool* get_address_of_canPublishValueOnSubscribe_1() { return &___canPublishValueOnSubscribe_1; }
inline void set_canPublishValueOnSubscribe_1(bool value)
{
___canPublishValueOnSubscribe_1 = value;
}
inline static int32_t get_offset_of_isDisposed_2() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1501562804, ___isDisposed_2)); }
inline bool get_isDisposed_2() const { return ___isDisposed_2; }
inline bool* get_address_of_isDisposed_2() { return &___isDisposed_2; }
inline void set_isDisposed_2(bool value)
{
___isDisposed_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1501562804, ___value_3)); }
inline Bounds_t2266837910 get_value_3() const { return ___value_3; }
inline Bounds_t2266837910 * get_address_of_value_3() { return &___value_3; }
inline void set_value_3(Bounds_t2266837910 value)
{
___value_3 = value;
}
inline static int32_t get_offset_of_publisher_4() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1501562804, ___publisher_4)); }
inline Subject_1_t2355494297 * get_publisher_4() const { return ___publisher_4; }
inline Subject_1_t2355494297 ** get_address_of_publisher_4() { return &___publisher_4; }
inline void set_publisher_4(Subject_1_t2355494297 * value)
{
___publisher_4 = value;
Il2CppCodeGenWriteBarrier((&___publisher_4), value);
}
inline static int32_t get_offset_of_sourceConnection_5() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1501562804, ___sourceConnection_5)); }
inline RuntimeObject* get_sourceConnection_5() const { return ___sourceConnection_5; }
inline RuntimeObject** get_address_of_sourceConnection_5() { return &___sourceConnection_5; }
inline void set_sourceConnection_5(RuntimeObject* value)
{
___sourceConnection_5 = value;
Il2CppCodeGenWriteBarrier((&___sourceConnection_5), value);
}
inline static int32_t get_offset_of_lastException_6() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1501562804, ___lastException_6)); }
inline Exception_t * get_lastException_6() const { return ___lastException_6; }
inline Exception_t ** get_address_of_lastException_6() { return &___lastException_6; }
inline void set_lastException_6(Exception_t * value)
{
___lastException_6 = value;
Il2CppCodeGenWriteBarrier((&___lastException_6), value);
}
};
struct ReactiveProperty_1_t1501562804_StaticFields
{
public:
// System.Collections.Generic.IEqualityComparer`1<T> UniRx.ReactiveProperty`1::defaultEqualityComparer
RuntimeObject* ___defaultEqualityComparer_0;
public:
inline static int32_t get_offset_of_defaultEqualityComparer_0() { return static_cast<int32_t>(offsetof(ReactiveProperty_1_t1501562804_StaticFields, ___defaultEqualityComparer_0)); }
inline RuntimeObject* get_defaultEqualityComparer_0() const { return ___defaultEqualityComparer_0; }
inline RuntimeObject** get_address_of_defaultEqualityComparer_0() { return &___defaultEqualityComparer_0; }
inline void set_defaultEqualityComparer_0(RuntimeObject* value)
{
___defaultEqualityComparer_0 = value;
Il2CppCodeGenWriteBarrier((&___defaultEqualityComparer_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REACTIVEPROPERTY_1_T1501562804_H
#ifndef LAZYTASK_T1721948414_H
#define LAZYTASK_T1721948414_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.LazyTask
struct LazyTask_t1721948414 : public RuntimeObject
{
public:
// UniRx.LazyTask/TaskStatus UniRx.LazyTask::<Status>k__BackingField
int32_t ___U3CStatusU3Ek__BackingField_0;
// UniRx.BooleanDisposable UniRx.LazyTask::cancellation
BooleanDisposable_t84760918 * ___cancellation_1;
public:
inline static int32_t get_offset_of_U3CStatusU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(LazyTask_t1721948414, ___U3CStatusU3Ek__BackingField_0)); }
inline int32_t get_U3CStatusU3Ek__BackingField_0() const { return ___U3CStatusU3Ek__BackingField_0; }
inline int32_t* get_address_of_U3CStatusU3Ek__BackingField_0() { return &___U3CStatusU3Ek__BackingField_0; }
inline void set_U3CStatusU3Ek__BackingField_0(int32_t value)
{
___U3CStatusU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_cancellation_1() { return static_cast<int32_t>(offsetof(LazyTask_t1721948414, ___cancellation_1)); }
inline BooleanDisposable_t84760918 * get_cancellation_1() const { return ___cancellation_1; }
inline BooleanDisposable_t84760918 ** get_address_of_cancellation_1() { return &___cancellation_1; }
inline void set_cancellation_1(BooleanDisposable_t84760918 * value)
{
___cancellation_1 = value;
Il2CppCodeGenWriteBarrier((&___cancellation_1), value);
}
};
struct LazyTask_t1721948414_StaticFields
{
public:
// System.Func`2<UniRx.LazyTask,UnityEngine.Coroutine> UniRx.LazyTask::<>f__am$cache0
Func_2_t2678796183 * ___U3CU3Ef__amU24cache0_2;
public:
inline static int32_t get_offset_of_U3CU3Ef__amU24cache0_2() { return static_cast<int32_t>(offsetof(LazyTask_t1721948414_StaticFields, ___U3CU3Ef__amU24cache0_2)); }
inline Func_2_t2678796183 * get_U3CU3Ef__amU24cache0_2() const { return ___U3CU3Ef__amU24cache0_2; }
inline Func_2_t2678796183 ** get_address_of_U3CU3Ef__amU24cache0_2() { return &___U3CU3Ef__amU24cache0_2; }
inline void set_U3CU3Ef__amU24cache0_2(Func_2_t2678796183 * value)
{
___U3CU3Ef__amU24cache0_2 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3Ef__amU24cache0_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // LAZYTASK_T1721948414_H
#ifndef BEHAVIOUR_T1437897464_H
#define BEHAVIOUR_T1437897464_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.Behaviour
struct Behaviour_t1437897464 : public Component_t1923634451
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BEHAVIOUR_T1437897464_H
#ifndef LOGENTRY_T1141507113_H
#define LOGENTRY_T1141507113_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.Diagnostics.LogEntry
struct LogEntry_t1141507113
{
public:
union
{
struct
{
// System.String UniRx.Diagnostics.LogEntry::<LoggerName>k__BackingField
String_t* ___U3CLoggerNameU3Ek__BackingField_0;
// UnityEngine.LogType UniRx.Diagnostics.LogEntry::<LogType>k__BackingField
int32_t ___U3CLogTypeU3Ek__BackingField_1;
// System.String UniRx.Diagnostics.LogEntry::<Message>k__BackingField
String_t* ___U3CMessageU3Ek__BackingField_2;
// System.DateTime UniRx.Diagnostics.LogEntry::<Timestamp>k__BackingField
DateTime_t3738529785 ___U3CTimestampU3Ek__BackingField_3;
// UnityEngine.Object UniRx.Diagnostics.LogEntry::<Context>k__BackingField
Object_t631007953 * ___U3CContextU3Ek__BackingField_4;
// System.Exception UniRx.Diagnostics.LogEntry::<Exception>k__BackingField
Exception_t * ___U3CExceptionU3Ek__BackingField_5;
// System.String UniRx.Diagnostics.LogEntry::<StackTrace>k__BackingField
String_t* ___U3CStackTraceU3Ek__BackingField_6;
// System.Object UniRx.Diagnostics.LogEntry::<State>k__BackingField
RuntimeObject * ___U3CStateU3Ek__BackingField_7;
};
uint8_t LogEntry_t1141507113__padding[1];
};
public:
inline static int32_t get_offset_of_U3CLoggerNameU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(LogEntry_t1141507113, ___U3CLoggerNameU3Ek__BackingField_0)); }
inline String_t* get_U3CLoggerNameU3Ek__BackingField_0() const { return ___U3CLoggerNameU3Ek__BackingField_0; }
inline String_t** get_address_of_U3CLoggerNameU3Ek__BackingField_0() { return &___U3CLoggerNameU3Ek__BackingField_0; }
inline void set_U3CLoggerNameU3Ek__BackingField_0(String_t* value)
{
___U3CLoggerNameU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CLoggerNameU3Ek__BackingField_0), value);
}
inline static int32_t get_offset_of_U3CLogTypeU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(LogEntry_t1141507113, ___U3CLogTypeU3Ek__BackingField_1)); }
inline int32_t get_U3CLogTypeU3Ek__BackingField_1() const { return ___U3CLogTypeU3Ek__BackingField_1; }
inline int32_t* get_address_of_U3CLogTypeU3Ek__BackingField_1() { return &___U3CLogTypeU3Ek__BackingField_1; }
inline void set_U3CLogTypeU3Ek__BackingField_1(int32_t value)
{
___U3CLogTypeU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CMessageU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(LogEntry_t1141507113, ___U3CMessageU3Ek__BackingField_2)); }
inline String_t* get_U3CMessageU3Ek__BackingField_2() const { return ___U3CMessageU3Ek__BackingField_2; }
inline String_t** get_address_of_U3CMessageU3Ek__BackingField_2() { return &___U3CMessageU3Ek__BackingField_2; }
inline void set_U3CMessageU3Ek__BackingField_2(String_t* value)
{
___U3CMessageU3Ek__BackingField_2 = value;
Il2CppCodeGenWriteBarrier((&___U3CMessageU3Ek__BackingField_2), value);
}
inline static int32_t get_offset_of_U3CTimestampU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(LogEntry_t1141507113, ___U3CTimestampU3Ek__BackingField_3)); }
inline DateTime_t3738529785 get_U3CTimestampU3Ek__BackingField_3() const { return ___U3CTimestampU3Ek__BackingField_3; }
inline DateTime_t3738529785 * get_address_of_U3CTimestampU3Ek__BackingField_3() { return &___U3CTimestampU3Ek__BackingField_3; }
inline void set_U3CTimestampU3Ek__BackingField_3(DateTime_t3738529785 value)
{
___U3CTimestampU3Ek__BackingField_3 = value;
}
inline static int32_t get_offset_of_U3CContextU3Ek__BackingField_4() { return static_cast<int32_t>(offsetof(LogEntry_t1141507113, ___U3CContextU3Ek__BackingField_4)); }
inline Object_t631007953 * get_U3CContextU3Ek__BackingField_4() const { return ___U3CContextU3Ek__BackingField_4; }
inline Object_t631007953 ** get_address_of_U3CContextU3Ek__BackingField_4() { return &___U3CContextU3Ek__BackingField_4; }
inline void set_U3CContextU3Ek__BackingField_4(Object_t631007953 * value)
{
___U3CContextU3Ek__BackingField_4 = value;
Il2CppCodeGenWriteBarrier((&___U3CContextU3Ek__BackingField_4), value);
}
inline static int32_t get_offset_of_U3CExceptionU3Ek__BackingField_5() { return static_cast<int32_t>(offsetof(LogEntry_t1141507113, ___U3CExceptionU3Ek__BackingField_5)); }
inline Exception_t * get_U3CExceptionU3Ek__BackingField_5() const { return ___U3CExceptionU3Ek__BackingField_5; }
inline Exception_t ** get_address_of_U3CExceptionU3Ek__BackingField_5() { return &___U3CExceptionU3Ek__BackingField_5; }
inline void set_U3CExceptionU3Ek__BackingField_5(Exception_t * value)
{
___U3CExceptionU3Ek__BackingField_5 = value;
Il2CppCodeGenWriteBarrier((&___U3CExceptionU3Ek__BackingField_5), value);
}
inline static int32_t get_offset_of_U3CStackTraceU3Ek__BackingField_6() { return static_cast<int32_t>(offsetof(LogEntry_t1141507113, ___U3CStackTraceU3Ek__BackingField_6)); }
inline String_t* get_U3CStackTraceU3Ek__BackingField_6() const { return ___U3CStackTraceU3Ek__BackingField_6; }
inline String_t** get_address_of_U3CStackTraceU3Ek__BackingField_6() { return &___U3CStackTraceU3Ek__BackingField_6; }
inline void set_U3CStackTraceU3Ek__BackingField_6(String_t* value)
{
___U3CStackTraceU3Ek__BackingField_6 = value;
Il2CppCodeGenWriteBarrier((&___U3CStackTraceU3Ek__BackingField_6), value);
}
inline static int32_t get_offset_of_U3CStateU3Ek__BackingField_7() { return static_cast<int32_t>(offsetof(LogEntry_t1141507113, ___U3CStateU3Ek__BackingField_7)); }
inline RuntimeObject * get_U3CStateU3Ek__BackingField_7() const { return ___U3CStateU3Ek__BackingField_7; }
inline RuntimeObject ** get_address_of_U3CStateU3Ek__BackingField_7() { return &___U3CStateU3Ek__BackingField_7; }
inline void set_U3CStateU3Ek__BackingField_7(RuntimeObject * value)
{
___U3CStateU3Ek__BackingField_7 = value;
Il2CppCodeGenWriteBarrier((&___U3CStateU3Ek__BackingField_7), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of UniRx.Diagnostics.LogEntry
struct LogEntry_t1141507113_marshaled_pinvoke
{
union
{
struct
{
char* ___U3CLoggerNameU3Ek__BackingField_0;
int32_t ___U3CLogTypeU3Ek__BackingField_1;
char* ___U3CMessageU3Ek__BackingField_2;
DateTime_t3738529785 ___U3CTimestampU3Ek__BackingField_3;
Object_t631007953_marshaled_pinvoke ___U3CContextU3Ek__BackingField_4;
Exception_t * ___U3CExceptionU3Ek__BackingField_5;
char* ___U3CStackTraceU3Ek__BackingField_6;
Il2CppIUnknown* ___U3CStateU3Ek__BackingField_7;
};
uint8_t LogEntry_t1141507113__padding[1];
};
};
// Native definition for COM marshalling of UniRx.Diagnostics.LogEntry
struct LogEntry_t1141507113_marshaled_com
{
union
{
struct
{
Il2CppChar* ___U3CLoggerNameU3Ek__BackingField_0;
int32_t ___U3CLogTypeU3Ek__BackingField_1;
Il2CppChar* ___U3CMessageU3Ek__BackingField_2;
DateTime_t3738529785 ___U3CTimestampU3Ek__BackingField_3;
Object_t631007953_marshaled_com* ___U3CContextU3Ek__BackingField_4;
Exception_t * ___U3CExceptionU3Ek__BackingField_5;
Il2CppChar* ___U3CStackTraceU3Ek__BackingField_6;
Il2CppIUnknown* ___U3CStateU3Ek__BackingField_7;
};
uint8_t LogEntry_t1141507113__padding[1];
};
};
#endif // LOGENTRY_T1141507113_H
#ifndef BOUNDSREACTIVEPROPERTY_T3308566424_H
#define BOUNDSREACTIVEPROPERTY_T3308566424_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.BoundsReactiveProperty
struct BoundsReactiveProperty_t3308566424 : public ReactiveProperty_1_t1501562804
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BOUNDSREACTIVEPROPERTY_T3308566424_H
#ifndef MONOBEHAVIOUR_T3962482529_H
#define MONOBEHAVIOUR_T3962482529_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UnityEngine.MonoBehaviour
struct MonoBehaviour_t3962482529 : public Behaviour_t1437897464
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MONOBEHAVIOUR_T3962482529_H
#ifndef MAINTHREADDISPATCHER_T3684499304_H
#define MAINTHREADDISPATCHER_T3684499304_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// UniRx.MainThreadDispatcher
struct MainThreadDispatcher_t3684499304 : public MonoBehaviour_t3962482529
{
public:
// UniRx.InternalUtil.ThreadSafeQueueWorker UniRx.MainThreadDispatcher::queueWorker
ThreadSafeQueueWorker_t2171548691 * ___queueWorker_3;
// System.Action`1<System.Exception> UniRx.MainThreadDispatcher::unhandledExceptionCallback
Action_1_t1609204844 * ___unhandledExceptionCallback_4;
// UniRx.InternalUtil.MicroCoroutine UniRx.MainThreadDispatcher::updateMicroCoroutine
MicroCoroutine_t3506682403 * ___updateMicroCoroutine_5;
// UniRx.InternalUtil.MicroCoroutine UniRx.MainThreadDispatcher::fixedUpdateMicroCoroutine
MicroCoroutine_t3506682403 * ___fixedUpdateMicroCoroutine_6;
// UniRx.InternalUtil.MicroCoroutine UniRx.MainThreadDispatcher::endOfFrameMicroCoroutine
MicroCoroutine_t3506682403 * ___endOfFrameMicroCoroutine_7;
// UniRx.Subject`1<UniRx.Unit> UniRx.MainThreadDispatcher::update
Subject_1_t3450905854 * ___update_12;
// UniRx.Subject`1<UniRx.Unit> UniRx.MainThreadDispatcher::lateUpdate
Subject_1_t3450905854 * ___lateUpdate_13;
// UniRx.Subject`1<System.Boolean> UniRx.MainThreadDispatcher::onApplicationFocus
Subject_1_t185944352 * ___onApplicationFocus_14;
// UniRx.Subject`1<System.Boolean> UniRx.MainThreadDispatcher::onApplicationPause
Subject_1_t185944352 * ___onApplicationPause_15;
// UniRx.Subject`1<UniRx.Unit> UniRx.MainThreadDispatcher::onApplicationQuit
Subject_1_t3450905854 * ___onApplicationQuit_16;
public:
inline static int32_t get_offset_of_queueWorker_3() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___queueWorker_3)); }
inline ThreadSafeQueueWorker_t2171548691 * get_queueWorker_3() const { return ___queueWorker_3; }
inline ThreadSafeQueueWorker_t2171548691 ** get_address_of_queueWorker_3() { return &___queueWorker_3; }
inline void set_queueWorker_3(ThreadSafeQueueWorker_t2171548691 * value)
{
___queueWorker_3 = value;
Il2CppCodeGenWriteBarrier((&___queueWorker_3), value);
}
inline static int32_t get_offset_of_unhandledExceptionCallback_4() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___unhandledExceptionCallback_4)); }
inline Action_1_t1609204844 * get_unhandledExceptionCallback_4() const { return ___unhandledExceptionCallback_4; }
inline Action_1_t1609204844 ** get_address_of_unhandledExceptionCallback_4() { return &___unhandledExceptionCallback_4; }
inline void set_unhandledExceptionCallback_4(Action_1_t1609204844 * value)
{
___unhandledExceptionCallback_4 = value;
Il2CppCodeGenWriteBarrier((&___unhandledExceptionCallback_4), value);
}
inline static int32_t get_offset_of_updateMicroCoroutine_5() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___updateMicroCoroutine_5)); }
inline MicroCoroutine_t3506682403 * get_updateMicroCoroutine_5() const { return ___updateMicroCoroutine_5; }
inline MicroCoroutine_t3506682403 ** get_address_of_updateMicroCoroutine_5() { return &___updateMicroCoroutine_5; }
inline void set_updateMicroCoroutine_5(MicroCoroutine_t3506682403 * value)
{
___updateMicroCoroutine_5 = value;
Il2CppCodeGenWriteBarrier((&___updateMicroCoroutine_5), value);
}
inline static int32_t get_offset_of_fixedUpdateMicroCoroutine_6() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___fixedUpdateMicroCoroutine_6)); }
inline MicroCoroutine_t3506682403 * get_fixedUpdateMicroCoroutine_6() const { return ___fixedUpdateMicroCoroutine_6; }
inline MicroCoroutine_t3506682403 ** get_address_of_fixedUpdateMicroCoroutine_6() { return &___fixedUpdateMicroCoroutine_6; }
inline void set_fixedUpdateMicroCoroutine_6(MicroCoroutine_t3506682403 * value)
{
___fixedUpdateMicroCoroutine_6 = value;
Il2CppCodeGenWriteBarrier((&___fixedUpdateMicroCoroutine_6), value);
}
inline static int32_t get_offset_of_endOfFrameMicroCoroutine_7() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___endOfFrameMicroCoroutine_7)); }
inline MicroCoroutine_t3506682403 * get_endOfFrameMicroCoroutine_7() const { return ___endOfFrameMicroCoroutine_7; }
inline MicroCoroutine_t3506682403 ** get_address_of_endOfFrameMicroCoroutine_7() { return &___endOfFrameMicroCoroutine_7; }
inline void set_endOfFrameMicroCoroutine_7(MicroCoroutine_t3506682403 * value)
{
___endOfFrameMicroCoroutine_7 = value;
Il2CppCodeGenWriteBarrier((&___endOfFrameMicroCoroutine_7), value);
}
inline static int32_t get_offset_of_update_12() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___update_12)); }
inline Subject_1_t3450905854 * get_update_12() const { return ___update_12; }
inline Subject_1_t3450905854 ** get_address_of_update_12() { return &___update_12; }
inline void set_update_12(Subject_1_t3450905854 * value)
{
___update_12 = value;
Il2CppCodeGenWriteBarrier((&___update_12), value);
}
inline static int32_t get_offset_of_lateUpdate_13() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___lateUpdate_13)); }
inline Subject_1_t3450905854 * get_lateUpdate_13() const { return ___lateUpdate_13; }
inline Subject_1_t3450905854 ** get_address_of_lateUpdate_13() { return &___lateUpdate_13; }
inline void set_lateUpdate_13(Subject_1_t3450905854 * value)
{
___lateUpdate_13 = value;
Il2CppCodeGenWriteBarrier((&___lateUpdate_13), value);
}
inline static int32_t get_offset_of_onApplicationFocus_14() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___onApplicationFocus_14)); }
inline Subject_1_t185944352 * get_onApplicationFocus_14() const { return ___onApplicationFocus_14; }
inline Subject_1_t185944352 ** get_address_of_onApplicationFocus_14() { return &___onApplicationFocus_14; }
inline void set_onApplicationFocus_14(Subject_1_t185944352 * value)
{
___onApplicationFocus_14 = value;
Il2CppCodeGenWriteBarrier((&___onApplicationFocus_14), value);
}
inline static int32_t get_offset_of_onApplicationPause_15() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___onApplicationPause_15)); }
inline Subject_1_t185944352 * get_onApplicationPause_15() const { return ___onApplicationPause_15; }
inline Subject_1_t185944352 ** get_address_of_onApplicationPause_15() { return &___onApplicationPause_15; }
inline void set_onApplicationPause_15(Subject_1_t185944352 * value)
{
___onApplicationPause_15 = value;
Il2CppCodeGenWriteBarrier((&___onApplicationPause_15), value);
}
inline static int32_t get_offset_of_onApplicationQuit_16() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304, ___onApplicationQuit_16)); }
inline Subject_1_t3450905854 * get_onApplicationQuit_16() const { return ___onApplicationQuit_16; }
inline Subject_1_t3450905854 ** get_address_of_onApplicationQuit_16() { return &___onApplicationQuit_16; }
inline void set_onApplicationQuit_16(Subject_1_t3450905854 * value)
{
___onApplicationQuit_16 = value;
Il2CppCodeGenWriteBarrier((&___onApplicationQuit_16), value);
}
};
struct MainThreadDispatcher_t3684499304_StaticFields
{
public:
// UniRx.MainThreadDispatcher/CullingMode UniRx.MainThreadDispatcher::cullingMode
int32_t ___cullingMode_2;
// UniRx.MainThreadDispatcher UniRx.MainThreadDispatcher::instance
MainThreadDispatcher_t3684499304 * ___instance_8;
// System.Boolean UniRx.MainThreadDispatcher::initialized
bool ___initialized_9;
// System.Boolean UniRx.MainThreadDispatcher::isQuitting
bool ___isQuitting_10;
// System.Action`1<System.Exception> UniRx.MainThreadDispatcher::<>f__am$cache0
Action_1_t1609204844 * ___U3CU3Ef__amU24cache0_17;
public:
inline static int32_t get_offset_of_cullingMode_2() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304_StaticFields, ___cullingMode_2)); }
inline int32_t get_cullingMode_2() const { return ___cullingMode_2; }
inline int32_t* get_address_of_cullingMode_2() { return &___cullingMode_2; }
inline void set_cullingMode_2(int32_t value)
{
___cullingMode_2 = value;
}
inline static int32_t get_offset_of_instance_8() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304_StaticFields, ___instance_8)); }
inline MainThreadDispatcher_t3684499304 * get_instance_8() const { return ___instance_8; }
inline MainThreadDispatcher_t3684499304 ** get_address_of_instance_8() { return &___instance_8; }
inline void set_instance_8(MainThreadDispatcher_t3684499304 * value)
{
___instance_8 = value;
Il2CppCodeGenWriteBarrier((&___instance_8), value);
}
inline static int32_t get_offset_of_initialized_9() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304_StaticFields, ___initialized_9)); }
inline bool get_initialized_9() const { return ___initialized_9; }
inline bool* get_address_of_initialized_9() { return &___initialized_9; }
inline void set_initialized_9(bool value)
{
___initialized_9 = value;
}
inline static int32_t get_offset_of_isQuitting_10() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304_StaticFields, ___isQuitting_10)); }
inline bool get_isQuitting_10() const { return ___isQuitting_10; }
inline bool* get_address_of_isQuitting_10() { return &___isQuitting_10; }
inline void set_isQuitting_10(bool value)
{
___isQuitting_10 = value;
}
inline static int32_t get_offset_of_U3CU3Ef__amU24cache0_17() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304_StaticFields, ___U3CU3Ef__amU24cache0_17)); }
inline Action_1_t1609204844 * get_U3CU3Ef__amU24cache0_17() const { return ___U3CU3Ef__amU24cache0_17; }
inline Action_1_t1609204844 ** get_address_of_U3CU3Ef__amU24cache0_17() { return &___U3CU3Ef__amU24cache0_17; }
inline void set_U3CU3Ef__amU24cache0_17(Action_1_t1609204844 * value)
{
___U3CU3Ef__amU24cache0_17 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3Ef__amU24cache0_17), value);
}
};
struct MainThreadDispatcher_t3684499304_ThreadStaticFields
{
public:
// System.Object UniRx.MainThreadDispatcher::mainThreadToken
RuntimeObject * ___mainThreadToken_11;
public:
inline static int32_t get_offset_of_mainThreadToken_11() { return static_cast<int32_t>(offsetof(MainThreadDispatcher_t3684499304_ThreadStaticFields, ___mainThreadToken_11)); }
inline RuntimeObject * get_mainThreadToken_11() const { return ___mainThreadToken_11; }
inline RuntimeObject ** get_address_of_mainThreadToken_11() { return &___mainThreadToken_11; }
inline void set_mainThreadToken_11(RuntimeObject * value)
{
___mainThreadToken_11 = value;
Il2CppCodeGenWriteBarrier((&___mainThreadToken_11), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MAINTHREADDISPATCHER_T3684499304_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2400 = { sizeof (U3CPeriodicActionU3Ec__Iterator1_t2287198350), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2400[8] =
{
U3CPeriodicActionU3Ec__Iterator1_t2287198350::get_offset_of_period_0(),
U3CPeriodicActionU3Ec__Iterator1_t2287198350::get_offset_of_cancellation_1(),
U3CPeriodicActionU3Ec__Iterator1_t2287198350::get_offset_of_action_2(),
U3CPeriodicActionU3Ec__Iterator1_t2287198350::get_offset_of_U3CelapsedU3E__1_3(),
U3CPeriodicActionU3Ec__Iterator1_t2287198350::get_offset_of_U3CdtU3E__1_4(),
U3CPeriodicActionU3Ec__Iterator1_t2287198350::get_offset_of_U24current_5(),
U3CPeriodicActionU3Ec__Iterator1_t2287198350::get_offset_of_U24disposing_6(),
U3CPeriodicActionU3Ec__Iterator1_t2287198350::get_offset_of_U24PC_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2401 = { sizeof (FixedUpdateMainThreadScheduler_t1759960949), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2402 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2402[6] =
{
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2403 = { sizeof (U3CDelayActionU3Ec__Iterator1_t3218606553), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2403[9] =
{
U3CDelayActionU3Ec__Iterator1_t3218606553::get_offset_of_dueTime_0(),
U3CDelayActionU3Ec__Iterator1_t3218606553::get_offset_of_cancellation_1(),
U3CDelayActionU3Ec__Iterator1_t3218606553::get_offset_of_action_2(),
U3CDelayActionU3Ec__Iterator1_t3218606553::get_offset_of_U3CstartTimeU3E__1_3(),
U3CDelayActionU3Ec__Iterator1_t3218606553::get_offset_of_U3CdtU3E__1_4(),
U3CDelayActionU3Ec__Iterator1_t3218606553::get_offset_of_U3CelapsedU3E__2_5(),
U3CDelayActionU3Ec__Iterator1_t3218606553::get_offset_of_U24current_6(),
U3CDelayActionU3Ec__Iterator1_t3218606553::get_offset_of_U24disposing_7(),
U3CDelayActionU3Ec__Iterator1_t3218606553::get_offset_of_U24PC_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2404 = { sizeof (U3CPeriodicActionU3Ec__Iterator2_t2169154091), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2404[10] =
{
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_period_0(),
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_cancellation_1(),
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_action_2(),
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_U3CstartTimeU3E__1_3(),
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_U3CdtU3E__1_4(),
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_U3CftU3E__2_5(),
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_U3CelapsedU3E__2_6(),
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_U24current_7(),
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_U24disposing_8(),
U3CPeriodicActionU3Ec__Iterator2_t2169154091::get_offset_of_U24PC_9(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2405 = { sizeof (EndOfFrameMainThreadScheduler_t3512639697), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2406 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2406[6] =
{
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2407 = { sizeof (U3CDelayActionU3Ec__Iterator1_t1566613126), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2407[8] =
{
U3CDelayActionU3Ec__Iterator1_t1566613126::get_offset_of_dueTime_0(),
U3CDelayActionU3Ec__Iterator1_t1566613126::get_offset_of_cancellation_1(),
U3CDelayActionU3Ec__Iterator1_t1566613126::get_offset_of_action_2(),
U3CDelayActionU3Ec__Iterator1_t1566613126::get_offset_of_U3CelapsedU3E__1_3(),
U3CDelayActionU3Ec__Iterator1_t1566613126::get_offset_of_U3CdtU3E__1_4(),
U3CDelayActionU3Ec__Iterator1_t1566613126::get_offset_of_U24current_5(),
U3CDelayActionU3Ec__Iterator1_t1566613126::get_offset_of_U24disposing_6(),
U3CDelayActionU3Ec__Iterator1_t1566613126::get_offset_of_U24PC_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2408 = { sizeof (U3CPeriodicActionU3Ec__Iterator2_t2292180132), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2408[8] =
{
U3CPeriodicActionU3Ec__Iterator2_t2292180132::get_offset_of_period_0(),
U3CPeriodicActionU3Ec__Iterator2_t2292180132::get_offset_of_cancellation_1(),
U3CPeriodicActionU3Ec__Iterator2_t2292180132::get_offset_of_action_2(),
U3CPeriodicActionU3Ec__Iterator2_t2292180132::get_offset_of_U3CelapsedU3E__1_3(),
U3CPeriodicActionU3Ec__Iterator2_t2292180132::get_offset_of_U3CdtU3E__1_4(),
U3CPeriodicActionU3Ec__Iterator2_t2292180132::get_offset_of_U24current_5(),
U3CPeriodicActionU3Ec__Iterator2_t2292180132::get_offset_of_U24disposing_6(),
U3CPeriodicActionU3Ec__Iterator2_t2292180132::get_offset_of_U24PC_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2409 = { sizeof (U3CScheduleU3Ec__AnonStorey0_t1246538827), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2409[5] =
{
U3CScheduleU3Ec__AnonStorey0_t1246538827::get_offset_of_action_0(),
U3CScheduleU3Ec__AnonStorey0_t1246538827::get_offset_of_scheduler_1(),
U3CScheduleU3Ec__AnonStorey0_t1246538827::get_offset_of_gate_2(),
U3CScheduleU3Ec__AnonStorey0_t1246538827::get_offset_of_group_3(),
U3CScheduleU3Ec__AnonStorey0_t1246538827::get_offset_of_recursiveAction_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2410 = { sizeof (U3CScheduleU3Ec__AnonStorey1_t2063910649), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2410[4] =
{
U3CScheduleU3Ec__AnonStorey1_t2063910649::get_offset_of_isAdded_0(),
U3CScheduleU3Ec__AnonStorey1_t2063910649::get_offset_of_d_1(),
U3CScheduleU3Ec__AnonStorey1_t2063910649::get_offset_of_isDone_2(),
U3CScheduleU3Ec__AnonStorey1_t2063910649::get_offset_of_U3CU3Ef__refU240_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2411 = { sizeof (U3CScheduleU3Ec__AnonStorey2_t1628875851), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2411[5] =
{
U3CScheduleU3Ec__AnonStorey2_t1628875851::get_offset_of_action_0(),
U3CScheduleU3Ec__AnonStorey2_t1628875851::get_offset_of_scheduler_1(),
U3CScheduleU3Ec__AnonStorey2_t1628875851::get_offset_of_gate_2(),
U3CScheduleU3Ec__AnonStorey2_t1628875851::get_offset_of_group_3(),
U3CScheduleU3Ec__AnonStorey2_t1628875851::get_offset_of_recursiveAction_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2412 = { sizeof (U3CScheduleU3Ec__AnonStorey3_t342939487), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2412[4] =
{
U3CScheduleU3Ec__AnonStorey3_t342939487::get_offset_of_isAdded_0(),
U3CScheduleU3Ec__AnonStorey3_t342939487::get_offset_of_d_1(),
U3CScheduleU3Ec__AnonStorey3_t342939487::get_offset_of_isDone_2(),
U3CScheduleU3Ec__AnonStorey3_t342939487::get_offset_of_U3CU3Ef__refU242_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2413 = { sizeof (U3CScheduleU3Ec__AnonStorey4_t481864779), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2413[5] =
{
U3CScheduleU3Ec__AnonStorey4_t481864779::get_offset_of_action_0(),
U3CScheduleU3Ec__AnonStorey4_t481864779::get_offset_of_scheduler_1(),
U3CScheduleU3Ec__AnonStorey4_t481864779::get_offset_of_gate_2(),
U3CScheduleU3Ec__AnonStorey4_t481864779::get_offset_of_group_3(),
U3CScheduleU3Ec__AnonStorey4_t481864779::get_offset_of_recursiveAction_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2414 = { sizeof (U3CScheduleU3Ec__AnonStorey5_t849780234), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2414[4] =
{
U3CScheduleU3Ec__AnonStorey5_t849780234::get_offset_of_isAdded_0(),
U3CScheduleU3Ec__AnonStorey5_t849780234::get_offset_of_d_1(),
U3CScheduleU3Ec__AnonStorey5_t849780234::get_offset_of_isDone_2(),
U3CScheduleU3Ec__AnonStorey5_t849780234::get_offset_of_U3CU3Ef__refU244_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2415 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2416 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2417 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2418 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2419 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2419[7] =
{
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2420 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2420[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2421 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2421[6] =
{
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2422 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2422[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2423 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2424 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2425 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2426 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2426[10] =
{
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2427 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2427[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2428 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2428[5] =
{
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2429 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2429[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2430 = { sizeof (SubjectExtensions_t2134319452), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2431 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2431[2] =
{
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2432 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2433 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2434 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2435 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2436 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2437 = { sizeof (OptimizedObservableExtensions_t1647498745), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2438 = { 0, 0, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2439 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2439[1] =
{
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2440 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2441 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2442 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2443 = { sizeof (Tuple_t1757971014), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2444 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2444[8] =
{
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2445 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2445[1] =
{
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2446 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2446[2] =
{
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2447 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2447[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2448 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2448[4] =
{
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2449 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2449[5] =
{
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2450 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2450[6] =
{
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2451 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2451[7] =
{
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2452 = { sizeof (Unit_t3362249467)+ sizeof (RuntimeObject), sizeof(Unit_t3362249467 ), sizeof(Unit_t3362249467_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2452[1] =
{
Unit_t3362249467_StaticFields::get_offset_of_default_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2453 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2453[2] =
{
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2454 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2454[2] =
{
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2455 = { sizeof (Timestamped_t555880859), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2456 = { sizeof (AotSafeExtensions_t3690086409), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2457 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2457[6] =
{
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2458 = { sizeof (AsyncOperationExtensions_t103671278), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2459 = { sizeof (U3CAsObservableU3Ec__AnonStorey1_t2816429619), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2459[2] =
{
U3CAsObservableU3Ec__AnonStorey1_t2816429619::get_offset_of_asyncOperation_0(),
U3CAsObservableU3Ec__AnonStorey1_t2816429619::get_offset_of_progress_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2460 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2460[2] =
{
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2461 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2461[7] =
{
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2462 = { sizeof (CancellationToken_t1265546479)+ sizeof (RuntimeObject), -1, sizeof(CancellationToken_t1265546479_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2462[3] =
{
CancellationToken_t1265546479::get_offset_of_source_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
CancellationToken_t1265546479_StaticFields::get_offset_of_Empty_1(),
CancellationToken_t1265546479_StaticFields::get_offset_of_None_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2463 = { sizeof (LogEntry_t1141507113)+ sizeof (RuntimeObject), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2463[8] =
{
LogEntry_t1141507113::get_offset_of_U3CLoggerNameU3Ek__BackingField_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
LogEntry_t1141507113::get_offset_of_U3CLogTypeU3Ek__BackingField_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
LogEntry_t1141507113::get_offset_of_U3CMessageU3Ek__BackingField_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
LogEntry_t1141507113::get_offset_of_U3CTimestampU3Ek__BackingField_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
LogEntry_t1141507113::get_offset_of_U3CContextU3Ek__BackingField_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
LogEntry_t1141507113::get_offset_of_U3CExceptionU3Ek__BackingField_5() + static_cast<int32_t>(sizeof(RuntimeObject)),
LogEntry_t1141507113::get_offset_of_U3CStackTraceU3Ek__BackingField_6() + static_cast<int32_t>(sizeof(RuntimeObject)),
LogEntry_t1141507113::get_offset_of_U3CStateU3Ek__BackingField_7() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2464 = { sizeof (LogEntryExtensions_t2577791660), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2465 = { sizeof (Logger_t3861635025), -1, sizeof(Logger_t3861635025_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2465[4] =
{
Logger_t3861635025_StaticFields::get_offset_of_isInitialized_0(),
Logger_t3861635025_StaticFields::get_offset_of_isDebugBuild_1(),
Logger_t3861635025::get_offset_of_U3CNameU3Ek__BackingField_2(),
Logger_t3861635025::get_offset_of_logPublisher_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2466 = { sizeof (ObservableDebugExtensions_t2967164862), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2467 = { sizeof (ObservableLogger_t2665118834), -1, sizeof(ObservableLogger_t2665118834_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2467[2] =
{
ObservableLogger_t2665118834_StaticFields::get_offset_of_logPublisher_0(),
ObservableLogger_t2665118834_StaticFields::get_offset_of_Listener_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2468 = { sizeof (UnityDebugSink_t4250252982), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2469 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2469[2] =
{
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2470 = { sizeof (IntReactiveProperty_t3243525985), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2471 = { sizeof (LongReactiveProperty_t2823960147), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2472 = { sizeof (ByteReactiveProperty_t1600986847), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2473 = { sizeof (FloatReactiveProperty_t2159343209), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2474 = { sizeof (DoubleReactiveProperty_t3731678748), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2475 = { sizeof (StringReactiveProperty_t3302058057), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2476 = { sizeof (BoolReactiveProperty_t700220569), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2477 = { sizeof (Vector2ReactiveProperty_t1480206898), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2478 = { sizeof (Vector3ReactiveProperty_t1509712485), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2479 = { sizeof (Vector4ReactiveProperty_t1508944816), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2480 = { sizeof (ColorReactiveProperty_t3266332558), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2481 = { sizeof (RectReactiveProperty_t1528095736), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2482 = { sizeof (AnimationCurveReactiveProperty_t44630468), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2483 = { sizeof (BoundsReactiveProperty_t3308566424), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2484 = { sizeof (QuaternionReactiveProperty_t2539028965), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2485 = { sizeof (InspectorDisplayAttribute_t2165086330), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2485[2] =
{
InspectorDisplayAttribute_t2165086330::get_offset_of_U3CFieldNameU3Ek__BackingField_0(),
InspectorDisplayAttribute_t2165086330::get_offset_of_U3CNotifyPropertyChangedU3Ek__BackingField_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2486 = { sizeof (MultilineReactivePropertyAttribute_t2064446684), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2486[1] =
{
MultilineReactivePropertyAttribute_t2064446684::get_offset_of_U3CLinesU3Ek__BackingField_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2487 = { sizeof (RangeReactivePropertyAttribute_t2057313354), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2487[2] =
{
RangeReactivePropertyAttribute_t2057313354::get_offset_of_U3CMinU3Ek__BackingField_0(),
RangeReactivePropertyAttribute_t2057313354::get_offset_of_U3CMaxU3Ek__BackingField_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2488 = { sizeof (LazyTask_t1721948414), -1, sizeof(LazyTask_t1721948414_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable2488[3] =
{
LazyTask_t1721948414::get_offset_of_U3CStatusU3Ek__BackingField_0(),
LazyTask_t1721948414::get_offset_of_cancellation_1(),
LazyTask_t1721948414_StaticFields::get_offset_of_U3CU3Ef__amU24cache0_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2489 = { sizeof (TaskStatus_t4183509909)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2489[6] =
{
TaskStatus_t4183509909::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2490 = { sizeof (U3CWhenAllCoreU3Ec__Iterator0_t2684419830), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2490[7] =
{
U3CWhenAllCoreU3Ec__Iterator0_t2684419830::get_offset_of_coroutines_0(),
U3CWhenAllCoreU3Ec__Iterator0_t2684419830::get_offset_of_U24locvar0_1(),
U3CWhenAllCoreU3Ec__Iterator0_t2684419830::get_offset_of_U24locvar1_2(),
U3CWhenAllCoreU3Ec__Iterator0_t2684419830::get_offset_of_U3CitemU3E__1_3(),
U3CWhenAllCoreU3Ec__Iterator0_t2684419830::get_offset_of_U24current_4(),
U3CWhenAllCoreU3Ec__Iterator0_t2684419830::get_offset_of_U24disposing_5(),
U3CWhenAllCoreU3Ec__Iterator0_t2684419830::get_offset_of_U24PC_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2491 = { 0, 0, 0, 0 };
extern const int32_t g_FieldOffsetTable2491[3] =
{
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2492 = { sizeof (LazyTaskExtensions_t3183993102), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2493 = { sizeof (MainThreadDispatcher_t3684499304), -1, sizeof(MainThreadDispatcher_t3684499304_StaticFields), sizeof(MainThreadDispatcher_t3684499304_ThreadStaticFields) };
extern const int32_t g_FieldOffsetTable2493[16] =
{
MainThreadDispatcher_t3684499304_StaticFields::get_offset_of_cullingMode_2(),
MainThreadDispatcher_t3684499304::get_offset_of_queueWorker_3(),
MainThreadDispatcher_t3684499304::get_offset_of_unhandledExceptionCallback_4(),
MainThreadDispatcher_t3684499304::get_offset_of_updateMicroCoroutine_5(),
MainThreadDispatcher_t3684499304::get_offset_of_fixedUpdateMicroCoroutine_6(),
MainThreadDispatcher_t3684499304::get_offset_of_endOfFrameMicroCoroutine_7(),
MainThreadDispatcher_t3684499304_StaticFields::get_offset_of_instance_8(),
MainThreadDispatcher_t3684499304_StaticFields::get_offset_of_initialized_9(),
MainThreadDispatcher_t3684499304_StaticFields::get_offset_of_isQuitting_10(),
THREAD_STATIC_FIELD_OFFSET,
MainThreadDispatcher_t3684499304::get_offset_of_update_12(),
MainThreadDispatcher_t3684499304::get_offset_of_lateUpdate_13(),
MainThreadDispatcher_t3684499304::get_offset_of_onApplicationFocus_14(),
MainThreadDispatcher_t3684499304::get_offset_of_onApplicationPause_15(),
MainThreadDispatcher_t3684499304::get_offset_of_onApplicationQuit_16(),
MainThreadDispatcher_t3684499304_StaticFields::get_offset_of_U3CU3Ef__amU24cache0_17(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2494 = { sizeof (CullingMode_t3030417749)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2494[4] =
{
CullingMode_t3030417749::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2495 = { sizeof (U3CSendStartCoroutineU3Ec__AnonStorey3_t1416387401), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2495[1] =
{
U3CSendStartCoroutineU3Ec__AnonStorey3_t1416387401::get_offset_of_routine_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2496 = { sizeof (U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2496[4] =
{
U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799::get_offset_of_U24this_0(),
U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799::get_offset_of_U24current_1(),
U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799::get_offset_of_U24disposing_2(),
U3CRunUpdateMicroCoroutineU3Ec__Iterator0_t3229616799::get_offset_of_U24PC_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2497 = { sizeof (U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2497[4] =
{
U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234::get_offset_of_U24this_0(),
U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234::get_offset_of_U24current_1(),
U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234::get_offset_of_U24disposing_2(),
U3CRunFixedUpdateMicroCoroutineU3Ec__Iterator1_t4089570234::get_offset_of_U24PC_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2498 = { sizeof (U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable2498[4] =
{
U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078::get_offset_of_U24this_0(),
U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078::get_offset_of_U24current_1(),
U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078::get_offset_of_U24disposing_2(),
U3CRunEndOfFrameMicroCoroutineU3Ec__Iterator2_t4169616078::get_offset_of_U24PC_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize2499 = { sizeof (FrameCountType_t3331626185)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable2499[4] =
{
FrameCountType_t3331626185::get_offset_of_value___1() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
|
db0a0a7591778364d9656d234d87d11d160b22aa
|
2b849aa758ba3137e9ec6ea5858f4281ac637348
|
/src/world/objb/MtlBuilder.hpp
|
9c07d8c9aa9c2095bd27767bde4332a29830d4cb
|
[
"MIT"
] |
permissive
|
JiangKevin/ofxPlanet
|
9dd948f99e5395d5b6f482c4b219f8634b8d3fed
|
fe364e83f4c0ec0f169df63ce989a88ae6328c07
|
refs/heads/master
| 2022-12-05T10:47:36.047470
| 2020-03-02T01:56:58
| 2020-03-02T01:56:58
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,267
|
hpp
|
MtlBuilder.hpp
|
#pragma once
#ifndef WORLD_OBJB_MTLBUILDER_HPP
#define WORLD_OBJB_MTLBUILDER_HPP
#include <glm/glm.hpp>
#include <string>
#include <vector>
namespace ofxPlanet {
namespace objb {
/**
* MtlElement is material information.
*/
class MtlElement {
public:
explicit MtlElement(const std::string& name);
MtlElement& ns(float _ns);
MtlElement& ka(glm::vec3 _ka);
MtlElement& kd(glm::vec3 _kd);
MtlElement& ks(glm::vec3 _ks);
MtlElement& ke(glm::vec3 _ke);
MtlElement& ni(float _ni);
MtlElement& d(float _d);
MtlElement& illum(float _illum);
MtlElement& map_Kd(const std::string& _map_Kd);
std::string name;
float _ns;
glm::vec3 _ka;
glm::vec3 _kd;
glm::vec3 _ks;
glm::vec3 _ke;
float _ni;
float _d;
float _illum;
std::string _map_Kd;
};
/**
* MtlBuilder is helper class for material definition file.
*/
class MtlBuilder {
public:
explicit MtlBuilder();
~MtlBuilder();
MtlElement& newElement(const std::string& name);
std::string toString() const;
private:
std::vector<MtlElement*> elements;
};
} // namespace objb
} // namespace ofxPlanet
#endif
|
bda97c2644a481800581dc5766211a745cf6c881
|
5ce4f30b23fe55bfe4f1edab08e4625558536820
|
/staticScheduling/staticDecomposition.hpp
|
391186785f9bf3dc44146f42e44b07dd942bf7f7
|
[] |
no_license
|
rajuramj/Dynamic-Task-Scheduling
|
113b3df28c1eb9a0453be7aa80a9fb419223f414
|
896332134b181c954e64ce57fb3325a2fd823e63
|
refs/heads/master
| 2023-06-11T08:50:41.618427
| 2021-06-12T14:35:22
| 2021-06-12T14:35:22
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,024
|
hpp
|
staticDecomposition.hpp
|
/**
header file: staticDecompostion.hpp
Purpose: to declare class variables and member functions of StaticDecompostion class
@author Raju Ram
@version 1.0 04/07/18
*/
#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
#include <cstdlib> // for size_t
#include <utility> // std::pair
#ifndef STDEC_H
#define STDEC_H
class StaticDecompostion
{
private:
size_t niters;
size_t nthreads;
size_t ntasks;
bool toBePinned;
std::vector<double> task_cycles;
std::vector<std::pair <size_t, size_t >> taskInds;
// output synchronisation
std::mutex cout_mutex;
public:
StaticDecompostion(size_t niters, size_t nthreads, size_t ntasks);
void setThreadTaskMap();
void setTaskCycles(double avgCycles, double dev);
inline void pinThreadOnSocket(size_t thread_id);
// /inline void pinMainThread();
//debug version
void sleepCycles (double nCycles, size_t taskid);
void sleepCycles (double nCycles);
void runAllTasks();
~StaticDecompostion();
};
#endif // STDEC_H
|
56ac61ccf60b374c28ae61acfb5446120ea779ff
|
02130234c005b6506b42d76ab92f209f5597143b
|
/2016 Plan/数据结构代码/第5章 数组和广义表/bo5-3.cpp
|
957034a5037b7b0b93c234b9d765a2bdb45b3fdc
|
[
"Apache-2.0"
] |
permissive
|
qinting513/Learning-QT
|
ccc08e09f8657fcf10583a9782961d764280bb8d
|
c7ed7a39c75d47bee7eb614d6e65018323c7ca93
|
refs/heads/master
| 2020-05-23T06:25:37.362918
| 2016-12-23T11:03:29
| 2016-12-23T11:03:29
| 70,233,226
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 753
|
cpp
|
bo5-3.cpp
|
// bo5-3.cpp 三元组稀疏矩阵的基本操作(4个)，也可用于行逻辑链接结构
void DestroySMatrix(TSMatrix &M)
{
M.mu=M.nu=M.tu=0;
}
void PrintSMatrix(TSMatrix M)
{
int i,j,k=1;
Triple *p=M.data+1;
for(i=1;i<=M.mu;i++)
{ for(j=1;j<=M.nu;j++)
if(k<=M.tu&&p->i==i&&p->j==j)
{ printf("%3d",(p++)->e);
k++;
}
else
printf("%3d",0);
printf("\n");
}
}
void CopySMatrix(TSMatrix M,TSMatrix &T)
{
T=M;
}
Status SubtSMatrix(TSMatrix M,TSMatrix N,TSMatrix &Q)
{
int i;
if(M.mu!=N.mu||M.nu!=N.nu)
return ERROR;
for(i=1;i<=N.tu;++i)
N.data[i].e*=-1;
AddSMatrix(M,N,Q);
return OK;
}
|
4faceab2aa42f95d3fd17c36151c1b77e664d7ed
|
e7a792081e9371c243295df2a5f1852b3552e156
|
/Billiard Bubble/Classes/UI/Level.cpp
|
af15d94be5b05ed46044533059a94b1b330e0575
|
[] |
no_license
|
DustinJia/Alliance-Warfare
|
7ed2fadcad6a52a15dbe34ec2b91b6d558dcf6ea
|
e444d0c90a6b888b9552e0ef2bdf4cfd81a955cd
|
refs/heads/master
| 2021-01-01T15:44:36.385929
| 2015-11-04T21:47:22
| 2015-11-04T21:47:22
| 23,674,619
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 29,379
|
cpp
|
Level.cpp
|
#include "Level.h"
#include "Menu.h"
#include "World.h"
#include "Interface.h"
#include "SimpleAudioEngine.h"
using namespace CocosDenshion;
CCScene* Level::scene()
{
CCScene* scene = CCScene::create();
Level* layer = Level::create();
scene->addChild(layer);
return scene;
}
bool Level::init()
{
if (!CCLayer::init()) {
return false;
}
/*预加载音效*/
SimpleAudioEngine::sharedEngine()->preloadEffect("confirm.mp3");
/*添加背景*/
CCSize size = CCDirector::sharedDirector()->getWinSize();
CCSprite* spBackGround = CCSprite::create("levelBackground.png");
spBackGround->setPosition(ccp(size.width*0.5, size.height*0.5));
addChild(spBackGround);
/*创建图片菜单项*/
CCMenuItemImage *item1 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel1));
CCMenuItemImage *item2 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel2));
CCMenuItemImage *item3 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel3));
CCMenuItemImage *item4 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel4));
CCMenuItemImage *item5 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel5));
/*创建返回菜单项*/
CCMenuItemImage *itemBack = CCMenuItemImage::create("display_back.png", "display_back.png", this, menu_selector(Level::backToMenu));;
/*设置菜单项大小*/
item1->setScale(0.45);
item2->setScale(0.45);
item3->setScale(0.45);
item4->setScale(0.45);
item5->setScale(0.45);
/*创建菜单*/
CCMenu* menu1 = CCMenu::create(item1, item2, item3, item4, item5, NULL);
menu1->setPosition(ccp(size.width * 0.5, size.height * 0.55));
menu1->alignItemsHorizontallyWithPadding(70);
CCMenu* menuBack = CCMenu::create(itemBack, NULL);
addChild(menuBack);
menuBack->setPosition(ccp(size.width * 0.36, size.height * 0.05));
menuBack->setScale(0.7);
menuBack->setColor(ccc3(0, 32, 240));
/*创建图片菜单项*/
CCMenuItemImage *item6 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel6));
CCMenuItemImage *item7 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel7));
CCMenuItemImage *item8 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel8));
CCMenuItemImage *item9 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel9));
CCMenuItemImage *item10 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel10));
/*设置菜单项大小*/
item6->setScale(0.45);
item7->setScale(0.45);
item8->setScale(0.45);
item9->setScale(0.45);
item10->setScale(0.45);
/*创建菜单*/
CCMenu* menu2 = CCMenu::create(item6, item7, item8, item9, item10, NULL);
menu2->setPosition(ccp(size.width * 1.5, size.height * 0.55));
menu2->alignItemsHorizontallyWithPadding(70);
/*-----------------------*/
/*创建图片菜单项*/
CCMenuItemImage *item11 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel11));
CCMenuItemImage *item12 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel12));
CCMenuItemImage *item13 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel13));
CCMenuItemImage *item14 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel14));
CCMenuItemImage *item15 = CCMenuItemImage::create("level_normal.png", "level_selected.png", this, menu_selector(Level::chooseLevel15));
/*设置菜单项大小*/
item11->setScale(0.45);
item12->setScale(0.45);
item13->setScale(0.45);
item14->setScale(0.45);
item15->setScale(0.45);
/*创建菜单*/
CCMenu* menu3 = CCMenu::create(item11, item12, item13, item14, item15, NULL);
menu3->setPosition(ccp(size.width * 2.5, size.height * 0.55));
menu3->alignItemsHorizontallyWithPadding(70);
/*添加关卡锁*/
lock2 = CCSprite::create("lock.png");
lock3 = CCSprite::create("lock.png");
lock4 = CCSprite::create("lock.png");
lock5 = CCSprite::create("lock.png");
lock6 = CCSprite::create("lock.png");
lock7 = CCSprite::create("lock.png");
lock8 = CCSprite::create("lock.png");
lock9 = CCSprite::create("lock.png");
lock10 = CCSprite::create("lock.png");
lock11 = CCSprite::create("lock.png");
lock12 = CCSprite::create("lock.png");
lock13 = CCSprite::create("lock.png");
lock14 = CCSprite::create("lock.png");
lock15 = CCSprite::create("lock.png");
item2->addChild(lock2);
item3->addChild(lock3);
item4->addChild(lock4);
item5->addChild(lock5);
item6->addChild(lock6);
item7->addChild(lock7);
item8->addChild(lock8);
item9->addChild(lock9);
item10->addChild(lock10);
item11->addChild(lock11);
item12->addChild(lock12);
item13->addChild(lock13);
item14->addChild(lock14);
item15->addChild(lock15);
addLock();
//创建层容器
CCLayer * containLayer = CCLayer::create();
containLayer->addChild(menu1);
containLayer->addChild(menu2);
containLayer->addChild(menu3);
containLayer->setContentSize(CCSizeMake(size.width * 4, size.height));
/*添加关数*/
CCLabelTTF* level1 = CCLabelTTF::create("1st", "Georgia-Bold", 45);
CCLabelTTF* level2 = CCLabelTTF::create("2nd", "Georgia-Bold", 45);
CCLabelTTF* level3 = CCLabelTTF::create("3rd", "Georgia-Bold", 45);
CCLabelTTF* level4 = CCLabelTTF::create("4th", "Georgia-Bold", 45);
CCLabelTTF* level5 = CCLabelTTF::create("5th", "Georgia-Bold", 45);
CCLabelTTF* level6 = CCLabelTTF::create("6th", "Georgia-Bold", 45);
CCLabelTTF* level7 = CCLabelTTF::create("7th", "Georgia-Bold", 45);
CCLabelTTF* level8 = CCLabelTTF::create("8th", "Georgia-Bold", 45);
CCLabelTTF* level9 = CCLabelTTF::create("9th", "Georgia-Bold", 45);
CCLabelTTF* level10 = CCLabelTTF::create("10th", "Georgia-Bold", 45);
CCLabelTTF* level11 = CCLabelTTF::create("11th", "Georgia-Bold", 45);
CCLabelTTF* level12 = CCLabelTTF::create("12th", "Georgia-Bold", 45);
CCLabelTTF* level13 = CCLabelTTF::create("13th", "Georgia-Bold", 45);
CCLabelTTF* level14 = CCLabelTTF::create("14th", "Georgia-Bold", 45);
CCLabelTTF* level15 = CCLabelTTF::create("15th", "Georgia-Bold", 45);
containLayer->addChild(level1);
containLayer->addChild(level2);
containLayer->addChild(level3);
containLayer->addChild(level4);
containLayer->addChild(level5);
containLayer->addChild(level6);
containLayer->addChild(level7);
containLayer->addChild(level8);
containLayer->addChild(level9);
containLayer->addChild(level10);
containLayer->addChild(level11);
containLayer->addChild(level12);
containLayer->addChild(level13);
containLayer->addChild(level14);
containLayer->addChild(level15);
level1->setPosition(ccp(size.width * 0.18, size.height * 0.4));
level2->setPosition(ccp(size.width * 0.34, size.height * 0.4));
level3->setPosition(ccp(size.width * 0.5, size.height * 0.4));
level4->setPosition(ccp(size.width * 0.657, size.height * 0.4));
level5->setPosition(ccp(size.width * 0.82, size.height * 0.4));
level6->setPosition(ccp(size.width * 1.18, size.height * 0.4));
level7->setPosition(ccp(size.width * 1.34, size.height * 0.4));
level8->setPosition(ccp(size.width * 1.5, size.height * 0.4));
level9->setPosition(ccp(size.width * 1.657, size.height * 0.4));
level10->setPosition(ccp(size.width * 1.82, size.height * 0.4));
level11->setPosition(ccp(size.width * 2.18, size.height * 0.4));
level12->setPosition(ccp(size.width * 2.34, size.height * 0.4));
level13->setPosition(ccp(size.width * 2.5, size.height * 0.4));
level14->setPosition(ccp(size.width * 2.657, size.height * 0.4));
level15->setPosition(ccp(size.width * 2.82, size.height * 0.4));
/*创建滚动视图*/
scrollView = CCScrollView::create(CCSizeMake(size.width*3, size.height));
addChild(scrollView);
scrollView->setBounceable(false);//设置scrollview有弹跳效果(默认为true)
scrollView->setViewSize(CCSizeMake(size.width*2, size.height));//设置scrollView尺寸
scrollView->setContainer(containLayer);//设置容器
scrollView->getViewSize();//获取视图尺寸
scrollView->setTouchEnabled(true);//开启监听多触点
scrollView->setDelegate(this);//注册监听
return true;
}
#pragma mark - 关卡锁
void Level::addLock()
{
lock2->setScale(0.09);
lock3->setScale(0.09);
lock4->setScale(0.09);
lock5->setScale(0.09);
lock6->setScale(0.09);
lock7->setScale(0.09);
lock8->setScale(0.09);
lock9->setScale(0.09);
lock10->setScale(0.09);
lock11->setScale(0.09);
lock12->setScale(0.09);
lock13->setScale(0.09);
lock14->setScale(0.09);
lock15->setScale(0.09);
lock2->setPosition(ccp(220, 40));
lock3->setPosition(ccp(220, 40));
lock4->setPosition(ccp(220, 40));
lock5->setPosition(ccp(220, 40));
lock6->setPosition(ccp(220, 40));
lock7->setPosition(ccp(220, 40));
lock8->setPosition(ccp(220, 40));
lock9->setPosition(ccp(220, 40));
lock10->setPosition(ccp(220, 40));
lock11->setPosition(ccp(220, 40));
lock12->setPosition(ccp(220, 40));
lock13->setPosition(ccp(220, 40));
lock14->setPosition(ccp(220, 40));
lock15->setPosition(ccp(220, 40));
}
void Level::save()
{
CCUserDefault::sharedUserDefault()->setBoolForKey("leve2", ifLock2);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve3", ifLock3);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve4", ifLock4);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve5", ifLock5);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve6", ifLock6);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve7", ifLock7);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve8", ifLock8);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve9", ifLock9);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve10", ifLock10);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve11", ifLock11);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve12", ifLock12);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve13", ifLock13);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve14", ifLock14);
CCUserDefault::sharedUserDefault()->setBoolForKey("leve15", ifLock15);
CCUserDefault::sharedUserDefault()->flush();
}
void Level::read()
{
ifLock2 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve2", true);
ifLock3 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve3", true);
ifLock4 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve4", true);
ifLock5 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve5", true);
ifLock6 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve6", true);
ifLock7 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve7", true);
ifLock8 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve8", true);
ifLock9 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve9", true);
ifLock10 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve10", true);
ifLock11 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve11", true);
ifLock12 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve12", true);
ifLock13 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve13", true);
ifLock14 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve14", true);
ifLock15 = CCUserDefault::sharedUserDefault()->getBoolForKey("leve15",true);
level = CCUserDefault::sharedUserDefault()->getIntegerForKey("level1", 1);
}
void Level::set()
{
/*设置BOOL值*/
switch (level) {
case 1:
ifLock2 = true;
ifLock3 = true;
ifLock4 = true;
ifLock5 = true;
ifLock6 = true;
ifLock7 = true;
ifLock8 = true;
ifLock9 = true;
ifLock10 = true;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 2:
ifLock2 = false;
ifLock3 = true;
ifLock4 = true;
ifLock5 = true;
ifLock6 = true;
ifLock7 = true;
ifLock8 = true;
ifLock9 = true;
ifLock10 = true;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 3:
ifLock2 = false;
ifLock3 = false;
ifLock4 = true;
ifLock5 = true;
ifLock6 = true;
ifLock7 = true;
ifLock8 = true;
ifLock9 = true;
ifLock10 = true;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 4:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = true;
ifLock6 = true;
ifLock7 = true;
ifLock8 = true;
ifLock9 = true;
ifLock10 = true;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 5:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = true;
ifLock7 = true;
ifLock8 = true;
ifLock9 = true;
ifLock10 = true;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 6:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = true;
ifLock8 = true;
ifLock9 = true;
ifLock10 = true;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 7:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = false;
ifLock8 = true;
ifLock9 = true;
ifLock10 = true;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 8:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = false;
ifLock8 = false;
ifLock9 = true;
ifLock10 = true;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 9:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = false;
ifLock8 = false;
ifLock9 = false;
ifLock10 = true;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 10:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = false;
ifLock8 = false;
ifLock9 = false;
ifLock10 = false;
ifLock11 = true;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 11:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = false;
ifLock8 = false;
ifLock9 = false;
ifLock10 = false;
ifLock11 = false;
ifLock12 = true;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 12:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = false;
ifLock8 = false;
ifLock9 = false;
ifLock10 = false;
ifLock11 = false;
ifLock12 = false;
ifLock13 = true;
ifLock14 = true;
ifLock15 = true;
break;
case 13:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = false;
ifLock8 = false;
ifLock9 = false;
ifLock10 = false;
ifLock11 = false;
ifLock12 = false;
ifLock13 = false;
ifLock14 = true;
ifLock15 = true;
break;
case 14:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = false;
ifLock8 = false;
ifLock9 = false;
ifLock10 = false;
ifLock11 = false;
ifLock12 = false;
ifLock13 = false;
ifLock14 = false;
ifLock15 = true;
break;
case 15:
ifLock2 = false;
ifLock3 = false;
ifLock4 = false;
ifLock5 = false;
ifLock6 = false;
ifLock7 = false;
ifLock8 = false;
ifLock9 = false;
ifLock10 = false;
ifLock11 = false;
ifLock12 = false;
ifLock13 = false;
ifLock14 = false;
ifLock15 = false;
break;
default:
break;
}
/*设置可见*/
if (ifLock2) {
lock2->setVisible(true);
}
else if (!ifLock2) {
lock2->setVisible(false);
}
if (ifLock3) {
lock3->setVisible(true);
}
else if (!ifLock3) {
lock3->setVisible(false);
}
if (ifLock4) {
lock4->setVisible(true);
}
else if (!ifLock4) {
lock4->setVisible(false);
}
if (ifLock5) {
lock5->setVisible(true);
}
else if (!ifLock5) {
lock5->setVisible(false);
}
if (ifLock6) {
lock6->setVisible(true);
}
else if (!ifLock6) {
lock6->setVisible(false);
}
if (ifLock7) {
lock7->setVisible(true);
}
else if (!ifLock7) {
lock7->setVisible(false);
}
if (ifLock8) {
lock8->setVisible(true);
}
else if (!ifLock8) {
lock8->setVisible(false);
}
if (ifLock9) {
lock9->setVisible(true);
}
else if (!ifLock9) {
lock9->setVisible(false);
}
if (ifLock10) {
lock10->setVisible(true);
}
else if (!ifLock10) {
lock10->setVisible(false);
}
if (ifLock11) {
lock11->setVisible(true);
}
else if (!ifLock11) {
lock11->setVisible(false);
}
if (ifLock12) {
lock12->setVisible(true);
}
else if (!ifLock12) {
lock12->setVisible(false);
}
if (ifLock13) {
lock13->setVisible(true);
}
else if (!ifLock13) {
lock13->setVisible(false);
}
if (ifLock14) {
lock14->setVisible(true);
}
else if (!ifLock14) {
lock14->setVisible(false);
}
if (ifLock15) {
lock15->setVisible(true);
}
else if (!ifLock15) {
lock15->setVisible(false);
}
}
#pragma mark - 选关
void Level::chooseLevel1()
{
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 1;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
void Level::chooseLevel2()
{
if (level >= 2) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 2;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel3()
{
if (level >= 3) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 3;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel4()
{
if (level >= 4) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 4;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel5()
{
if (level >= 5) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 5;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel6()
{
if (level >= 6) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 6;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel7()
{
if (level >= 7) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 7;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel8()
{
if (level >= 8) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 8;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel9()
{
if (level >= 9) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 9;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel10()
{
if (level >= 10) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 10;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel11()
{
if (level >= 11) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 11;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel12()
{
if (level >= 12) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 12;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel13()
{
if (level >= 13) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 13;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel14()
{
if (level >= 14) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 14;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::chooseLevel15()
{
if (level >= 1) {
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到游戏场景*/
Interface::sharedInterface()->level1 = 15;
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1, World::scene()));
}
}
void Level::backToMenu()
{
/*播放音效*/
if (Interface::sharedInterface()->ifPlayEffect) {
SimpleAudioEngine::sharedEngine()->playEffect("confirm.mp3");
}
/*切换到主菜单场景*/
CCDirector::sharedDirector()->replaceScene(CCTransitionFade::create(1.5, Menu::scene()));
}
#pragma mark - 触摸事件
bool Level::ccTouchBegan(cocos2d::CCTouch* pTouch, cocos2d::CCEvent* pEvent)
{
return true;
}
void Level::ccTouchEnded(cocos2d::CCTouch* pTouch, cocos2d::CCEvent* pEvent)
{
adjustScrollView();
}
#pragma mark - 滚动视图相关
void Level::scrollViewDidScroll(CCScrollView* view){
}
void Level::scrollViewDidZoom(CCScrollView* view){
}
void Level::ccTouchCancelled(cocos2d::CCTouch *pTouch, cocos2d::CCEvent *pEvent)
{
adjustScrollView();
}
void Level::adjustScrollView()
{
CCSize size = CCDirector::sharedDirector()->getWinSize();
// 关闭CCScrollView中的自调整
scrollView->unscheduleAllSelectors();
int x =scrollView->getContentOffset().x;
int offset = (int) x % (int)(size.width);
static bool ifSlided = false;
// 调整位置
CCPoint adjustPos;
// 调整动画时间
float adjustAnimDelay;
// 向右滑动是正向左滑动是负
if (offset < -100 && !ifSlided)
{
// 计算下一页位置，时间
adjustPos =
ccpSub(scrollView->getContentOffset(), ccp((int)(size.width) + offset, 0));
adjustAnimDelay = (float) (1136 +offset) / 1500;
ifSlided = true;
}
else if(offset < -100 && ifSlided){
// 计算当前页位置，时间
adjustPos =ccpSub(scrollView->getContentOffset(), ccp(offset, 0));
// 这里要取绝对值，否则在第一页往左翻动的时，保证adjustAnimDelay为正数
adjustAnimDelay = (float) abs(offset) /1500;
ifSlided = false;
}
// 调整位置
adjustPos.y = 0;
scrollView->setContentOffsetInDuration(adjustPos,adjustAnimDelay);
}
#pragma mark - 生命周期相关
void Level::onEnter()
{
read();
set();
CCDirector::sharedDirector()->getTouchDispatcher()->addTargetedDelegate(this, 10, true);
CCLayer::onEnter();
}
void Level::onExit()
{
save();
CCDirector::sharedDirector()->getTouchDispatcher()->removeDelegate(this);
CCLayer::onExit();
}
|
ccb35f8074da128510e7deff6e322db8dacb9626
|
ea13d5b49631b3fd8b528eea8abf9c754c15ab28
|
/src/connect.cpp
|
f7eaaec8df877774dfb607cc87f3f38f2dc9ebf2
|
[] |
no_license
|
TheBestLogic/QNX_Resource_Manadger
|
5757869d5564b894d801cc5b99e622fc32eb7573
|
d5db128a4f666013318b38bc907a9c619e788fed
|
refs/heads/master
| 2021-04-06T11:05:00.731807
| 2018-03-21T14:23:53
| 2018-03-21T14:23:53
| 125,324,159
| 1
| 0
| null | null | null | null |
WINDOWS-1251
|
C++
| false
| false
| 5,166
|
cpp
|
connect.cpp
|
#include "connect.h"
using namespace std;
using namespace DataSend;
//extern DoConnect doConn;
void DoConnect::CreateIN()
{
/*
* resmgr_attr_t resmgr_attr_IN;
dispatch_t *dpp_IN;
dispatch_context_t *ctp_IN;
int id_IN;
static resmgr_connect_funcs_t connect_funcs_IN;
static resmgr_io_funcs_t io_funcs_IN;
static iofunc_attr_t attr_IN;
throw "\"\" - failed";
*/
// инициализация интерфейса диспетчеризации
if ((dpp_IN = dispatch_create()) == NULL)
{
throw "\"dpp_IN = dispatch_create()\" - failed";
}
// инициализация атрибутов менеджера
memset(&resmgr_attr_IN, 0, sizeof resmgr_attr_IN);
resmgr_attr_IN.nparts_max = 1;
resmgr_attr_IN.msg_max_size = 2048;
// инициализация таблиц функций обработчиков
iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect_funcs_IN,_RESMGR_IO_NFUNCS, &io_funcs_IN);
// здесь нами дописан всего один обработчик - операции read,
// все остальное делается менеджером по умолчанию!
io_funcs_IN.read = prior_read;//must be my read function
// инициализация атрибутной структуры, используемой
// устройством.
iofunc_attr_init(&attr_IN, S_IFNAM | 0666, 0, 0);
// здесь создается путевое имя для менеджера
id_IN = resmgr_attach(dpp_IN, &resmgr_attr_IN, "/dev/prior_IN", _FTYPE_ANY, 0, &connect_funcs_IN, &io_funcs_IN, &attr_IN);
if (id_IN == -1)
throw "\"id = resmgr_attach(dpp_IN, &resmgr_attr_IN, \"/dev/prior_IN\", _FTYPE_ANY, 0, &connect_funcs_IN, &io_funcs_IN, &attr_IN)\" - failed";
ctp_IN = dispatch_context_alloc(dpp_IN);
}
void DoConnect::CreateOUT()
{
// инициализация интерфейса диспетчеризации
if ((dpp_OUT = dispatch_create()) == NULL)
{
throw "\"dpp_OUT = dispatch_create()\" - failed";
}
// инициализация атрибутов менеджера
memset(&resmgr_attr_OUT, 0, sizeof resmgr_attr_OUT);
resmgr_attr_OUT.nparts_max = 1;
resmgr_attr_OUT.msg_max_size = 2048;
// инициализация таблиц функций обработчиков
iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect_funcs_OUT,_RESMGR_IO_NFUNCS, &io_funcs_OUT);
// здесь нами дописан всего один обработчик - операции read,
// все остальное делается менеджером по умолчанию!
io_funcs_OUT.write = prior_write;//must be my write function
// инициализация атрибутной структуры, используемой
// устройством.
iofunc_attr_init(&attr_OUT, S_IFNAM | 0666, 0, 0);
// здесь создается путевое имя для менеджера
id_OUT = resmgr_attach(dpp_OUT, &resmgr_attr_OUT, "/dev/prior_OUT", _FTYPE_ANY, 0, &connect_funcs_OUT, &io_funcs_OUT, &attr_OUT);
if (id_OUT == -1)
throw "\"id = resmgr_attach(dpp_OUT, &resmgr_attr_OUT, \"/dev/prior_OUT\", _FTYPE_ANY, 0, &connect_funcs_OUT, &io_funcs_OUT, &attr_OUT)\" - failed";
ctp_OUT = dispatch_context_alloc(dpp_OUT);
}
DoConnect::DoConnect()
{
DoConnect::CreateIN();
DoConnect::CreateOUT();
}
DoConnect::~DoConnect()
{
}
int prior_write(resmgr_context_t *ctp, io_read_t *t,RESMGR_OCB_T *ocb)
{
static bool odd = true;
int status = iofunc_write_verify(ctp, msg, ocb, NULL);
if (status != EOK)
return status;
/*if (msg->i.xtype & _IO_XTYPE_MASK != _ID_XTYPE_NONE)
return ENOSYS;*/
if (odd)
{
struct sched_param param;
sched_getparam(0, ¶m);
MsgReply(ctp->rcvid, strlen(rbuf) + 1, rbuf, strlen(rbuf) + 1);//MsgRead
}
else
MsgReply(ctp->rcvid, EOK, NULL, 0);
odd = !odd;
return _RESMGR_NOREPLY;
}
int prior_read(resmgr_context_t *ctp, io_write_t *t, RESMGR_OCB_T *ocb)
{
string str = doConn.D->SendData();
static bool odd = true;
/*if (msg->i.xtype & _IO_XTYPE_MASK != _ID_XTYPE_NONE)
return ENOSYS;*/
if (odd)
{
if( MsgSend( ctp->rcvid, &str, str.length(), NULL, 0 ) == -1 )
{
fprintf( stderr, "Unable to MsgSend() to server: %s\n", strerror( errno ) );
return EXIT_FAILURE;
}
}
else
MsgReply(ctp->rcvid, EOK, NULL, 0);
//
odd = !odd;
return _RESMGR_NOREPLY;
}
int DoConnect::threadOut()
{
while( 1 )
{
ctp_ret_OUT = dispatch_block( ctp_OUT );
if( ctp_ret_OUT )
{
dispatch_handler( ctp_OUT );
}
else
{
fprintf( stderr, "dispatch_block() failed: %s\n",
strerror( errno ) );
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
int DoConnect::threadIn()
{
while( 1 )
{
ctp_ret_IN = dispatch_block( ctp_IN );
if( ctp_ret_IN )
{
dispatch_handler( ctp_IN );
}
else
{
fprintf( stderr, "dispatch_block() failed: %s\n",
strerror( errno ) );
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
|
cec09aa7c082e7753a7212a974283c257c6f14fb
|
271c4daa096c020fe57072a30251b10ccd7112f5
|
/element.h
|
cb10e55f4e96081adc296a6d0efba06d1e7110c0
|
[] |
no_license
|
adriaanwm/485L3
|
adedf0440839d1496c90024baa16138eb9e180d0
|
72132dc4e8b86a3280397b63c099fea3e4b01cab
|
refs/heads/master
| 2016-08-12T07:40:18.547424
| 2016-02-28T03:07:11
| 2016-02-28T03:07:11
| 51,561,659
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 406
|
h
|
element.h
|
#ifndef ELEMENT_H_
#define ELEMENT_H_
#include <vector>
#include <iostream>
using namespace std;
struct element {
element() : touched(false), lowerCounts(0) {}
vector<int> upperLex;
vector<int> upperCover;
vector<int> lowerCover;
int lowerCounts;
bool touched;
int key;
int lex;
};
void dump(vector<element> elements);
void dump(element e);
void dump(vector<int> v);
#endif /* ELEMENT_H_ */
|
bc00918ffdf586a383f271909d87a3a7995251fa
|
9edcbf2646ff38ca2b85b8c45332e8b7806ee28c
|
/Headsoccer/class.h
|
400b5d0cdf108c0b1dbea6ca9169cfaeb7f2bfb4
|
[] |
no_license
|
anhtuanng689/roboKick
|
4aa79c8411e67cecdc12e501abdae996a24dd418
|
969422069d30ce0811eab924d1f02ce6e21cdf27
|
refs/heads/master
| 2021-02-13T11:50:24.232384
| 2020-03-03T17:11:06
| 2020-03-03T17:11:06
| 244,694,060
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 269
|
h
|
class.h
|
#ifndef CLASS_H_INCLUDED
#define CLASS_H_INCLUDED
#include <string>
#include <SDL.h>
class Painter{
float x;
float y;
float angle;
int width;
int height;
SDL_Color color;
SDL_Renderer* renderer;
#endif // CLASS_H_INCLUDED
|
1408bda73b0373ffd2bac89320d44667e3c3f9cc
|
0243726f2168b61895ec23d1b1314aa4d968c925
|
/client/TaskQueue.h
|
e9fbc8a34bf6fb9d47a7f47bad35291c8e992473
|
[] |
no_license
|
3F/FlightSDC.RPC-WebSockets
|
6eae6b2349c0d39efb7e65018af3746080fcd97c
|
fa73c59aa5de8e6bba0f1fc9e9062c40d339ae18
|
refs/heads/master
| 2021-01-21T08:12:18.221113
| 2013-07-07T16:03:11
| 2013-08-05T14:47:09
| 68,389,120
| 1
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,674
|
h
|
TaskQueue.h
|
/*
* Copyright (C) 2001-2011 Jacek Sieka, arnetheduck on gmail point com
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef DCPLUSPLUS_DCPP_TASK_H
#define DCPLUSPLUS_DCPP_TASK_H
#include "Thread.h"
namespace dcpp
{
struct Task
{
virtual ~Task() { }
};
struct StringTask : public Task
{
StringTask(const string& str_) : str(str_) { }
const string str;
};
class TaskQueue
{
public:
typedef pair<uint8_t, unique_ptr<Task>> Pair;
typedef vector<Pair> List;
typedef List::const_iterator Iter;
TaskQueue()
{
}
~TaskQueue()
{
clear();
}
void add(uint8_t type, std::unique_ptr<Task> && data)
{
Lock l(cs);
tasks.push_back(make_pair(type, move(data)));
}
void get(List& list)
{
Lock l(cs);
swap(tasks, list);
}
void clear()
{
Lock l(cs); //[+]PPA
List tmp;
get(tmp);
}
private:
TaskQueue(const TaskQueue&);
TaskQueue& operator=(const TaskQueue&);
CriticalSection cs;
List tasks;
};
} // namespace dcpp
#endif
|
8ae5a7516277acbb3ee0efb8f6b062233e4ad5f4
|
48d64302d5873a404c299f271ecd9ee20d7d810e
|
/Game structure/combat_handler.h
|
d93816ceddcda8a278e496b6a0d4a593632f10be
|
[] |
no_license
|
MFA8CL/OOP-Text-based-adventure-game-in-c-for-PHYS30672
|
bf57b5ab59c54ef7e3a05385264d30dbff82485b
|
50a6b97a4b2b9fdc0793d50767a0daba05346a9e
|
refs/heads/main
| 2023-07-02T19:22:46.267707
| 2021-08-11T16:57:38
| 2021-08-11T16:57:38
| 395,045,577
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 188
|
h
|
combat_handler.h
|
#pragma once
#include "Enemy.h"
#include "player.h"
#include <conio.h>
class combat_handler
{public:
combat_handler();
~combat_handler();
int fight(enemy &e, player &p);
};
|
91e3586c5a1519de4c0e386b998d14541809f867
|
d0fb46aecc3b69983e7f6244331a81dff42d9595
|
/cassandra/src/model/DescribeBackupsResult.cc
|
60e88596168f4b702b46cb7be7ff663dfb737bf0
|
[
"Apache-2.0"
] |
permissive
|
aliyun/aliyun-openapi-cpp-sdk
|
3d8d051d44ad00753a429817dd03957614c0c66a
|
e862bd03c844bcb7ccaa90571bceaa2802c7f135
|
refs/heads/master
| 2023-08-29T11:54:00.525102
| 2023-08-29T03:32:48
| 2023-08-29T03:32:48
| 115,379,460
| 104
| 82
|
NOASSERTION
| 2023-09-14T06:13:33
| 2017-12-26T02:53:27
|
C++
|
UTF-8
|
C++
| false
| false
| 2,460
|
cc
|
DescribeBackupsResult.cc
|
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/cassandra/model/DescribeBackupsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Cassandra;
using namespace AlibabaCloud::Cassandra::Model;
DescribeBackupsResult::DescribeBackupsResult() :
ServiceResult()
{}
DescribeBackupsResult::DescribeBackupsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeBackupsResult::~DescribeBackupsResult()
{}
void DescribeBackupsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allBackupsNode = value["Backups"]["Backup"];
for (auto valueBackupsBackup : allBackupsNode)
{
Backup backupsObject;
if(!valueBackupsBackup["ClusterId"].isNull())
backupsObject.clusterId = valueBackupsBackup["ClusterId"].asString();
if(!valueBackupsBackup["DataCenterId"].isNull())
backupsObject.dataCenterId = valueBackupsBackup["DataCenterId"].asString();
if(!valueBackupsBackup["BackupId"].isNull())
backupsObject.backupId = valueBackupsBackup["BackupId"].asString();
if(!valueBackupsBackup["BackupType"].isNull())
backupsObject.backupType = valueBackupsBackup["BackupType"].asString();
if(!valueBackupsBackup["Status"].isNull())
backupsObject.status = valueBackupsBackup["Status"].asString();
if(!valueBackupsBackup["StartTime"].isNull())
backupsObject.startTime = valueBackupsBackup["StartTime"].asString();
if(!valueBackupsBackup["EndTime"].isNull())
backupsObject.endTime = valueBackupsBackup["EndTime"].asString();
if(!valueBackupsBackup["Size"].isNull())
backupsObject.size = std::stol(valueBackupsBackup["Size"].asString());
backups_.push_back(backupsObject);
}
}
std::vector<DescribeBackupsResult::Backup> DescribeBackupsResult::getBackups()const
{
return backups_;
}
|
177ea48ea28231f7cc75c03ef365ecb59efe801f
|
bc77b4119832adf303644d8d0a6b92aa752b5f8e
|
/An-Introduction-to-Programming-the-Internet-of-Things-(IOT)-Specialization/3. Interfacing with the Arduino/Week 3/Assignment.ino
|
087e6566785a52c2ca7546928d4fa3985f19cd2b
|
[] |
no_license
|
dhankhar313/Coursera-Courses
|
e20f3b57d115cb870b451e8f4d8914c2272cb2a2
|
1f5324d57172b7a1d0798d3c7b6f8cb4cf5e91ce
|
refs/heads/master
| 2023-08-11T18:54:51.255866
| 2021-10-03T10:45:53
| 2021-10-03T10:45:53
| 293,840,411
| 1
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 736
|
ino
|
Assignment.ino
|
#include <EEPROM.h>
void setup()
{
Serial.begin(9600);
}
void loop()
{
String buffer = "";
buffer = Serial.readString();
int address, data;
if (buffer.startsWith("read"))
{
address = buffer.substring(buffer.indexOf(' ') + 1).toInt();
Serial.print("Data:");
Serial.print(address);
Serial.println();
Serial.println(EEPROM.read(address));
}
else if (buffer.startsWith("write"))
{
address = buffer.substring(6, 7).toInt();
data = buffer.substring(8).toInt();
Serial.print("Address:");
Serial.print(data);
Serial.println();
Serial.print(address);
Serial.println();
EEPROM.write(address, data);
}
}
|
e98c0097fe4da567131bde787d3729bf07698690
|
b7e65ae41a8e46f1344da84b9510e5903286280d
|
/9012.cpp
|
5a5a2ec9e6aa12972eed84142db00470d26f4644
|
[] |
no_license
|
RulLu16/baekjoon_problems
|
f0af80befba4b3ca47170d88001780a547dad141
|
594fb9a6f176f2c07da5343b4a2e6c80af6a3056
|
refs/heads/master
| 2021-11-20T21:12:42.553246
| 2021-10-06T06:22:35
| 2021-10-06T06:22:35
| 232,083,648
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 576
|
cpp
|
9012.cpp
|
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
int main(){
int t;
char temp;
int flag=0;
vector <char> v;
scanf("%d",&t);
getchar();
for(int i=0;i<t;i++){
while(1){
scanf("%1c",&temp);
if(temp=='('){
v.push_back(temp);
}
else if(temp==')'){
if(!v.empty()){
v.pop_back();
}
else{
flag=1;
}
}
else{
//getchar();
if(v.empty() && flag==0){
printf("YES\n");
}
else{
printf("NO\n");
}
break;
}
}
v.clear();
flag=0;
}
}
|
98127240c383847aba8edb6cb2e00184bff8e822
|
970aba56d1c56bcd88aca3dee72bdf46369af69d
|
/stack/linkedStack/linkedStack.h
|
54e09c6bd3836792fa97e4c543c9bc4c525d38e7
|
[] |
no_license
|
zagreos/DataStructure
|
e370327552fbc675040e180c138733df8cc68773
|
b5b8afbc47d457e248e8d3918f6506777f205efb
|
refs/heads/master
| 2023-04-09T19:12:38.558069
| 2020-05-01T15:49:03
| 2020-05-01T15:49:03
| null | 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 1,285
|
h
|
linkedStack.h
|
#pragma once
#include <iostream>
#include <sstream>
#include <string>
#include "myExceptions.h"
#include "stack.h"
#include "ChainNode.h"
template <typename T>
class linkedStack : public stack<T> {
public:
linkedStack(int initial_capacity = 10) {
stackTop == NULL;
stackSize == 0;
};
~linkedStack();
// ADT
bool empty() const { return stackSize == 0; };
int size() const { return stackSize; };
T& top() const {
if (stackSize == 0) throw stackEmpty();
return stackTop->element;
};
void pop();
void push(const T& the_element) {
stackTop = new chainNode<T>(the_element, stackTop);
stackSize++;
}
protected:
chainNode<T>* stackTop; // 栈顶指针
int stackSize; // 栈元素个数
};
template<typename T>
void linkedStack<T>::pop() {
if (stackSize == 0) {
throw stackEmpty();
}
chainNode<T>* nextNode = stackTop->next;
delete
[] stackTop; // 删除放中间，避免没有删除成功又令指针指向新的地方造成内存泄漏
stackTop = nextNode;
stackSize--;
};
template<typename T>
linkedStack<T>::~linkedStack() {
while (stackTop != NULL) {
chainNode<T>* nextNode = stackTop->next;
delete stackTop;
stackTop = nextNode;
}
};
|
b41584577ce6026cbfe7cb91ed276ecc23f0c6c2
|
8e6b39024c7a4b6e3447e737046f83a31bcf4fa9
|
/src/pigmain.cpp
|
f44a8aef38ee17078b1702522b49f31d4e628b0b
|
[] |
no_license
|
guptha-/birdypigs3
|
f33ebfb3208c8f76bf7391e97af43fdfd9bafd8b
|
f5aea869afcdd2ec513876898dc8b56b8063eb89
|
refs/heads/master
| 2020-03-30T00:48:11.709665
| 2013-05-07T19:24:14
| 2013-05-07T19:24:14
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,101
|
cpp
|
pigmain.cpp
|
/*==============================================================================
*
* Filename: pigmain.cpp
*
* Description: This starts off the pig's execution
*
* =============================================================================
*/
#include "../inc/piginc.h"
OwnStruct ownNode;
vector<OtherStruct> otherVector;
mutex otherVectorLock;
atomic<unsigned short int> birdPosn;
atomic<unsigned short int> landCount;
/* === FUNCTION ==============================================================
* Name: listenerFlow
* Description: The pig listens for incoming messages here
* =============================================================================
*/
static void listenerFlow ()
{
UDPSocket listenSocket (COM_IP_ADDR, ownNode.port);
while (true) {
// Block for msg receipt
int inMsgSize;
char *inMsg;
inMsg = new char[MAX_MSG_SIZE]();
try {
inMsgSize = listenSocket.recv(inMsg, MAX_MSG_SIZE);
} catch (SocketException &e) {
cout<<ownNode.port<<": "<<e.what()<<endl;
}
inMsg[inMsgSize] = '\0';
thread handlerThread (pigMsgHandler, inMsgSize, inMsg);
handlerThread.detach();
}
} /* ----- end of function listenerFlow ----- */
/* === FUNCTION ==============================================================
* Name: main
* Description: The pig's execution starts here
* =============================================================================
*/
int main (int argc, char *argv[])
{
if (argc < 2) {
cout<<"Invalid number of arguments to pig"<<endl;
return EXIT_FAILURE;
}
ownNode.port = atoi(argv[1]);
srand(time(NULL) * ownNode.port);
otherVectorLock.lock();
for (int iter = 2; iter < argc; iter++) {
OtherStruct otherNode;
otherNode.port = atoi(argv[iter]);
otherNode.posn = 0;
otherVector.push_back(otherNode);
}
otherVectorLock.unlock();
// Listen on incoming port for messages
thread handlerThread(listenerFlow);
handlerThread.join();
return EXIT_SUCCESS;
} /* ---------- end of function main ---------- */
|
464a1a866986d262c111e4703bf9e39ee7ae8237
|
7c8d05c31133dfebeb2be46c3ac4cbc532c903e3
|
/source/pbr_demo/command_sort_key_generators.cpp
|
0d6c8ecd8621e02983511765967cffd5971e4651
|
[
"LicenseRef-scancode-warranty-disclaimer",
"Apache-2.0"
] |
permissive
|
iCodeIN/thehalflingproject
|
0a2c9fb3599560863050af2309688ae1b1e9f8bf
|
dd3c322f3ede8935766de6a85d438602e7c27887
|
refs/heads/master
| 2022-02-24T07:50:40.370283
| 2019-09-08T23:19:42
| 2019-09-08T23:19:42
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,688
|
cpp
|
command_sort_key_generators.cpp
|
/* The Halfling Project - A Graphics Engine and Projects
*
* The Halfling Project is the legal property of Adrian Astley
* Copyright Adrian Astley 2013 - 2014
*/
#include "pbr_demo/command_sort_key_generators.h"
namespace PBRDemo {
uint64 GBufferSortKeyGenerator::GenerateKey(Graphics::MaterialShader *materialShader, const Scene::Material *material, ID3D11Buffer *vertexBuffer, ID3D11Buffer *indexBuffer) {
uint16 materialShaderKey;
uint16 materialKey;
uint16 vertexBufferKey;
uint16 indexBufferKey;
{
auto iter = m_materialShaderMap.find(materialShader);
if (iter != m_materialShaderMap.end()) {
materialShaderKey = iter->second;
} else {
materialShaderKey = m_materialShaderMap.size();
m_materialShaderMap[materialShader] = materialShaderKey;
}
}
{
auto iter = m_materialMap.find(material);
if (iter != m_materialMap.end()) {
materialKey = iter->second;
} else {
materialKey = m_materialMap.size();
m_materialMap[material] = materialKey;
}
}
{
auto iter = m_vertexBufferMap.find(vertexBuffer);
if (iter != m_vertexBufferMap.end()) {
vertexBufferKey = iter->second;
} else {
vertexBufferKey = m_vertexBufferMap.size();
m_vertexBufferMap[vertexBuffer] = vertexBufferKey;
}
}
{
auto iter = m_indexBufferMap.find(indexBuffer);
if (iter != m_indexBufferMap.end()) {
indexBufferKey = iter->second;
} else {
indexBufferKey = m_indexBufferMap.size();
m_indexBufferMap[indexBuffer] = indexBufferKey;
}
}
return ((uint64)materialShaderKey << 52) |
((uint64)materialKey << 40) |
((uint64)vertexBufferKey << 28) |
((uint64)indexBufferKey << 16);
}
} // End of namespace PBRDemo
|
c1ff4a0ad9f65ba248c84a5f0246bc434c378eaa
|
bf85d279332f0f54759919ffe366813038962f6c
|
/dwarfdecorator.h
|
ed9e308926beb5c4c646035060225a97f0cf1b21
|
[] |
no_license
|
KarinaSang/simple-rogue-like
|
5412d19b5b9ae05620f040eac104c18550760fa6
|
493e4aadfb2b7953efac199beb5d2ec5952d08a9
|
refs/heads/master
| 2022-03-18T10:32:59.907519
| 2019-12-09T20:35:55
| 2019-12-09T20:35:55
| 198,051,458
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 237
|
h
|
dwarfdecorator.h
|
#ifndef DWARFDECORATOR_H
#define DWARFDECORATOR_H
#include "playerdecorator.h"
class DwarfDecorator : public PlayerDecorator{
public:
DwarfDecorator(shared_ptr <Player> p): PlayerDecorator{p}{}
void addGold(int) override;
};
#endif
|
405f4b9ce253dddb7df5eade2fe9728605a12e97
|
4a73b9fe1290e4a5c579c50c6f293fcbdabc3f04
|
/day04/ex03/ClassIce.hpp
|
c61cef7085d039fa283310149d8a53032c905423
|
[] |
no_license
|
dimashipicyn/cppStudy
|
a87ed51db107f21f51e718746cabf358fe02a368
|
f3ef4bf1d2e237d474d848afdbe8418fede0410f
|
refs/heads/main
| 2023-08-29T06:56:11.821326
| 2021-10-06T09:03:59
| 2021-10-06T09:03:59
| 393,662,844
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 365
|
hpp
|
ClassIce.hpp
|
//
// Created by Lajuana Bespin on 9/10/21.
//
#ifndef CPPSTUDY_CLASSICE_HPP
#define CPPSTUDY_CLASSICE_HPP
#include "ClassAMateria.hpp"
#include "ClassICharacter.hpp"
class Ice : public AMateria {
public:
Ice();
virtual ~Ice();
virtual AMateria *clone() const;
virtual void use(ICharacter &target);
};
#endif //CPPSTUDY_CLASSICE_HPP
|
ff9ffd574833a337b71f3a7f48921214490af830
|
d7d32d142dbd8af66bc9e7e59096286eae0b08c3
|
/example/chat/ChatClient.h
|
b99799f88e60d075140f302082328b53e13f8f2f
|
[] |
no_license
|
xiaoqiangkx/dio
|
272ecb419abb40c77c77a0e19b5071b45785aa4c
|
edfe8514d8bc2b38d473214aaadb0d7480b9fd34
|
refs/heads/master
| 2020-05-21T23:54:53.338158
| 2016-09-27T17:11:44
| 2016-09-27T17:11:44
| 65,309,999
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 796
|
h
|
ChatClient.h
|
//
// Created by parallels on 9/25/16.
//
#ifndef PROJECT_CHATCLIENT_H
#define PROJECT_CHATCLIENT_H
#include <boost/core/noncopyable.hpp>
#include <dio/net/LengthHeaderCodec.h>
#include <dio/net/TcpClient.h>
#include <dio/net/InetAddress.h>
#include <dio/base/Callbacks.h>
namespace dio {
class EventLoop;
class ChatClient : public boost::noncopyable {
public:
ChatClient(EventLoop *loop, const InetAddress& address);
void start();
void send(const std::string&);
private:
EventLoop *loop_;
TcpClient tcpClient_;
LengthHeaderCodec codec_;
dio::net::TcpConnectionPtr connection_;
void onConnection(const dio::net::TcpConnectionPtr&);
void onMessage(const dio::net::TcpConnectionPtr&, const std::string&, Timestamp);
};
};
#endif //PROJECT_CHATCLIENT_H
|
64676c746eef23df1ef91d677307b67114613aac
|
1597c85e9178c9a703ee46056da7d354d717b38e
|
/src/queryinstrument.cpp
|
a6103924a8309141f0a23e7f6e56ffd77968b279
|
[] |
no_license
|
ciobaca/rmt-from-2019
|
de7a09b3cd3e82fe2d00a1f08f3be141ea5958c8
|
ccb24939fd30c11a9f9871f55567dc15b21c3e16
|
refs/heads/master
| 2020-06-18T02:38:13.886074
| 2019-07-16T12:57:01
| 2019-07-16T12:57:01
| 196,138,485
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,529
|
cpp
|
queryinstrument.cpp
|
#include "queryinstrument.h"
#include "parse.h"
#include "factories.h"
#include "z3driver.h"
#include "log.h"
#include <iostream>
#include <string>
#include <map>
#include <cassert>
using namespace std;
QueryInstrument::QueryInstrument()
{
}
Query *QueryInstrument::create()
{
return new QueryInstrument();
}
void QueryInstrument::parse(std::string &s, int &w)
{
matchString(s, w, "instrument");
skipWhiteSpace(s, w);
rewriteSystemName = getIdentifier(s, w);
skipWhiteSpace(s, w);
newSystemName = getIdentifier(s, w);
skipWhiteSpace(s, w);
oldStateSortName = getIdentifier(s, w);
skipWhiteSpace(s, w);
newStateSortName = getIdentifier(s, w);
skipWhiteSpace(s, w);
protectFunctionName = getIdentifier(s, w);
skipWhiteSpace(s, w);
matchString(s, w, ";");
}
bool QueryInstrument::initialize() {
if (!existsConstrainedRewriteSystem(rewriteSystemName) && !existsRewriteSystem(rewriteSystemName)) {
Log(ERROR) << "Could not find constrained rewrite system " << rewriteSystemName << " (neigher regular or constrained)" << endl;
return false;
}
if (existsConstrainedRewriteSystem(newSystemName) || existsRewriteSystem(newSystemName)) {
Log(ERROR) << "There already exists a (constrained) rewrite system with name " << newSystemName << "." << endl;
return false;
}
if (!sortExists(oldStateSortName)) {
Log(ERROR) << "Sort of configurations " << oldStateSortName << " does not exist." << endl;
return false;
}
if (!sortExists(newStateSortName)) {
Log(ERROR) << "Sort of new configurations " << newStateSortName << " does not exist." << endl;
return false;
}
protectFunction = getFunction(protectFunctionName);
if (!protectFunction) {
Log(ERROR) << "Function symbol" << protectFunctionName << " does not exist." << endl;
return false;
}
if (protectFunction->hasInterpretation) {
Log(ERROR) << "Function symbol" << protectFunctionName << " should be uninterpreted." << endl;
return false;
}
{
bool flag = true;
if (protectFunction->arguments.size() != 2) flag = false;
else if (protectFunction->arguments[0] != getSort(oldStateSortName)) flag = false;
else if (protectFunction->arguments[1] != getIntSort()) flag = false;
else if (protectFunction->result != getSort(newStateSortName)) flag = false;
if (!flag) {
Log(ERROR) << "Function symbol" << protectFunctionName << " is not of the appropriate arity." << endl;
return false;
}
}
Variable *protectVariable = createFreshVariable(getIntSort());
leftSideProtection = getVarTerm(protectVariable);
{
vector<Term*> arguments;
arguments.push_back(leftSideProtection);
arguments.push_back(getIntOneConstant());
rightSideProtection = getFunTerm(getMinusFunction(), arguments);
}
{
vector<Term*> arguments;
arguments.push_back(leftSideProtection);
arguments.push_back(getIntZeroConstant());
naturalNumberConstraint = bNot(getFunTerm(getLEFunction(), arguments));
}
return true;
}
void QueryInstrument::addRuleFromOldRule(ConstrainedRewriteSystem &nrs, Term *leftTerm, Term *leftConstraint, Term *rightTerm) {
vector<Term*> arguments;
if (leftTerm->getSort() == getSort(oldStateSortName)) {
arguments.push_back(leftTerm);
arguments.push_back(leftSideProtection);
leftTerm = getFunTerm(protectFunction, arguments);
leftConstraint = bAnd(leftConstraint, naturalNumberConstraint);
}
if (rightTerm->getSort() == getSort(oldStateSortName)) {
arguments.clear();
arguments.push_back(rightTerm);
arguments.push_back(rightSideProtection);
rightTerm = getFunTerm(protectFunction, arguments);
}
nrs.addRule(ConstrainedTerm(leftTerm, leftConstraint), rightTerm);
}
void QueryInstrument::buildNewRewriteSystem() {
ConstrainedRewriteSystem nrs;
ConstrainedRewriteSystem rs =
existsConstrainedRewriteSystem(rewriteSystemName) ?
getConstrainedRewriteSystem(rewriteSystemName) :
ConstrainedRewriteSystem(getRewriteSystem(rewriteSystemName));
for (const auto &it : rs)
addRuleFromOldRule(nrs, it.first.term, it.first.constraint, it.second);
putConstrainedRewriteSystem(newSystemName, nrs);
}
void QueryInstrument::execute()
{
if (!initialize())
return;
buildNewRewriteSystem();
ConstrainedRewriteSystem &testrs = getConstrainedRewriteSystem(newSystemName);
for (const auto &it : testrs) {
cout << it.first.term->toString() << " /\\ " << it.first.constraint->toString() << " => " <<
it.second->toString() << endl;
}
}
|
28a8c26ebe9192b2d2ec749815a2860daa0234a8
|
9dd29d031493354d594ca73c2e2dbbd2c048597f
|
/third_party/vss/GoogleVssAgent/util.cpp
|
9824afa5a35340fddde87c1c7df87fb639a9d8e3
|
[
"Apache-2.0",
"LicenseRef-scancode-generic-cla",
"LicenseRef-scancode-unknown-license-reference",
"MS-LPL",
"LicenseRef-scancode-unknown"
] |
permissive
|
GoogleCloudPlatform/compute-image-windows
|
d28a5b150a8bd6e2cbc78edffb72ab5c5c59fde3
|
9706dcff5d5e6000121aac48ff11aaf5a1ee7d99
|
refs/heads/master
| 2023-08-17T12:05:18.058535
| 2023-02-17T01:37:26
| 2023-02-17T01:37:26
| 31,079,594
| 108
| 75
|
Apache-2.0
| 2023-08-21T17:09:37
| 2015-02-20T18:57:42
|
PowerShell
|
UTF-8
|
C++
| false
| false
| 4,598
|
cpp
|
util.cpp
|
#include "stdafx.h"
#include "util.h"
DWORD GetHardDiskNumberFromVolume(PCWSTR Volume,
std::vector<DWORD>* DiskNumber) {
HANDLE handle;
DWORD ret = ERROR_SUCCESS;
VOLUME_DISK_EXTENTS extents;
DWORD bytes_returned;
wstring volume_no_trailing_back_slash(Volume);
// All Windows volume functions work with VolumeGuid name with trailing slash.
// CreateFile is the only exception. It would fail with ERROR_PATH_NOT_FOUND
// if trailing slash presents. It actually mean opening the root dir if the
// trailing back slash is supplied.
if (volume_no_trailing_back_slash.back() == L'\\') {
volume_no_trailing_back_slash.pop_back();
}
handle = CreateFile(volume_no_trailing_back_slash.c_str(), GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
0, NULL);
if (handle == INVALID_HANDLE_VALUE) {
ret = GetLastError();
LogDebugMessage(L"CreateFile (%s) failed with error %d", Volume,
GetLastError());
}
if (ret == ERROR_SUCCESS) {
ret = ERROR_MORE_DATA;
while (ret == ERROR_MORE_DATA) {
if (!DeviceIoControl(handle, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL,
0, &extents, sizeof(extents), &bytes_returned,
NULL)) {
ret = GetLastError();
if (ret != ERROR_MORE_DATA) {
LogDebugMessage(
L"IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS for %s failed with error "
L"%d",
Volume, GetLastError());
}
} else {
ret = ERROR_SUCCESS;
}
if (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) {
for (DWORD i = 0; i < extents.NumberOfDiskExtents; i++) {
DiskNumber->push_back(extents.Extents[i].DiskNumber);
}
}
}
}
if (handle != INVALID_HANDLE_VALUE) {
CloseHandle(handle);
}
return ret;
}
DWORD GetScsiAddressForHardDisk(DWORD DiskNumber, SCSI_ADDRESS* ScsiAddress) {
HANDLE handle = INVALID_HANDLE_VALUE;
WCHAR disk_name[64];
DWORD ret = ERROR_SUCCESS;
if (FAILED(StringCchPrintf(disk_name, ARRAYSIZE(disk_name),
L"\\\\.\\PhysicalDrive%d", DiskNumber))) {
return ERROR_INSUFFICIENT_BUFFER;
}
if (ret == ERROR_SUCCESS) {
handle =
CreateFile(disk_name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, OPEN_EXISTING, 0, NULL);
if (handle == INVALID_HANDLE_VALUE) {
ret = GetLastError();
LogDebugMessage(L"CreateFile (%s) failed with error %d", disk_name,
GetLastError());
}
}
if (ret == ERROR_SUCCESS) {
SCSI_ADDRESS scsi_address;
DWORD bytes_returned;
if (!DeviceIoControl(handle, IOCTL_SCSI_GET_ADDRESS, NULL, 0, &scsi_address,
sizeof(scsi_address), &bytes_returned, NULL)) {
ret = GetLastError();
LogDebugMessage(L"IOCTL_SCSI_GET_ADDRESS for %s failed with error %d",
disk_name, GetLastError());
} else {
*ScsiAddress = scsi_address;
}
}
if (handle != INVALID_HANDLE_VALUE) {
CloseHandle(handle);
}
return ret;
}
DWORD GetVolumesForScsiTarget(std::vector<wstring>* Volumes, DWORD PortNumber,
UCHAR Target, UCHAR Lun) {
HANDLE handle;
WCHAR volume_name[MAX_PATH];
DWORD ret = ERROR_SUCCESS;
handle = FindFirstVolume(volume_name, ARRAYSIZE(volume_name));
if (handle == INVALID_HANDLE_VALUE) {
ret = GetLastError();
LogDebugMessage(L"IOCTL_SCSI_GET_ADDRESS failed with error %d",
GetLastError());
return ret;
}
for (;;) {
if (GetDriveType(volume_name) == DRIVE_FIXED) {
vector<DWORD> disk_numbers;
SCSI_ADDRESS scsi_address;
if (ERROR_SUCCESS ==
GetHardDiskNumberFromVolume(volume_name, &disk_numbers)) {
for (int i = 0; i < disk_numbers.size(); i++) {
// Looking up matching tuple (ScsiPort, Tagrte, Lun).
if (ERROR_SUCCESS ==
GetScsiAddressForHardDisk(disk_numbers[i], &scsi_address) &&
PortNumber == scsi_address.PortNumber &&
Target == scsi_address.TargetId && Lun == scsi_address.Lun) {
Volumes->push_back(volume_name);
}
}
} else {
LogDebugMessage(L"GetHardDiskNumberFromVolume failed for %s",
volume_name);
}
}
if (!FindNextVolume(handle, volume_name, ARRAYSIZE(volume_name))) {
break;
}
}
FindVolumeClose(handle);
return ret;
}
|
c88b7c8a45bfda4a7c26900d4a83fca511c76ea5
|
50c2e632e04c86aca1be33dfe2b2671468456595
|
/misc/hackerrank/csindia/keyboard.cpp
|
49feef51ec8cda5885b10ac7d219de48061fb524
|
[] |
no_license
|
rohith2506/Algo-world
|
b413b4c4b572ec1d0c9539af526fa7edfa584444
|
064241d0c8f3ec43f9abc7905cab75214db1b9e0
|
refs/heads/master
| 2022-08-03T13:37:56.406913
| 2019-08-16T12:23:28
| 2019-08-16T12:23:28
| 24,947,086
| 0
| 0
| null | 2022-07-21T22:32:16
| 2014-10-08T15:28:36
|
Python
|
UTF-8
|
C++
| false
| false
| 572
|
cpp
|
keyboard.cpp
|
#include <iostream>
#include <stdio.h>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;
int main(){
int t;
cin >> t;
for(int tst=0; tst<t; tst++){
string str1,str2;
cin >> str1 >> str2;
vector<int> letters(26,1);
for(int i=0;i<str1.length();i++){
int val = (int)(str1[i] - 'a');
letters[val] = 0;
}
int cnt = 0;
for(int i=0;i<str2.length();i++){
int val = (int)(str2[i] - 'a');
if(letters[val] == 0){
cnt = cnt + 1;
letters[val] = 1;
}
}
cout << cnt << endl;
}
return 0;
}
|
a4252fa67a5c34aa637677b26b89146eb662dbd3
|
69e29020d31a1fdf23052ec57ccc247179c09be0
|
/src/data.hpp
|
c0cea1ba5f0ce9a95bcdc3793bfc29819d7d60ed
|
[] |
no_license
|
pgalindo-isart/ibl
|
132fa40340597216bf931d162c9817db1bc330b0
|
fc301d145c056212242be52b459effd6e4bea50a
|
refs/heads/main
| 2023-03-11T03:07:24.020272
| 2021-02-24T15:36:00
| 2021-02-24T15:36:00
| 327,258,034
| 0
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 131
|
hpp
|
data.hpp
|
#pragma once
#include "types.hpp"
namespace Tavern
{
extern float3 CandlesPositions[];
extern int CandlesCount;
}
|
13607b267866687ebb5c4a3a62d47f7bcf485f7e
|
4cd78346b16f83a7ff121ee1c3dd154fe8b4c6d1
|
/cpp/isogram/isogram.cpp
|
66e65e50848a6becec0b9b300f55c640a36fa69a
|
[] |
no_license
|
Mufassir-Chowdhury/Exercism
|
691a8dfb200a54f01fdb783a27748ae7402bb9bc
|
fdaae52ba91392d922b677c00f02d01aaa009dbe
|
refs/heads/main
| 2023-02-26T04:23:00.526692
| 2021-02-04T17:16:44
| 2021-02-04T17:16:44
| 333,815,620
| 2
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 346
|
cpp
|
isogram.cpp
|
#include "isogram.h"
namespace isogram {
bool is_isogram(std::string input){
std::set <char> ordered_input;
for(auto character: input)
if(isalnum((unsigned char) character) and ordered_input.insert(tolower( (unsigned char)character) ).second == false)
return false;
return true;
}
} // namespace isogram
|
ff7a2d3a6237d55a8659570a96f42b3beb2a65c1
|
43452d62da797640c517379268ee2a2df757ea70
|
/include/lib/Engine/Rendering/Texture2D.hpp
|
50932ccac8634f290c44c9b798b040508f78502c
|
[
"BSD-3-Clause"
] |
permissive
|
wangscript007/UniEngine
|
5b29141b988575ea688688c5cc87707d7b43c6d2
|
33246eba2fce4d040368ff9499b50195a249b9c9
|
refs/heads/main
| 2023-07-16T17:00:47.285053
| 2021-09-06T07:07:54
| 2021-09-06T07:07:54
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,220
|
hpp
|
Texture2D.hpp
|
#pragma once
#include <Core/OpenGLUtils.hpp>
namespace UniEngine
{
enum class UNIENGINE_API TextureType
{
Albedo,
Normal,
Metallic,
Roughness,
AO,
};
class UNIENGINE_API Texture2D : public IAsset
{
friend class Material;
friend class RenderManager;
friend class Bloom;
std::shared_ptr<OpenGLUtils::GLTexture2D> m_texture;
friend class AssetManager;
friend class Camera;
friend class DefaultResources;
friend class LightProbe;
friend class ReflectionProbe;
friend class EnvironmentalMap;
friend class Cubemap;
public:
float m_gamma = 1.0f;
void OnCreate() override;
[[nodiscard]] glm::vec2 GetResolution() const;
void StoreToPng(
const std::string &path,
int resizeX = -1,
int resizeY = -1,
bool alphaChannel = false,
unsigned compressionLevel = 8) const;
void StoreToJpg(const std::string &path, int resizeX = -1, int resizeY = -1, unsigned quality = 100) const;
[[nodiscard]] std::shared_ptr<OpenGLUtils::GLTexture2D>& UnsafeGetGLTexture();
void Save(const std::filesystem::path &path) override;
void Load(const std::filesystem::path & path) override;
};
} // namespace UniEngine
|
4ce0109fff59ee74157d4daf9d676417001ccf9e
|
62efc7dd0b95a4504ef77fa620008b284f552cb2
|
/p1/ssdavis/SeansSrc/LongInt.cpp
|
8e36256583a926907576b9b4d1bb93efb6dad8b4
|
[] |
no_license
|
shutAp/ecs60
|
0ef01524d1811c7e3457a6122aa909f32071fc12
|
3c7bb53ec2fcd26f73069a6ddf6c385c43f88032
|
refs/heads/master
| 2020-04-29T15:12:23.601215
| 2014-05-29T01:01:45
| 2014-05-29T01:01:45
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,070
|
cpp
|
LongInt.cpp
|
#include <ctype.h>
#include <limits.h>
#include "LongInt.h"
#include "StackLi.h"
LongInt::LongInt()
{
digits.makeEmpty();
} // LongInt
istream& operator>> (istream &in, LongInt &rhs)
{ // digit are stored in reverse order!!!
char c = '0';
rhs.digits.makeEmpty();
ListItr <char> itr = rhs.digits.zeroth();
while(isdigit(c))
{
in >> c;
rhs.digits.insert(c - '0', itr);
c = in.peek();
} // while c is a digit
in.ignore(INT_MAX, '\n');
return in;
} // operator>>
ostream& operator<< (ostream &out, LongInt &rhs)
{
if(rhs.digits.isEmpty())
out << 0;
else
{
ListItr<char> itr = rhs.digits.first();
StackLi<char> stack;
while(!itr.isPastEnd())
{
stack.push(itr.retrieve());
itr.advance();
}
while(!stack.isEmpty())
out << (int) stack.topAndPop();
} // else not empty
return out;
} // operator<<
LongInt& LongInt::operator+ (LongInt &rhs)
{
char num = 0;
static LongInt result;
result.digits.makeEmpty();
ListItr<char> itr = digits.first(), itr2 = rhs.digits.first(),
itr3 = result.digits.zeroth();
while(!itr.isPastEnd() && !itr2.isPastEnd())
{
num += itr.retrieve() + itr2.retrieve();
result.digits.insert(num % 10, itr3);
num /= 10;
itr3.advance();
itr2.advance();
itr.advance();
}
while(!itr.isPastEnd())
{
num += itr.retrieve();
result.digits.insert(num % 10, itr3);
num /= 10;
itr3.advance();
itr.advance();
}
while(!itr2.isPastEnd())
{
num += itr2.retrieve();
result.digits.insert(num % 10, itr3);
num /= 10;
itr3.advance();
itr2.advance();
}
if(num > 0){
result.digits.insert(num, itr3);
itr3.advance();
}
return result;
} // operator+
LongInt& LongInt::operator= (LongInt &rhs)
{
if(this == &rhs)
return *this;
digits.makeEmpty();
ListItr <char> itr = digits.zeroth(), itr2 = rhs.digits.first();
while(!itr2.isPastEnd())
{
digits.insert(itr2.retrieve(), itr);
itr.advance();
itr2.advance();
}
return *this;
} // operator=
|
cf44dcbc3ac44ab9d0335c50f0e3049c5bc060e8
|
101b515ed28375ead0c88d14ed31311c4d4c8f4c
|
/09-love-calculator/09-love-calculator.cpp
|
e9104de231b318d3e6d20e9d5143be7af2dd2ea6
|
[] |
no_license
|
bpieszko/programming_challenges_cpp
|
ea04577ea98e73a1bdc532dd444d40589f2580b0
|
6dcad6bd78ce0e56436a6f5565ddf4b7b58d139f
|
refs/heads/master
| 2020-03-22T11:17:17.982421
| 2018-09-18T15:11:17
| 2018-09-18T15:11:17
| 139,961,204
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,262
|
cpp
|
09-love-calculator.cpp
|
#include <iostream>
#include <vector>
#include <algorithm>
void print_intro()
{
std::cout << "Love calculator - bpieszko" << std::endl;
std::cout << "Written as a part of /g/'s programming challenges." << std::endl << std::endl;
}
const long long prime = 31;
const long long mod = 1000000007;
int hash(const std::string& s)
{
long long result = 0;
for (auto i : s)
result = (result + prime * (i - (i >= 'a') ? 'a' : 'A')) % mod;
return result;
}
int main ()
{
print_intro();
std::string first_name, second_name;
std::cout << "Enter first name: ";
std::cin >> first_name;
std::cout << "Enter second name: ";
std::cin >> second_name;
const int love = (hash(first_name) ^ hash(second_name)) % 101;
if(love > 90)
std::cout << "Wow! That's a lot of love! (" << love << ")" << std::endl;
else if(love > 70)
std::cout << "That's quite a lot of love! (" << love << ")" << std::endl;
else if(love > 50)
std::cout << "It's still quite a bunch. (" << love << ")" << std::endl;
else if(love > 30)
std::cout << "It's still love after all. (" << love << ")" << std::endl;
else if(love > 10)
std::cout << "It could have been better... (" << love << ")" << std::endl;
else
std::cout << "Oh... (" << love << ")" << std::endl;
return 0;
}
|
ad2d3c74dee3cec179c805d25936109b7d80a23a
|
974d04d2ea27b1bba1c01015a98112d2afb78fe5
|
/paddle/phi/kernels/funcs/eigen/pad.cc
|
8041fc4ae175ec9e68e8a393e5d5cc5ef7180b39
|
[
"Apache-2.0"
] |
permissive
|
PaddlePaddle/Paddle
|
b3d2583119082c8e4b74331dacc4d39ed4d7cff0
|
22a11a60e0e3d10a3cf610077a3d9942a6f964cb
|
refs/heads/develop
| 2023-08-17T21:27:30.568889
| 2023-08-17T12:38:22
| 2023-08-17T12:38:22
| 65,711,522
| 20,414
| 5,891
|
Apache-2.0
| 2023-09-14T19:20:51
| 2016-08-15T06:59:08
|
C++
|
UTF-8
|
C++
| false
| false
| 2,814
|
cc
|
pad.cc
|
/* Copyright (c) 2022 PaddlePaddle 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 "paddle/phi/common/bfloat16.h"
#include "paddle/phi/common/complex.h"
#include "paddle/phi/kernels/funcs/eigen/eigen_function.h"
namespace phi {
namespace funcs {
template <typename T, int Rank>
struct EigenPad<Eigen::DefaultDevice, T, Rank> {
using Array = std::array<std::pair<int64_t, int64_t>, Rank>;
using Array32Bit = std::array<std::pair<int, int>, Rank>;
using InType = Eigen::TensorMap<
Eigen::Tensor<const T, Rank, Eigen::RowMajor, Eigen::DenseIndex>>;
using InType32BitIndex =
Eigen::TensorMap<Eigen::Tensor<const T, Rank, Eigen::RowMajor, int>,
Eigen::Aligned>;
using OutType = Eigen::TensorMap<
Eigen::Tensor<T, Rank, Eigen::RowMajor, Eigen::DenseIndex>>;
using OutType32BitIndex =
Eigen::TensorMap<Eigen::Tensor<T, Rank, Eigen::RowMajor, int>,
Eigen::Aligned>;
static void Eval(const Eigen::DefaultDevice& dev,
OutType out,
const InType& in,
const Array& padding,
const T value) {
out.device(dev) = in.pad(padding, value);
}
static void Eval32(const Eigen::DefaultDevice& dev,
OutType32BitIndex out,
const InType32BitIndex& in,
const Array32Bit& padding,
const T value) {
out.device(dev) = in.pad(padding, value);
}
};
#define INSTANTIATION(FUNCTOR, TYPE) \
template struct FUNCTOR<Eigen::DefaultDevice, TYPE, 1>; \
template struct FUNCTOR<Eigen::DefaultDevice, TYPE, 2>; \
template struct FUNCTOR<Eigen::DefaultDevice, TYPE, 3>; \
template struct FUNCTOR<Eigen::DefaultDevice, TYPE, 4>; \
template struct FUNCTOR<Eigen::DefaultDevice, TYPE, 5>; \
template struct FUNCTOR<Eigen::DefaultDevice, TYPE, 6>;
INSTANTIATION(EigenPad, bool);
INSTANTIATION(EigenPad, uint8_t);
INSTANTIATION(EigenPad, int);
INSTANTIATION(EigenPad, int64_t);
INSTANTIATION(EigenPad, float);
INSTANTIATION(EigenPad, double);
INSTANTIATION(EigenPad, dtype::bfloat16);
INSTANTIATION(EigenPad, dtype::complex<float>);
INSTANTIATION(EigenPad, dtype::complex<double>);
#undef INSTANTIATION
} // namespace funcs
} // namespace phi
|
3a561d7206b57f41de74c5a10d2cbd10adaf85d7
|
fb4f925e03d5e31679d984bf3e74af4480157866
|
/Disser/SVM/descriptor_svm_trainer.h
|
fe9e6c7899354f74e632bab81bab71787e1310cf
|
[] |
no_license
|
nelenivy/mol_descr
|
f79402df29c801c6a47c57acddd3dd56510f305f
|
0947fdc2521a14a29678c227291e5b2cc887a090
|
refs/heads/master
| 2023-02-12T10:13:23.934391
| 2023-02-01T22:32:12
| 2023-02-01T22:32:12
| 15,648,489
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,327
|
h
|
descriptor_svm_trainer.h
|
#pragma once
#include "stdafx.h"
#include <utility>
#include <vector>
#include "opencv2/core/core.hpp"
#include "shark/Models/Kernels/KernelExpansion.h"
#include "element_with_index_and_id.h"
//namespace boost
//{
// namespace serialization
// {
// template <class Archive/*, typename T*/>
// void serialize(Archive& ar, /*const*/ cv::Point3d/*_<T>*/& point, const unsigned int version)
// {
// ar & point.x;
// ar & point.y;
// ar & point.z;
// }
//
// template <class Archive, typename ElemType/*, typename T*/>
// void serialize(Archive& ar, /*const*/ /*_<T>*/molecule_descriptor::ElemWithIndexAndID<ElemType>& point, const unsigned int version)
// {
// ar & point.Elem();
// }
//
// template <class Archive, typename ElemType/*, typename T*/>
// void serialize(Archive& ar, /*const*/ /*_<T>*/molecule_descriptor::SingularPoint<ElemType>& point, const unsigned int version)
// {
// ar & point.GetAsPair();
// }
//
// template <class Archive/*, typename T*/>
// void serialize(Archive& ar, /*const*/ /*_<T>*/molecule_descriptor::PropertiesSet& point, const unsigned int version)
// {
// ar & point.SurfaceType();
// ar & point.Charge();
// ar & point.ElectricPotential();
// }
// }
//}
namespace molecule_descriptor
{
using std::vector;
using std::string;
using shark::RealVector;
class DescriptorSVMTrainerManager
{
public:
typedef size_t singular_point;
typedef /*std::vector<singular_point>*/RealVector sing_pts_seq;
typedef ElemWithIndexAndID<sing_pts_seq> sing_pts_seq_wth_ind;
DescriptorSVMTrainerManager()
: m_kernel_expansion(),
m_curr_dataset_id(0)
{ }
void SetData(const cv::Mat_<size_t>& data,
const vector<unsigned int>& labels);//Convert input to shark format
void Train(const std::string& file_name);
void TrainL0Approx(const std::string& file_name);
void Write(const std::string& file_name);
private:
void EvaluateTrained();
int m_curr_dataset_id;
shark::LabeledData<sing_pts_seq_wth_ind, unsigned int> m_labeled_data_with_ind;
shark::LabeledData<sing_pts_seq, unsigned int> m_labeled_data;
shark::KernelClassifier<sing_pts_seq/*_wth_ind*/> m_kernel_expansion;
shark::Data<shark::blas::vector<double>> m_eval_result;
double m_training_error;
};
}
|
7a28faa26bce2c8ff80983d4defa1fedd0bd2ec5
|
33bd7c6d8df57039ec636cbf62f02265e7b861fb
|
/include/h3api/H3Managers/H3HiScoreManager.hpp
|
7fb6894b75251b33dc094fc2b4c60ce1371e6abb
|
[
"MIT"
] |
permissive
|
RoseKavalier/H3API
|
26f5bd1e2d63d1a61f762bba16a009ba33bf021f
|
49c65f1e30fe82a2156918aa7e45349f91a8524d
|
refs/heads/master
| 2023-08-18T14:07:00.214661
| 2022-11-14T02:27:17
| 2022-11-14T02:27:17
| 367,050,838
| 21
| 8
|
MIT
| 2023-08-06T16:55:05
| 2021-05-13T13:04:01
|
C++
|
UTF-8
|
C++
| false
| false
| 1,515
|
hpp
|
H3HiScoreManager.hpp
|
//////////////////////////////////////////////////////////////////////
// //
// Created by RoseKavalier: //
// rosekavalierhc@gmail.com //
// Created or last updated on: 2021-01-31 //
// ***You may use or distribute these files freely //
// so long as this notice remains present.*** //
// //
//////////////////////////////////////////////////////////////////////
#pragma once
#include "h3api/H3Base.hpp"
#include "h3api/H3Managers/H3BaseManager.hpp"
namespace h3
{
_H3API_DECLARE_(HiScoreManager);
#pragma pack(push, 4)
struct H3HiScoreManager : H3Manager
{
_H3API_SIZE_(0x8D4);
_H3API_VTABLE_(0x63EB8C);
_H3API_GET_INFO_(0x69941C, H3HiScoreManager);
struct Entry
{
_H3API_SIZE_(0x64);
CHAR username[40];
CHAR mapname[40];
h3unk32 _f_50;
INT32 score;
INT32 days;
h3unk8 _f_5C[8];
};
/** @brief [38] a buffer to read from <Heroes3>/data/HiScore.dat*/
Entry scenarios[11];
/** @brief [484] a buffer to read from <Heroes3>/data/HiScore.dat*/
Entry campaigns[11];
/** @brief [8D0]*/
BOOL showingSingleScenarios;
_H3API_ VOID ResetScores();
};
_H3API_ASSERT_SIZE_(H3HiScoreManager);
_H3API_ASSERT_SIZE_(H3HiScoreManager::Entry);
#pragma pack(pop) /* align-4 */
} /* namespace h3 */
|
a61eace6e5230d5baeff1be045f7839920d02879
|
fc73264e6a2632dc229962e2e55e8f7e51af646a
|
/._retired_/example/frame/concept/core/manager.hpp
|
16d97134c3721378bdacaa80e09922b1564058fb
|
[
"BSL-1.0"
] |
permissive
|
zodsoft/solidframe
|
8b259b208bda99bd85029664d92a05a0f254420c
|
136e913027cd94a54bff3dee4b0a6673f2123a7f
|
refs/heads/master
| 2021-01-12T23:59:56.403982
| 2016-12-22T09:50:52
| 2016-12-22T09:50:52
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,979
|
hpp
|
manager.hpp
|
// manager.hpp
//
// Copyright (c) 2007, 2008 Valentin Palade (vipalade @ gmail . com)
//
// This file is part of SolidFrame framework.
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.
//
#ifndef CONCEPT_CORE_MANAGER_HPP
#define CONCEPT_CORE_MANAGER_HPP
#include "frame/manager.hpp"
#include "frame/scheduler.hpp"
#include "frame/aio/aioselector.hpp"
#include "frame/objectselector.hpp"
#include "frame/file/filestore.hpp"
#include "common.hpp"
namespace solid{
namespace frame{
namespace aio{
class Resolver;
}//namespace aio
namespace ipc{
class Service;
}//namespace ipc
namespace file{
class Manager;
}//namespace file
}//namespace frame
}//namespace solid
namespace concept{
typedef solid::frame::Scheduler<solid::frame::aio::Selector> AioSchedulerT;
typedef solid::frame::Scheduler<solid::frame::ObjectSelector> SchedulerT;
typedef solid::frame::file::Store<> FileStoreT;
//! A proof of concept server
/*!
This is a proof of concept server and should be taken accordingly.
It tries to give an ideea of how the foundation::Manager should be used.
To complicate things a little, it allso keeps a map service name to service,
so that services can be more naturally accessed by their names.
*/
class Manager: public solid::frame::Manager{
public:
Manager();
~Manager();
void start();
static Manager& the(Manager *_pm = NULL);
void scheduleListener(solid::DynamicPointer<solid::frame::aio::Object> &_objptr);
void scheduleTalker(solid::DynamicPointer<solid::frame::aio::Object> &_objptr);
void scheduleAioObject(solid::DynamicPointer<solid::frame::aio::Object> &_objptr);
void scheduleObject(solid::DynamicPointer<solid::frame::Object> &_objptr);
solid::frame::ipc::Service &ipc()const;
FileStoreT& fileStore()const;
solid::frame::aio::Resolver& resolver();
private:
struct Data;
Data &d;
};
}//namespace concept
#endif
|
2fe012ec826ad132b95507929c9259da78c79457
|
6aee64c18e277886580b447a6bacb404fb7212ed
|
/参考/智能主动防御系统/应用程序代码/Defender825/AdvanceSetting.h
|
28e74f4c80841e1a886df90a0b607311e7b0e781
|
[] |
no_license
|
15831944/information_security_invitational
|
acbbcc3b4bd8d373bbd15d4fbf7fac85a8dac83b
|
361441f76a238f24853e970631591740c83a0cf5
|
refs/heads/master
| 2022-04-17T10:13:45.025461
| 2017-05-23T09:43:38
| 2017-05-23T09:43:38
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,816
|
h
|
AdvanceSetting.h
|
#if !defined(AFX_ADVANCESETTING_H__EF06BC72_2555_4312_B1C5_CE0EAB9992FF__INCLUDED_)
#define AFX_ADVANCESETTING_H__EF06BC72_2555_4312_B1C5_CE0EAB9992FF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// AdvanceSetting.h : header file
//
/////////////////////////////////////////////////////////////////////////////
// CAdvanceSetting dialog
class CAdvanceSetting : public CDialog
{
// Construction
public:
CAdvanceSetting(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CAdvanceSetting)
enum { IDD = IDD_ADVANCESETTING_DIALOG };
CListCtrl m_iplist;
CComboBox m_statelist;
CComboBox m_scriptlist;
CComboBox m_protocollist;
CListCtrl m_portlist;
CComboBox m_oslist;
//}}AFX_DATA
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAdvanceSetting)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
void LoadCheateSetting();
// Generated message map functions
//{{AFX_MSG(CAdvanceSetting)
afx_msg void OnShowWindow(BOOL bShow, UINT nStatus);
afx_msg void OnAddport();
afx_msg void OnRclickPortlist(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnDel();
afx_msg void OnDestroy();
afx_msg void OnAddhost();
afx_msg void OnSavehost();
afx_msg void OnNewhost();
afx_msg void OnRclickIplist(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnDelhost();
afx_msg void OnDblclkIplist(NMHDR* pNMHDR, LRESULT* pResult);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_ADVANCESETTING_H__EF06BC72_2555_4312_B1C5_CE0EAB9992FF__INCLUDED_)
|
23fbb6816a170df14aaf4a4566420740780c88c7
|
dad2f02cfb07c03acf5acda8830db0bed20a6f9b
|
/CompOutput.h
|
3db8940c1b3e73cb4c1a058c361a4930ca0986fb
|
[
"MIT"
] |
permissive
|
cdrttn/fragmon
|
43784b61b3f4841b460e5ec776db51692335c77b
|
77b1989a23f44cc12ff361ed6547e2ccd60a587e
|
refs/heads/master
| 2016-09-06T03:47:19.148244
| 2013-04-14T20:04:10
| 2013-04-14T20:04:10
| 3,863,637
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,737
|
h
|
CompOutput.h
|
/*
** Copyright (c) 2006 Christopher Davis
**
** 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.
**
** $Id$
*/
/////////////////////////////////////////////////////////////////////////////
// Name: CompOutput.h
// Author: XX
// Created: XX/XX/XX
// Copyright: XX
/////////////////////////////////////////////////////////////////////////////
#ifndef __CompOutput_H__
#define __CompOutput_H__
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma interface "CompOutput.cpp"
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include "fragmon_wdr.h"
#include "pyemb.h"
// WDR: class declarations
//----------------------------------------------------------------------------
// CompOutput
//----------------------------------------------------------------------------
class CompOutput: public wxPanel
{
public:
// constructors and destructors
CompOutput( wxWindow *parent, wxWindowID id = -1,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTAB_TRAVERSAL | wxNO_BORDER );
void AddDirty(unsigned long d) { m_dirty |= d; }
void ClearDirty(unsigned long d) { m_dirty &= ~d; }
bool IsDirty(unsigned long d) const { return (m_dirty & d) > 0; }
void SetDirty(unsigned long d) { m_dirty = d; }
unsigned long GetDirty() const { return m_dirty; }
wxString GetTime() { return GetCompTime()->GetValue(); }
wxString GetNameA() { return GetCompNameA()->GetValue(); }
wxString GetNameB() { return GetCompNameB()->GetValue(); }
wxString GetScoreA() { return GetCompScoreA()->GetValue(); }
wxString GetScoreB() { return GetCompScoreB()->GetValue(); }
void SetTime(const wxString &time) { m_setval = true; if (!IsDirty(TIME_DIRTY)) GetCompTime()->SetValue(time); m_setval = false; }
void SetNameA(const wxString &name) { m_setval = true; if (!IsDirty(NAMEA_DIRTY)) GetCompNameA()->SetValue(name); m_setval = false; }
void SetNameB(const wxString &name) { m_setval = true; if (!IsDirty(NAMEB_DIRTY)) GetCompNameB()->SetValue(name); m_setval = false; }
void SetScoreA(const wxString &score) { m_setval = true; if (!IsDirty(SCOREA_DIRTY)) GetCompScoreA()->SetValue(score); m_setval = false; }
void SetScoreB(const wxString &score) { m_setval = true; if (!IsDirty(SCOREB_DIRTY)) GetCompScoreB()->SetValue(score); m_setval = false; }
void SetScoreA(int score) { m_setval = true; if (!IsDirty(SCOREA_DIRTY)) GetCompScoreA()->SetValue(wxString::Format("%d", score)); m_setval = false; }
void SetScoreB(int score) { m_setval = true; if (!IsDirty(SCOREB_DIRTY)) GetCompScoreB()->SetValue(wxString::Format("%d", score)); m_setval = false; }
public:
enum
{
CLEAR_DIRTY = 0,
TIME_DIRTY = 1<<0,
SCOREA_DIRTY = 1<<1,
SCOREB_DIRTY = 1<<2,
NAMEA_DIRTY = 1<<3,
NAMEB_DIRTY = 1<<4,
};
private:
bool m_setval;
unsigned long m_dirty;
// WDR: method declarations for CompOutput
wxTextCtrl* GetCompTime() { return (wxTextCtrl*) FindWindow( ID_COMP_TIME ); }
wxTextCtrl* GetCompScoreB() { return (wxTextCtrl*) FindWindow( ID_COMP_SCORE_B ); }
wxTextCtrl* GetCompScoreA() { return (wxTextCtrl*) FindWindow( ID_COMP_SCORE_A ); }
wxTextCtrl* GetCompNameB() { return (wxTextCtrl*) FindWindow( ID_COMP_NAME_B ); }
wxTextCtrl* GetCompNameA() { return (wxTextCtrl*) FindWindow( ID_COMP_NAME_A ); }
private:
// WDR: member variable declarations for CompOutput
private:
// WDR: handler declarations for CompOutput
void OnGameQuery(PyEvent &evt);
void OnText(wxCommandEvent &evt);
private:
DECLARE_EVENT_TABLE()
};
#endif
|
f4a72d52654708f75efbde8f6045eeaa6db349b1
|
9f9660f318732124b8a5154e6670e1cfc372acc4
|
/Case_save/Case20/case9/700/U
|
5b69d8676837303752836a3d31cd1b8e7960f6ae
|
[] |
no_license
|
mamitsu2/aircond5
|
9a6857f4190caec15823cb3f975cdddb7cfec80b
|
20a6408fb10c3ba7081923b61e44454a8f09e2be
|
refs/heads/master
| 2020-04-10T22:41:47.782141
| 2019-09-02T03:42:37
| 2019-09-02T03:42:37
| 161,329,638
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 13,324
|
U
|
// -*- C++ -*-
// File generated by PyFoam - sorry for the ugliness
FoamFile
{
version 2.0;
format ascii;
class volVectorField;
location "700";
object U;
}
dimensions [ 0 1 -1 0 0 0 0 ];
internalField nonuniform List<vector> 459
(
(0.0640304 0.0699852 0)
(-0.135283 0.011764 0)
(-0.128452 0.00422798 0)
(-0.134148 0.00155977 0)
(-0.135106 -0.00149164 0)
(-0.131106 -0.00452382 0)
(-0.123123 -0.00671369 0)
(-0.112642 -0.00806209 0)
(-0.100972 -0.00875797 0)
(-0.0889851 -0.00913545 0)
(-0.0769051 -0.00958329 0)
(-0.0642598 -0.0104878 0)
(-0.0500059 -0.0123294 0)
(-0.033854 -0.0158133 0)
(-0.0201187 -0.0211026 0)
(0.0101295 -0.0100444 0)
(0.00663544 -0.00605551 0)
(0.00421171 -0.00379978 0)
(0.00447787 -0.00296573 0)
(0.00610059 -0.00267938 0)
(0.00861713 -0.00325122 0)
(0.0125789 -0.00434375 0)
(0.0177255 -0.00391112 0)
(0.0221335 -0.00327316 0)
(0.025265 -0.00278806 0)
(0.0275659 -0.00231395 0)
(0.0289571 -0.00187747 0)
(0.0291209 -0.00141043 0)
(0.0283033 -0.000835876 0)
(0.026634 -0.000126326 0)
(0.0232829 0.0015942 0)
(0.0188642 0.00239852 0)
(0.0150336 0.00539735 0)
(-0.0119721 0.0079951 0)
(0.19938 0.150047 0)
(-0.155444 0.0399035 0)
(-0.126794 0.0124798 0)
(-0.132678 0.00525652 0)
(-0.135013 -0.00278099 0)
(-0.131085 -0.0102963 0)
(-0.123203 -0.0143793 0)
(-0.113366 -0.0167315 0)
(-0.102951 -0.0176422 0)
(-0.0927556 -0.0177183 0)
(-0.0830269 -0.0177577 0)
(-0.0735576 -0.0185155 0)
(-0.0638321 -0.0207482 0)
(-0.0536428 -0.0252577 0)
(-0.0437493 -0.0316956 0)
(-0.0340965 -0.033107 0)
(0.0114566 0.00374991 0)
(-0.0164678 -0.00265418 0)
(0.00162859 0.000427503 0)
(-0.00118135 0.00124556 0)
(-0.0028193 0.000317841 0)
(-0.00364014 -0.000757738 0)
(-0.00425136 -0.00307036 0)
(-0.00542692 -0.00771012 0)
(-0.00347898 -0.00599036 0)
(-0.0024467 -0.00395625 0)
(-0.00294044 -0.00226704 0)
(-0.00409203 -0.000233315 0)
(-0.00540602 0.00138759 0)
(-0.00603728 0.00246502 0)
(-0.00663205 0.00364258 0)
(-0.0070493 0.0052649 0)
(-0.00722967 0.00861491 0)
(-0.0083044 0.00911816 0)
(-0.0155204 0.0101006 0)
(-0.0205263 0.00367899 0)
(0.353649 0.223558 0)
(-0.1463 0.0279457 0)
(-0.0815328 -0.0251234 0)
(-0.0896998 -0.0123678 0)
(-0.105334 -0.0141273 0)
(-0.111448 -0.019746 0)
(-0.109242 -0.0235326 0)
(-0.102869 -0.0267033 0)
(-0.0950623 -0.0272883 0)
(-0.0873715 -0.0266202 0)
(-0.0804625 -0.0258818 0)
(-0.0745163 -0.0260757 0)
(-0.0693831 -0.0280511 0)
(-0.0646963 -0.0323359 0)
(-0.0599151 -0.0383981 0)
(-0.0567283 -0.0441342 0)
(-0.0668489 -0.0501589 0)
(-0.048731 0.012511 0)
(-0.0245126 0.00437049 0)
(-0.0258833 0.00213723 0)
(-0.0256036 0.000273872 0)
(-0.024234 -0.00164063 0)
(-0.022971 -0.00438677 0)
(-0.0209902 -0.00662851 0)
(-0.0304495 -0.00583667 0)
(-0.0346727 -0.00451352 0)
(-0.0371378 -0.00371728 0)
(-0.0382475 -0.00309557 0)
(-0.0383397 -0.00265878 0)
(-0.0381475 -0.00233337 0)
(-0.0372289 -0.00200423 0)
(-0.0334587 -0.00201757 0)
(-0.0255063 -0.000822658 0)
(-0.0147498 0.00275969 0)
(-0.0215415 0.00562346 0)
(0.0840132 -0.00331597 0)
(0.584804 0.256395 0)
(0.259137 0.173592 0)
(0.205276 0.125005 0)
(0.15574 0.0966975 0)
(0.0801604 0.066043 0)
(-0.0236518 0.00971832 0)
(-0.0686917 -0.0215562 0)
(-0.0781642 -0.0315706 0)
(-0.0770065 -0.0334184 0)
(-0.0735691 -0.0323251 0)
(-0.0700562 -0.0305188 0)
(-0.0676013 -0.0293585 0)
(-0.0667021 -0.0298149 0)
(-0.0675569 -0.0322462 0)
(-0.0708264 -0.0362317 0)
(-0.0797384 -0.0405853 0)
(-0.0962919 -0.0412753 0)
(-0.0977187 -0.0247467 0)
(-0.0781617 0.00597237 0)
(-0.0667553 0.00280845 0)
(-0.0648251 0.00140964 0)
(-0.0654626 9.23315e-05 0)
(-0.0678343 -0.00161027 0)
(-0.0718423 -0.00355417 0)
(-0.074331 -0.00255443 0)
(-0.0734787 -0.00259774 0)
(-0.0722145 -0.00323068 0)
(-0.0702872 -0.0038835 0)
(-0.0676575 -0.00463112 0)
(-0.0642345 -0.0055363 0)
(-0.0597138 -0.00666465 0)
(-0.0534625 -0.00813827 0)
(-0.0451395 -0.0101645 0)
(-0.0374562 -0.0127337 0)
(-0.0324123 -0.0145533 0)
(-0.0393015 -0.0151257 0)
(0.129103 0.000734784 0)
(0.473556 -0.162797 0)
(0.296289 -0.00937531 0)
(0.279356 0.08446 0)
(0.250277 0.133196 0)
(0.179074 0.134565 0)
(0.0949206 0.0998669 0)
(0.0291286 0.0498816 0)
(-0.0351874 -0.016244 0)
(-0.0478212 -0.03141 0)
(-0.0516001 -0.0335876 0)
(-0.0521816 -0.0318031 0)
(-0.052552 -0.029389 0)
(-0.0540029 -0.0280032 0)
(-0.0569666 -0.0281577 0)
(-0.0619239 -0.0295449 0)
(-0.0700245 -0.0308356 0)
(-0.0799779 -0.0280818 0)
(-0.0837513 -0.0161519 0)
(-0.080328 -0.00568931 0)
(-0.0757468 -0.00166524 0)
(-0.0730802 0.000183069 0)
(-0.0717247 0.000798961 0)
(-0.0714109 0.000575315 0)
(-0.0717106 2.81381e-05 0)
(-0.071622 -4.76202e-05 0)
(-0.0708678 -0.000904378 0)
(-0.0699357 -0.00178941 0)
(-0.0687734 -0.00268381 0)
(-0.0673179 -0.00365975 0)
(-0.0655545 -0.00480113 0)
(-0.063453 -0.00621135 0)
(-0.0609672 -0.00808659 0)
(-0.0583689 -0.010789 0)
(-0.0568233 -0.0143807 0)
(-0.0585164 -0.016831 0)
(-0.0632663 -0.0169439 0)
(-0.0614513 -0.00897462 0)
(-0.0639113 -0.0102474 0)
(-0.0501546 -0.0202059 0)
(0.0108165 -0.0417713 0)
(0.360201 -0.318571 0)
(0.129645 -0.0760116 0)
(0.195475 0.112297 0)
(0.201712 0.193089 0)
(0.154017 0.196757 0)
(0.097094 0.156005 0)
(0.0541594 0.0982051 0)
(0.021561 0.0387402 0)
(-0.0114564 -0.0148508 0)
(-0.0232039 -0.0289958 0)
(-0.0285059 -0.0298981 0)
(-0.031727 -0.0273341 0)
(-0.0350391 -0.0248923 0)
(-0.0393009 -0.0236829 0)
(-0.0449641 -0.0236736 0)
(-0.0522881 -0.023729 0)
(-0.059964 -0.0211361 0)
(-0.0646664 -0.0141722 0)
(-0.0654572 -0.00779065 0)
(-0.064341 -0.00397986 0)
(-0.0630774 -0.0016842 0)
(-0.0620018 -0.00058899 0)
(-0.0612672 -0.000436891 0)
(-0.0608519 -0.000783699 0)
(-0.0604801 -0.0012196 0)
(-0.0600321 -0.00202792 0)
(-0.0595587 -0.00300533 0)
(-0.0590035 -0.00407273 0)
(-0.0583212 -0.00522898 0)
(-0.0575094 -0.00649578 0)
(-0.0565867 -0.00790921 0)
(-0.0556072 -0.0095477 0)
(-0.0547739 -0.0115338 0)
(-0.0544881 -0.0137578 0)
(-0.0548903 -0.0153163 0)
(-0.0545742 -0.0151643 0)
(-0.0509444 -0.0117054 0)
(-0.0469851 -0.0124253 0)
(-0.0457594 -0.0208379 0)
(0.0543294 -0.0559218 0)
(0.277661 -0.369863 0)
(-0.000145243 -0.141058 0)
(0.125721 0.113182 0)
(0.128236 0.229296 0)
(0.0867508 0.233435 0)
(0.0574443 0.186496 0)
(0.0445738 0.122488 0)
(0.0366088 0.0606519 0)
(0.0263648 0.0128594 0)
(0.0104745 -0.0160535 0)
(0.000240105 -0.0240641 0)
(-0.00606076 -0.0232576 0)
(-0.0109191 -0.0207226 0)
(-0.0158392 -0.0187114 0)
(-0.0214673 -0.0176647 0)
(-0.0279328 -0.0169271 0)
(-0.0343779 -0.0149918 0)
(-0.0391067 -0.0111933 0)
(-0.0414568 -0.00733394 0)
(-0.0421893 -0.00447719 0)
(-0.042195 -0.0025261 0)
(-0.0418883 -0.00143335 0)
(-0.0415457 -0.00108235 0)
(-0.0412975 -0.00124291 0)
(-0.0411255 -0.00171414 0)
(-0.0410041 -0.00250091 0)
(-0.0409212 -0.00350823 0)
(-0.0408223 -0.00466875 0)
(-0.0406726 -0.00594669 0)
(-0.0404622 -0.0073393 0)
(-0.0401871 -0.00887382 0)
(-0.0398527 -0.0106056 0)
(-0.039508 -0.0125879 0)
(-0.0392077 -0.0147334 0)
(-0.0386979 -0.0166749 0)
(-0.0367729 -0.0180448 0)
(-0.0320497 -0.0194749 0)
(-0.028469 -0.0245349 0)
(-0.0453197 -0.036607 0)
(0.0980373 -0.0675078 0)
(0.141668 -0.315816 0)
(-0.151143 -0.187033 0)
(0.0536054 0.0440667 0)
(0.0523251 0.26686 0)
(-0.00178646 0.246745 0)
(0.00564423 0.186552 0)
(0.0237219 0.120001 0)
(0.0377418 0.0621147 0)
(0.0427608 0.0203102 0)
(0.0382355 -0.00448543 0)
(0.0301453 -0.0150212 0)
(0.0231011 -0.0169978 0)
(0.0176094 -0.0155658 0)
(0.0126982 -0.0135315 0)
(0.00766513 -0.0119559 0)
(0.00226288 -0.0108208 0)
(-0.0031621 -0.00943632 0)
(-0.00746849 -0.00740825 0)
(-0.0102911 -0.0052534 0)
(-0.0118898 -0.00346345 0)
(-0.0127101 -0.0021308 0)
(-0.0130719 -0.00131347 0)
(-0.0132322 -0.000998021 0)
(-0.0133573 -0.00109123 0)
(-0.0135146 -0.00149613 0)
(-0.0137337 -0.00219213 0)
(-0.0140015 -0.00313778 0)
(-0.0142796 -0.00426939 0)
(-0.0145648 -0.0055205 0)
(-0.0148642 -0.0068792 0)
(-0.0151641 -0.00838053 0)
(-0.0154343 -0.0100831 0)
(-0.0156452 -0.012041 0)
(-0.0157426 -0.0142283 0)
(-0.015475 -0.016475 0)
(-0.0140355 -0.0186835 0)
(-0.0105494 -0.0218121 0)
(-0.0078671 -0.0291736 0)
(-0.0345436 -0.0451508 0)
(0.160917 -0.0640643 0)
(-0.0753841 -0.172485 0)
(-0.42055 -0.115022 0)
(-0.58294 -0.0232099 0)
(-0.0441345 0.234171 0)
(-0.101894 0.214645 0)
(-0.0425639 0.157194 0)
(0.00919399 0.0938333 0)
(0.0398449 0.0486827 0)
(0.0550692 0.0191229 0)
(0.0589984 0.00222736 0)
(0.0568072 -0.00548112 0)
(0.052929 -0.00742711 0)
(0.0490106 -0.00669871 0)
(0.0451738 -0.00522622 0)
(0.041267 -0.00388335 0)
(0.0372378 -0.002868 0)
(0.0332731 -0.00201665 0)
(0.029827 -0.00109275 0)
(0.0271915 -0.000114813 0)
(0.0253418 0.000779073 0)
(0.0240885 0.00150135 0)
(0.0232305 0.00197773 0)
(0.0225718 0.00216679 0)
(0.0219705 0.00207206 0)
(0.021377 0.00173423 0)
(0.0207355 0.00117197 0)
(0.0200633 0.000391494 0)
(0.0193754 -0.000560501 0)
(0.0186194 -0.00161264 0)
(0.0177472 -0.00277947 0)
(0.0167648 -0.00412519 0)
(0.0157148 -0.0057276 0)
(0.0146472 -0.00767137 0)
(0.0136235 -0.0100159 0)
(0.0127783 -0.0127567 0)
(0.0124503 -0.0159261 0)
(0.0126772 -0.0202043 0)
(0.0106169 -0.0280653 0)
(-0.01505 -0.0434391 0)
(0.14612 -0.0580361 0)
(-1.92422 -0.0476241 0)
(-0.0944594 0.0781128 0)
(-0.142938 0.107486 0)
(-0.0551877 0.0895271 0)
(0.0234571 0.0498198 0)
(0.0597837 0.0300829 0)
(0.0790933 0.017707 0)
(0.0871122 0.00876999 0)
(0.0877382 0.00475583 0)
(0.0854811 0.00447518 0)
(0.0824044 0.00590949 0)
(0.0793169 0.00765122 0)
(0.0764682 0.00904489 0)
(0.0738592 0.00987234 0)
(0.071455 0.0101918 0)
(0.0693054 0.0102348 0)
(0.0674749 0.0101531 0)
(0.0659525 0.01003 0)
(0.0646751 0.00990224 0)
(0.0635801 0.00973023 0)
(0.0625974 0.00947141 0)
(0.0616451 0.00909025 0)
(0.0606388 0.0085486 0)
(0.0595582 0.00775242 0)
(0.0584441 0.00650974 0)
(0.0572217 0.00497384 0)
(0.0558162 0.0032908 0)
(0.0541833 0.00136432 0)
(0.0523286 -0.000956632 0)
(0.050268 -0.00379736 0)
(0.0480047 -0.00728367 0)
(0.0455355 -0.0115258 0)
(0.0428778 -0.0165699 0)
(0.0401102 -0.022367 0)
(0.0369535 -0.0289268 0)
(0.0306911 -0.0370308 0)
(0.00818591 -0.050806 0)
(0.0669007 -0.0808905 0)
(-0.809592 0.0680195 0)
(0.309507 -0.0434965 0)
(0.0977868 -0.0552311 0)
(0.0765364 -0.0656109 0)
(0.109015 -0.0851464 0)
(0.131087 -0.101818 0)
(0.139028 -0.115965 0)
(0.13687 -0.123653 0)
(0.130127 -0.125336 0)
(0.122578 -0.12312 0)
(0.116239 -0.119254 0)
(0.111631 -0.115197 0)
(0.108506 -0.111483 0)
(0.10642 -0.108028 0)
(0.104936 -0.10493 0)
(0.103759 -0.102122 0)
(0.102732 -0.0995342 0)
(0.101793 -0.0972106 0)
(0.100929 -0.0952446 0)
(0.100114 -0.0936744 0)
(0.0993082 -0.0925135 0)
(0.0984602 -0.0917651 0)
(0.0975158 -0.0914468 0)
(0.0964014 -0.0915334 0)
(0.0949253 -0.0918613 0)
(0.0929844 -0.0924319 0)
(0.0906307 -0.0927331 0)
(0.0879222 -0.0928267 0)
(0.0848662 -0.0929545 0)
(0.0813899 -0.0931978 0)
(0.0773758 -0.0935561 0)
(0.0727141 -0.0939939 0)
(0.0673604 -0.0944614 0)
(0.0614703 -0.0948956 0)
(0.0554299 -0.0952433 0)
(0.0488706 -0.0960478 0)
(0.0411647 -0.103464 0)
(0.0804618 -0.165805 0)
(0.50749 0.229383 0)
(0.327039 -0.0763923 0)
(-0.00555304 0.132731 0)
(0.262684 0.125153 0)
(0.259999 0.178385 0)
(0.214921 0.227273 0)
(0.201059 0.269048 0)
(0.197943 0.304347 0)
(0.193308 0.331936 0)
(0.186621 0.34851 0)
(0.180203 0.354392 0)
(0.174875 0.352851 0)
(0.170453 0.347651 0)
(0.166611 0.341521 0)
(0.163157 0.335643 0)
(0.160006 0.330118 0)
(0.157164 0.325172 0)
(0.154614 0.32074 0)
(0.152369 0.316715 0)
(0.15044 0.313093 0)
(0.148793 0.309903 0)
(0.147354 0.307153 0)
(0.146036 0.304843 0)
(0.144739 0.302973 0)
(0.143352 0.301565 0)
(0.141747 0.300617 0)
(0.139799 0.300016 0)
(0.137423 0.299859 0)
(0.134476 0.299387 0)
(0.130905 0.298654 0)
(0.126599 0.298016 0)
(0.121364 0.297598 0)
(0.114969 0.297394 0)
(0.107129 0.297366 0)
(0.0974768 0.29752 0)
(0.085563 0.297966 0)
(0.0706911 0.298921 0)
(0.0508229 0.301763 0)
(0.0219257 0.322636 0)
(0.0828053 0.463614 0)
)
;
boundaryField
{
floor
{
type noSlip;
}
ceiling
{
type noSlip;
}
sWall
{
type noSlip;
}
nWall
{
type noSlip;
}
sideWalls
{
type empty;
}
glass1
{
type noSlip;
}
glass2
{
type noSlip;
}
sun
{
type noSlip;
}
heatsource1
{
type noSlip;
}
heatsource2
{
type noSlip;
}
Table_master
{
type noSlip;
}
Table_slave
{
type noSlip;
}
inlet
{
type fixedValue;
value uniform (0.1 0 0);
}
outlet
{
type zeroGradient;
}
} // ************************************************************************* //
|
|
1644c150fb85c7aa9301d43e4cad750ea996f8a8
|
d5a68a89c0ed9e3895f5a25ceacf92fee9e058bd
|
/Warehouse Manager/CDialog_CLass.h
|
84e42d85f6097b0158f1494f913aaf224e89f7c5
|
[] |
no_license
|
uwitec/wavehouser
|
1c3424a6cda5dd2e506fe75c018349a19c654168
|
ff3555cf850e6868b00ea9661b5175f9e35db81f
|
refs/heads/master
| 2021-01-25T08:55:02.667020
| 2013-05-21T02:24:48
| 2013-05-21T02:24:48
| 41,086,828
| 1
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 840
|
h
|
CDialog_CLass.h
|
#pragma once
#include "CDate_Class.h"
#include "afxwin.h"
// CDialog_CLass 对话框
class CDialog_CLass : public CDialog
{
DECLARE_DYNAMIC(CDialog_CLass)
public:
CDialog_CLass(CWnd* pParent = NULL); // 标准构造函数
virtual ~CDialog_CLass();
// 对话框数据
enum { IDD = IDD_DLG_CLASS };
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV 支持
DECLARE_MESSAGE_MAP()
private:
CDate_Class m_date;
public:
afx_msg void OnBnClickedBtbSave();
afx_msg void OnBnClickedBtbQuit();
virtual BOOL OnInitDialog();
CEdit m_name_ctrl;
CEdit m_pName_ctrl;
CEdit m_num_ctrl;
CEdit m_telphone_ctrl;
CEdit m_contact_ctrl;
CEdit m_detail_ctrl;
void SetDate(const CDate_Class &date)
{
m_date = date;
}
CDate_Class GetDate()
{
return m_date;
}
};
|
cee5a90384fdbbb3b320ba5eb5c198e121ddf0e9
|
81a1367960cf88168ba38bccfdcd01e22b33a4fc
|
/include/nmtl/tnmcvec.h
|
86d0d69161e9cdae9a5b81c7ed33a2dc75a4a22f
|
[] |
no_license
|
RC-MODULE/nmpp
|
3ade5fdd40f24960e586669febae715885e21330
|
a41c26c650c2dee42b2ae07329f7e139c4178134
|
refs/heads/master
| 2022-11-02T07:56:09.382120
| 2022-09-21T17:34:38
| 2022-09-21T17:34:38
| 44,173,133
| 9
| 12
| null | 2022-04-28T08:42:55
| 2015-10-13T11:59:04
|
Assembly
|
UTF-8
|
C++
| false
| false
| 5,610
|
h
|
tnmcvec.h
|
//------------------------------------------------------------------------
//
// $Workfile:: tnmcvec. $
//
// Векторно-матричная библиотека
//
// Copyright (c) RC Module Inc.
//
// $Revision: 1.2 $ $Date: 2005/05/03 13:22:40 $
//
//! \if file_doc
//!
//! \file tnmcvec.h
//! \author Сергей Мушкаев
//! \brief Определяет шаблон для класса вектор.
//!
//! \endif
//!
//------------------------------------------------------------------------
#ifndef _Tnmcvec_H_INCLUDED_
#define _Tnmcvec_H_INCLUDED_
#ifdef __cplusplus
#ifdef ENABLE_ASSERTE
#include <crtdbg.h>
#define ASSERTE _ASSERTE
#else
#define ASSERTE(expression)
#endif
#include "tnmint.h"
//*****************************************************************************
/**
\ingroup nmtl
\ru Класс векторов.
\en Class nmcvec
\~
\ru \par Примеры:
\en \par Example:
\~
\code
int Test[10]={1,125,3,4,5,6,7,8,9,10};
int Res [10];
nmcvec<int> A0(3);
nmcvec<int> B0(3);
nmcvec<int> C0(3);
\endcode
*/
//*****************************************************************************
template<class T> class nmcvec
{
protected:
cmplx<nmint<T> > * m_container;
bool m_flag_new;
public:
int m_size;
cmplx<nmint<T> > * m_data;
nmcvec(cmplx<nmint<T> >* Data, int Size):m_data(Data),m_size(Size),m_flag_new(false){};
nmcvec(int Size,int Reserve=0):m_size(Size),m_flag_new(true)
{
m_container=new cmplx<nmint<T> >[m_size+2*Reserve];
m_data=m_container+Reserve;
}
//nmcvec(T * Data, int Size):m_data(Data),m_size(Size),m_flag_new(false){};
nmcvec(const nmcvec<T> &vec)
{
m_flag_new=true;
m_size=vec.m_size;
m_data=m_container=new T[m_size];
memcpy(m_data,vec.m_data,m_size*sizeof(T));
};
~nmcvec()
{
if (m_flag_new)
delete []m_container;
}
nmcvec<T>& operator= (nmcvec<T>& vec)
{
ASSERTE(vec.m_size==m_size);
memcpy(m_data,vec.m_data,m_size*sizeof(T));
return *this;
}
#ifndef NMTL_DISABLE_INDEX_CHECK
inline cmplx<nmint<T> >& operator [] (int idx)
{
ASSERTE(idx>=0);
ASSERTE(idx<m_size);
cmplx<nmint<T> >* res=(cmplx<nmint<T> >*)(m_data+idx);
return *res;
}
#else
inline cmplx<nmint<T> >& operator [] (int idx)
{
return (cmplx<nmint<T> >*)(m_data+idx);
}
#endif
template <class T2> nmcvec<T2>& operator*= (const cmplx<nmint<T2> > val)
{
for(int idx=0;idx<m_size;idx++)
m_data[idx]*=val.m_value;
return (*this);
}
template <class T2> nmcvec<T2> operator* (const cmplx<nmint<T2> >& val) const
{
nmcvec<T2> res(m_size);
for(int idx=0;idx<m_size;idx++)
res.m_data[idx]=m_data[idx]*val.m_value;
return res;
}
template <class T2> nmint<T2> operator* (const nmcvec<T2>& vec) const
{
ASSERTE(m_size==vec.m_size);
nmint<T2> res;
for (int idx=0;idx<m_size;idx++)
res.m_value+=m_data[idx]*vec.m_data[idx];
return res;
}
nmcvec<T>& operator+= (const cmplx<nmint<T> > &val)
{
for(int idx=0;idx<m_size;idx++)
m_data[idx]+=val.m_value;
return (*this);
}
nmcvec<T>& operator+= (const nmcvec<T> &vec)
{
ASSERTE (vec.m_size==m_size);
for(int idx=0;idx<m_size;idx++)
m_data[idx]+=vec.m_data[idx];
return (*this);
}
nmcvec<T> operator+ (const cmplx<nmint<T> >& val) const
{
nmcvec<T> res(*this);
res+=val;
return res;
}
nmcvec<T> operator+ (const nmcvec<T>& vec) const
{
ASSERTE (vec.m_size==m_size);
nmcvec<T> res(*this);
res+=vec;
return res;
}
nmcvec<T>& operator-= (const nmcvec<T> &vec)
{
ASSERTE (vec.m_size==m_size);
for(int idx=0;idx<m_size;idx++)
m_data[idx]-=vec.m_data[idx];
return (*this);
}
nmcvec<T> operator- (const nmcvec<T>& vec) const
{
ASSERTE (vec.m_size==m_size);
nmcvec <T> res(*this);
res-=vec;
return res;
}
nmcvec<T> operator- () const
{
nmcvec<T> res(*this);
for(int idx=0;idx<m_size;idx++)
m_data[idx]=-m_data[idx];
return res;
}
nmcvec<T>& operator/=(const cmplx<nmint<T> > val)
{
ASSERTE(val.m_value!=0);
for(int idx=0;idx<m_size;idx++)
m_data[idx]/=val.m_value;
return (*this);
}
nmcvec<T> operator/ (const T val) const
{
nmcvec<T> res(*this);
res/=val;
return res;
}
nmcvec<T>& operator>>=(const int shr)
{
ASSERTE(shr>=0);
if (shr==0) return(*this);
for(int idx=0;idx<m_size;idx++)
m_data[idx]>>=shr;
return (*this);
}
nmcvec<T> operator>> (const int shr) const
{
ASSERTE(shr>=0);
nmcvec<T> res(*this);
res>>=shr;
return res;
}
nmcvec<T>& operator<<=(const int shl)
{
ASSERTE(shl>=0);
if (shl==0) return(*this);
for(int idx=0;idx<m_size;idx++)
m_data[idx]<<=shl;
return (*this);
}
nmcvec<T> operator<< (const int shl) const
{
ASSERTE(shl>=0);
nmcvec<T> res(*this);
res<<=shl;
return res;
}
template<class T2> void SetData(T2* Data)
{
for(int i=0;i<m_size;i++)
m_data[i]=Data[i];
}
template<class T2> void GetData(T2* Data)
{
for(int i=0;i<m_size;i++)
Data[i]=(T2)m_data[i].value;
}
void SetConst(const cmplx<nmint<T > > val)
{
for (int idx=0;idx<m_size;idx++)
m_data[idx]=val;
}
};
/*
template <class T> void InitInc2(nmcvec<T>& A,cmplx<nmint<T> > StartValue=0,cmplx<nmint<T> > Increment=1)
{
for (int idx=0;idx<A.m_size;idx++,StartValue+=Increment)
A[idx]=StartValue;
}
*/
//bool operator== (const nmcvec<T>& vec) const
//bool operator!= (const nmcvec<T>& vec) const;
#ifdef __NM__
#else
typedef nmcvec<char > nmvec8sc;
typedef nmcvec<short > nmvec16sc;
#endif
typedef nmcvec<int > nmvec32sc;
typedef nmcvec<long long> nmvec64sc;
#endif
#endif
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.