blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 986
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 145
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 122
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
935226070d6845d3f5b1c537da8726d4a7876d5b | 1665df3a60ef9b5fe150aa52a96301be7b3b7d32 | /thrift_c++/libsvm_online/src/ml_libs/libsvm/eval.cpp | 45f3bfff656dbe0a4293b4e3614a93573baf556d | [] | no_license | hemaoliang/MLmodel_online_project | d7904484c43024b85b8128d7916f958bd5f9ee46 | 18bd2da2b1d787dfee6e083a06d12c88fb894e9c | refs/heads/master | 2020-05-21T04:37:30.193738 | 2017-04-25T12:15:33 | 2017-04-25T12:15:33 | 54,866,696 | 2 | 0 | null | 2016-03-28T05:16:35 | 2016-03-28T05:02:36 | null | UTF-8 | C++ | false | false | 9,267 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
#include <errno.h>
#include <cstring>
#include "svm.h"
#include "eval.h"
namespace libsvm {
using namespace libsvm;
#define Malloc(type,n) (type *)malloc((n)*sizeof(type))
typedef std::vector<double> dvec_t;
typedef std::vector<int> ivec_t;
// prototypes of evaluation functions
double precision(const dvec_t& dec_values, const ivec_t& ty);
double recall(const dvec_t& dec_values, const ivec_t& ty);
double fscore(const dvec_t& dec_values, const ivec_t& ty);
double bac(const dvec_t& dec_values, const ivec_t& ty);
double auc(const dvec_t& dec_values, const ivec_t& ty);
double accuracy(const dvec_t& dec_values, const ivec_t& ty);
// evaluation function pointer
// You can assign this pointer to any above prototype
double (*validation_function)(const dvec_t&, const ivec_t&) = auc;
static char *line = NULL;
static int max_line_len;
void exit_input_error(int line_num)
{
fprintf(stderr,"Wrong input format at line %d\n", line_num);
exit(1);
}
static char* readline(FILE *input)
{
int len;
if(fgets(line,max_line_len,input) == NULL)
return NULL;
while(strrchr(line,'\n') == NULL)
{
max_line_len *= 2;
line = (char *) realloc(line,max_line_len);
len = (int) strlen(line);
if(fgets(line+len,max_line_len-len,input) == NULL)
break;
}
return line;
}
double precision(const dvec_t& dec_values, const ivec_t& ty){
size_t size = dec_values.size();
size_t i;
int tp, fp;
double precision;
tp = fp = 0;
for(i = 0; i < size; ++i) if(dec_values[i] >= 0){
if(ty[i] == 1) ++tp;
else ++fp;
}
if(tp + fp == 0){
fprintf(stderr, "warning: No positive predict label.\n");
precision = 0;
}else
precision = tp / (double) (tp + fp);
printf("Precision = %g%% (%d/%d)\n", 100.0 * precision, tp, tp + fp);
return precision;
}
double recall(const dvec_t& dec_values, const ivec_t& ty){
size_t size = dec_values.size();
size_t i;
int tp, fn; // true_positive and false_negative
double recall;
tp = fn = 0;
for(i = 0; i < size; ++i) if(ty[i] == 1){ // true label is 1
if(dec_values[i] >= 0) ++tp; // predict label is 1
else ++fn; // predict label is -1
}
if(tp + fn == 0){
fprintf(stderr, "warning: No postive true label.\n");
recall = 0;
}else
recall = tp / (double) (tp + fn);
// print result in case of invocation in prediction
printf("Recall = %g%% (%d/%d)\n", 100.0 * recall, tp, tp + fn);
return recall; // return the evaluation value
}
double fscore(const dvec_t& dec_values, const ivec_t& ty){
size_t size = dec_values.size();
size_t i;
int tp, fp, fn;
double precision, recall;
double fscore;
tp = fp = fn = 0;
for(i = 0; i < size; ++i)
if(dec_values[i] >= 0 && ty[i] == 1) ++tp;
else if(dec_values[i] >= 0 && ty[i] == -1) ++fp;
else if(dec_values[i] < 0 && ty[i] == 1) ++fn;
if(tp + fp == 0){
fprintf(stderr, "warning: No postive predict label.\n");
precision = 0;
}else
precision = tp / (double) (tp + fp);
if(tp + fn == 0){
fprintf(stderr, "warning: No postive true label.\n");
recall = 0;
}else
recall = tp / (double) (tp + fn);
if(precision + recall == 0){
fprintf(stderr, "warning: precision + recall = 0.\n");
fscore = 0;
}else
fscore = 2 * precision * recall / (precision + recall);
printf("F-score = %g\n", fscore);
return fscore;
}
double bac(const dvec_t& dec_values, const ivec_t& ty){
size_t size = dec_values.size();
size_t i;
int tp, fp, fn, tn;
double specificity, recall;
double bac;
tp = fp = fn = tn = 0;
for(i = 0; i < size; ++i)
if(dec_values[i] >= 0 && ty[i] == 1) ++tp;
else if(dec_values[i] >= 0 && ty[i] == -1) ++fp;
else if(dec_values[i] < 0 && ty[i] == 1) ++fn;
else ++tn;
if(tn + fp == 0){
fprintf(stderr, "warning: No negative true label.\n");
specificity = 0;
}else
specificity = tn / (double)(tn + fp);
if(tp + fn == 0){
fprintf(stderr, "warning: No positive true label.\n");
recall = 0;
}else
recall = tp / (double)(tp + fn);
bac = (specificity + recall) / 2;
printf("BAC = %g\n", bac);
return bac;
}
// only for auc
class Comp{
const double *dec_val;
public:
Comp(const double *ptr): dec_val(ptr){}
bool operator()(int i, int j) const{
return dec_val[i] > dec_val[j];
}
};
double auc(const dvec_t& dec_values, const ivec_t& ty){
double roc = 0;
size_t size = dec_values.size();
size_t i;
std::vector<size_t> indices(size);
for(i = 0; i < size; ++i) indices[i] = i;
std::sort(indices.begin(), indices.end(), Comp(&dec_values[0]));
int tp = 0,fp = 0;
for(i = 0; i < size; i++) {
if(ty[indices[i]] == 1) tp++;
else if(ty[indices[i]] == -1) {
roc += tp;
fp++;
}
}
if(tp == 0 || fp == 0)
{
fprintf(stderr, "warning: Too few postive true labels or negative true labels\n");
roc = 0;
}
else
roc = roc / tp / fp;
printf("AUC = %g\n", roc);
return roc;
}
double accuracy(const dvec_t& dec_values, const ivec_t& ty){
int correct = 0;
int total = (int) ty.size();
size_t i;
for(i = 0; i < ty.size(); ++i)
if(ty[i] == (dec_values[i] >= 0? 1: -1)) ++correct;
printf("Accuracy = %g%% (%d/%d)\n",
(double)correct/total*100,correct,total);
return (double) correct / total;
}
double binary_class_cross_validation(const svm_problem *prob, const svm_parameter *param, int nr_fold)
{
int i;
int *fold_start = Malloc(int,nr_fold+1);
int l = prob->l;
int *perm = Malloc(int,l);
int *labels;
dvec_t dec_values;
ivec_t ty;
for(i=0;i<l;i++) perm[i]=i;
for(i=0;i<l;i++)
{
int j = i+rand()%(l-i);
std::swap(perm[i],perm[j]);
}
for(i=0;i<=nr_fold;i++)
fold_start[i]=i*l/nr_fold;
for(i=0;i<nr_fold;i++)
{
int begin = fold_start[i];
int end = fold_start[i+1];
int j,k;
struct svm_problem subprob;
subprob.l = l-(end-begin);
subprob.x = Malloc(struct svm_node*,subprob.l);
subprob.y = Malloc(double,subprob.l);
k=0;
for(j=0;j<begin;j++)
{
subprob.x[k] = prob->x[perm[j]];
subprob.y[k] = prob->y[perm[j]];
++k;
}
for(j=end;j<l;j++)
{
subprob.x[k] = prob->x[perm[j]];
subprob.y[k] = prob->y[perm[j]];
++k;
}
struct svm_model *submodel = svm_train(&subprob,param);
int svm_type = svm_get_svm_type(submodel);
if(svm_type == NU_SVR || svm_type == EPSILON_SVR){
fprintf(stderr, "wrong svm type");
exit(1);
}
labels = Malloc(int, svm_get_nr_class(submodel));
svm_get_labels(submodel, labels);
if(svm_get_nr_class(submodel) > 2)
{
fprintf(stderr,"Error: the number of class is not equal to 2\n");
exit(-1);
}
dec_values.resize(end);
ty.resize(end);
for(j=begin;j<end;j++) {
svm_predict_values(submodel,prob->x[perm[j]], &dec_values[j]);
ty[j] = (prob->y[perm[j]] > 0)? 1: -1;
}
if(labels[0] <= 0) {
for(j=begin;j<end;j++)
dec_values[j] *= -1;
}
svm_free_and_destroy_model(&submodel);
free(subprob.x);
free(subprob.y);
free(labels);
}
free(perm);
free(fold_start);
return validation_function(dec_values, ty);
}
void binary_class_predict(FILE *input, FILE *output){
int total = 0;
int *labels;
int max_nr_attr = 64;
struct svm_node *x = Malloc(struct svm_node, max_nr_attr);
dvec_t dec_values;
ivec_t true_labels;
int svm_type=svm_get_svm_type(model);
if (svm_type==NU_SVR || svm_type==EPSILON_SVR){
fprintf(stderr, "wrong svm type.");
exit(1);
}
labels = Malloc(int, svm_get_nr_class(model));
svm_get_labels(model, labels);
max_line_len = 1024;
line = (char *)malloc(max_line_len*sizeof(char));
while(readline(input) != NULL)
{
int i = 0;
double target_label, predict_label;
char *idx, *val, *label, *endptr;
int inst_max_index = -1; // strtol gives 0 if wrong format, and precomputed kernel has <index> start from 0
label = strtok(line," \t");
target_label = strtod(label,&endptr);
if(endptr == label)
exit_input_error(total+1);
while(1)
{
if(i>=max_nr_attr - 2) // need one more for index = -1
{
max_nr_attr *= 2;
x = (struct svm_node *) realloc(x,max_nr_attr*sizeof(struct svm_node));
}
idx = strtok(NULL,":");
val = strtok(NULL," \t");
if(val == NULL)
break;
errno = 0;
x[i].index = (int) strtol(idx,&endptr,10);
if(endptr == idx || errno != 0 || *endptr != '\0' || x[i].index <= inst_max_index)
exit_input_error(total+1);
else
inst_max_index = x[i].index;
errno = 0;
x[i].value = strtod(val,&endptr);
if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
exit_input_error(total+1);
++i;
}
x[i].index = -1;
predict_label = svm_predict(model,x);
fprintf(output,"%g\n",predict_label);
double dec_value;
svm_predict_values(model, x, &dec_value);
true_labels.push_back((target_label > 0)? 1: -1);
if(labels[0] <= 0) dec_value *= -1;
dec_values.push_back(dec_value);
}
validation_function(dec_values, true_labels);
free(labels);
free(x);
}
} // namespace libsvm
| [
"hemaoliang@163.com"
] | hemaoliang@163.com |
3aee057ef70eb755586c7aab754f75c5733aca9d | 6c6ec1e561cb94b1d34813255c2a0f479f575a64 | /RobotArm_Hardware/ROBOT-MANIPULATORS(HardwareInterfaces)/JOINT6/Main/CentralSystem.ino | 4770371ed640bb6a38be443d135122c80b422356 | [] | no_license | SPECTRE-president/RobotArm | cabbcd1bd96d1de9e047c72eb986efb2a9a70357 | bc12b3fcaca7377fdde6bd75f51ef9c0ab1d5228 | refs/heads/master | 2021-01-10T15:29:23.153044 | 2016-03-04T19:28:07 | 2016-03-04T19:28:07 | 53,160,330 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,408 | ino | void setup()
{
Wire.begin(5); // join i2c bus with address
Wire.onReceive(receiveEvent); // register event
Wire.onRequest(requestEvent); // register event
pinMode(13,OUTPUT); // LED TEST
Serial.begin(9600); // start serial for output
JointSetup(); // Initial motor
}
void loop()
{
if(position_update_release != true){
if(datafail != 3){
datafail = 0;
requestEvent();
//datafail = 100;
}
//Serial.println("UPDATE MODE");
PositionUpdate(UPDATE_POSITION);
}else {
//Serial.println("HOLD MODE");
PositionUpdate(UPDATE_POSITION); //Hold Position.
if(datafail != 3){
datafail = 1;
requestEvent();
//datafail = 100;
}
}
//------------------------------- COMMUNICATION ---------------------------------------
if(incomingdata == true){
//Reset
if(inputString != "RP") //fillter
datafail = 0;
Serial.print("Incoming data is => ");
Serial.println(inputString);
if(inputString == "SZ") //Set position equal to zero.
{
Serial.println("SET ZERO.");
stepper.setCurrentPosition(0);
UPDATE_POSITION = 0;
datafail = 1;
requestEvent();
}else if(inputString == "ST") //Stop motor.
{
digitalWrite(13,HIGH);
datafail = 1;
requestEvent();
}else if(inputString == "CW"){
//TURN MOTOR CW OR UPDATE POSITION
Serial.println("CW");
UPDATE_POSITION += ACCURACY_TRAIN;
datafail = 1;
requestEvent();
}else if(inputString == "AC"){
//TURN MOTOR CWW OR UPDATE POSITION
Serial.println("CWW");
UPDATE_POSITION -= ACCURACY_TRAIN;
datafail = 1;
requestEvent();
}else if(inputString == "RP"){
datafail = 3;
requestEvent();
datafail = 1;
}else if(inputString == "SI"){ //Speed Increase
CONSTANT_SPEED += 200;
if(CONSTANT_SPEED >= 3200)
CONSTANT_SPEED = 3200;
datafail = 1;
requestEvent();
}else if(inputString == "SD"){ //Speed Decrease
CONSTANT_SPEED -= 200;
if(CONSTANT_SPEED <= 0)
CONSTANT_SPEED = 100;
datafail = 1;
requestEvent();
}else if(inputString == "PI"){ //Increase Precision move
ACCURACY_TRAIN += 20;
if(ACCURACY_TRAIN >= 1000)
ACCURACY_TRAIN = 1000;
datafail = 1;
requestEvent();
}else if(inputString == "PD"){ //Decrease Precision move
ACCURACY_TRAIN -= 20;
if(ACCURACY_TRAIN <= 0)
ACCURACY_TRAIN = 1;
datafail = 1;
requestEvent();
}else if(inputString == "AM"){ //Turn with Acceleration
MOVE_WITH_ACCELERATION = true;
datafail = 1;
requestEvent();
}else if(inputString == "NM"){ //Turn without Acceleration(Constant)
MOVE_WITH_ACCELERATION = false;
datafail = 1;
requestEvent();
}else { //Move motor to expect position.
UPDATE_POSITION = inputString.toInt();
digitalWrite(13,LOW);
reset();
}
incomingdata = false;
}
//------------------------------------------------------------------------------------
}//END VOIDLOOP
| [
"JPH.SPECTRE@GMAIL.COM"
] | JPH.SPECTRE@GMAIL.COM |
1e710813b69d2460cf26d9acd0693e06305a4eb7 | b33921433df41d5e5a92367413d178aee6fcc627 | /CPP_CodeSignal/evenDigitsOnly.cpp | 36a05f252cdae01630c07f7cc581bb5e4eb06e25 | [] | no_license | chanduk5/CPP_Edabit | 93e3604b42e35b0f7d0c55503f9e369b35c9f6a0 | 01460a944a95114f73ff547082fb856ad2f4446b | refs/heads/master | 2020-12-22T22:17:23.934974 | 2020-02-26T09:12:56 | 2020-02-26T09:12:56 | 236,943,450 | 1 | 0 | null | 2020-02-26T09:12:57 | 2020-01-29T09:15:57 | C++ | UTF-8 | C++ | false | false | 382 | cpp | #include<iostream>
using namespace std;
bool evenDigitsOnly(int n) {
while (n != 0)
{
if (((n % 10) % 2) != 0)
{
return false;
}
n = n / 10;
}
return true;
}
void evenDigitsOnly(void)
{
int n;
cout << "Enter the number: ";
cin >> n;
cout << "Even digits only in the number: " << evenDigitsOnly(n);
}
| [
"kurapatichandu535@gmail.com"
] | kurapatichandu535@gmail.com |
5ab5af4de84aaa1c7ba2515f6a7fcc1fbf455948 | b3239097cad0e28dfce355fa1e6f5a6fd12c10f4 | /939B.cpp | d57c2505cab5a98f777a7eed42605b6c93fa5ad1 | [] | no_license | trinhtanphat/Codeforces | da52d4efae03fa8f20564a3062cf7fde8ff3224d | c52cd4749f1c1dd38a0f0140250e6d8e96181037 | refs/heads/master | 2023-04-12T11:34:04.121808 | 2018-11-10T19:36:01 | 2018-11-10T19:36:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 404 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX_N = 1e5+7;
const ll oo = 1e18;
ll n, a[MAX_N], res;
int k;
int main() {
freopen("input.txt","r",stdin);
cin>>n>>k;
for (int i=0; i<k; i++) {
cin>>a[i];
}
res = oo;
int v = -1;
for (int i=0; i<k; i++) {
ll m = n%a[i];
if (m < res) {
res = m;
v = i;
}
}
cout<<v+1<<' '<<n/a[v]<<endl;
return 0;
} | [
"dphi999@gmail.com"
] | dphi999@gmail.com |
f05d8393d92915e6fb56e1f1219d82102be8bc15 | 2b9bd728c02f9f711cf6bf1836402814ae459558 | /Term5/mpi/m_quit.cpp | c5b888b74f5463446c196aa4a286525d6ac5bdf4 | [] | no_license | DeSerg/mipt-solutions | 20f5dcb3a441e8d9363dcfd11cf9dbf05848a5ab | 6851d572affde1540d1a16983cb5a77cf9b7ca74 | refs/heads/master | 2021-01-17T02:29:11.406570 | 2019-12-08T16:29:53 | 2019-12-08T16:29:53 | 25,125,104 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 827 | cpp | #include "support.h"
extern int K, N, M;
extern Status status;
extern int world_rank, world_size;
extern int work_rank, work_size;
extern MPI_Comm intercomm;
void quitMethod() {
//Завершение программы с корректной приостановкой потоков
cerr << "master: on quit..." << endl;
vector<MPI_Request> req(world_size - 1);
for (int i = 1; i < world_size; ++i) {
MPI_Isend(NULL, 0, MPI_INT, i, quit_tag, MPI_COMM_WORLD, &(req[i - 1]));
}
cerr << "master: waiting workers to quit..." << endl;
for (int i = 0; i < work_size; ++i) {
MPI_Wait(&req[i], MPI_STATUS_IGNORE);
}
cerr << "master: workers are quitting" << endl;
if (status == running) {
stopMethod();
}
status = on_quit;
}
| [
"sergpopov95@gmail.com"
] | sergpopov95@gmail.com |
8806f7d234a55e3426ef0c27b9178e52fa873fd0 | 2962f164cecb440ecd905ab9f3cc569c03a01ad5 | /RtspPlayer/assemblies/sunell/include/AlarmLogQueryParam.h | d9a4e9718c881b085660d0a04f8440aa04b53788 | [] | no_license | paxan222/hello-world | 5ef9bd04a5c4337c1403a04973e2c0c11665bb26 | c55c60e0f72a04e1e2560dc19c2a6bbd7e8b430f | refs/heads/master | 2020-12-11T21:09:30.200433 | 2017-05-04T08:39:53 | 2017-05-04T08:39:53 | 55,044,669 | 0 | 1 | null | null | null | null | GB18030 | C++ | false | false | 7,936 | h | #ifndef _ALARMLOGQUERYPARAM_H_
#define _ALARMLOGQUERYPARAM_H_
#include "DomainConst.h"
#include "const.h"
#include "SNPlatOS.h"
/**********************************************************************/
//此处用于控制文件编译字节对齐，拷贝时两行注释间内容需一起拷贝，
//结束处的“#ifdef PRAGMA_PACK”部分也要一起拷贝，否则pragma pack入栈出栈不匹配
#if(PRAGMA_PACK_DEFINE != 10000)
# error Not included "SNPlatOS.h".
#endif
#ifdef PRAGMA_PACK
#ifdef WIN32
#pragma pack(push, PRAGMA_PACK_CHAR)
#endif
#ifndef WIN32
#ifndef _PACKED_1_
#define _PACKED_1_ __attribute__((packed, aligned(PRAGMA_PACK_CHAR))) // for gcc
#endif
#else
#ifndef _PACKED_1_
#define _PACKED_1_
#endif
#endif
#else
#ifndef _PACKED_1_
#define _PACKED_1_
#endif
#endif
/**********************************************************************/
class SN_DLL_API AlarmLogQueryParam
{
public:
AlarmLogQueryParam();
~AlarmLogQueryParam();
//拷贝构造函数
AlarmLogQueryParam(const AlarmLogQueryParam& p_objAlarmLogQueryParam);
public:
/**********************************************************************
**概述：
* 设置网络视频设备的设备ID
**输入：
* p_pszDeviceId ：字符串，最大长度为CONST_MAXLENGTH_DEVICEID字节,
* 结尾以‘\0’结束。
**输出：
* 无
**返回值：
* true ： 成功
* false：失败
**功能：
* 若输入p_pszDeviceId长度<=CONST_MAXLENGTH_DEVICEID，返回true，
* 并保存到m_szDeviceId;
* 若输入p_pszDeviceId为NULL或其长度>CONST_MAXLENGTH_DEVICEID，返回false
************************************************************************/
bool setDeviceId(const char *p_pszDeviceId);
/************************************************************************
**概述：
* 获取网络视频设备的设备ID
**输入：
* 无
**输出：
* 无
**返回值：
* 设备ID
**功能：
*
***************************************************************************/
const char* getDeviceId() const;
/**********************************************************************
**概述：
* 设置设备IP地址
**输入：
* p_nDeviceIp ：设备IP地址
**输出：
* 无
**返回值：
* 无
**功能：
*
************************************************************************/
bool setDeviceIp(const char * p_pszDeviceIp);
/************************************************************************
**概述：
* 获取设备IP地址
**输入：
* 无
**输出：
* 无
**返回值：
* 设备IP地址
**功能：
*
**************************************************************************/
const char * getDeviceIp() const;
/**********************************************************************
**概述：
* 设置报警源ID
**输入：
* p_pszSourceId ：报警源ID
**输出：
* 无
**返回值：
* 无
**功能：
*
************************************************************************/
bool setSourceId(const char * p_pszSourceId);
/************************************************************************
**概述：
* 获取报警源ID
**输入：
* 无
**输出：
* 无
**返回值：
* 报警源ID
**功能：
*
**************************************************************************/
const char * getSourceId() const;
/**********************************************************************
**概述：
* 设置开始时间
**输入：
* p_nStartTime：开始时间
**输出：
* 无
**返回值：
* 无
**功能：
*
************************************************************************/
void setStartTime(const unsigned long p_nStartTime);
/************************************************************************
**概述：
* 获取开始时间
**输入：
* 无
**输出：
* 无
**返回值：
* 开始时间
**功能：
*
**************************************************************************/
unsigned long getStartTime() const;
/**********************************************************************
**概述：
* 设置结束时间
**输入：
* p_nEndTime ：结束时间
**输出：
* 无
**返回值：
* 无
**功能：
*
************************************************************************/
void setEndTime(const unsigned long p_nEndTime);
/************************************************************************
**概述：
* 获取结束时间
**输入：
* 无
**输出：
* 无
**返回值：
* 结束时间
**功能：
*
**************************************************************************/
unsigned long getEndTime() const;
/**********************************************************************
**概述：
* 设置报警类型
**输入：
* p_nAlarmType ：报警类型
**输出：
* 无
**返回值：
* 无
**功能：
*
************************************************************************/
void setAlarmType(const int p_nAlarmType);
/************************************************************************
**概述：
* 获取报警类型
**输入：
* 无
**输出：
* 无
**返回值：
* 报警类型
**功能：
*
**************************************************************************/
int getAlarmType() const;
/**********************************************************************
**概述：
* 设置报警主类型
**输入：
* p_nAlarmMajorType ：报警主类型
**输出：
* 无
**返回值：
* 无
**功能：
*
************************************************************************/
void setAlarmMajorType(const int p_nAlarmMajorType);
/************************************************************************
**概述：
* 获取报警主类型
**输入：
* 无
**输出：
* 无
**返回值：
* 报警主类型
**功能：
*
**************************************************************************/
int getAlarmMajorType() const;
/**********************************************************************
**概述：
* 设置报警子类型
**输入：
* p_nAlarmMinorType ：报警子类型
**输出：
* 无
**返回值：
* 无
**功能：
*
************************************************************************/
void setAlarmMinorType(const int p_nAlarmMinorType);
/************************************************************************
**概述：
* 获取报警子类型
**输入：
* 无
**输出：
* 无
**返回值：
* 报警子类型
**功能：
*
**************************************************************************/
int getAlarmMinorType() const;
/****************************************************************************
**概述：
* 赋值函数
**输入：
* p_objAlarmLogQueryParam：报警日志查询参数对象
**输出：
* 无
**返回值：
* 赋值后的报警日志查询参数对象
**功能：
*
*****************************************************************************/
AlarmLogQueryParam& operator = (const AlarmLogQueryParam &p_objAlarmLogQueryParam);
private:
char m_szDeviceId[CONST_MAXLENGTH_DEVICEID + 1]; //设备ID
char m_szDeviceIp[CONST_MAXLENGTH_IP + 1]; //设备IP
char m_szSourceId[CONST_MAXLENGTH_ALARM_SOURCE_ID + 1]; //源ID
long m_nStartTime; //开始时间
long m_nEndTime; //结束时间
int m_nAlarmType; //报警类型(old)
int m_nMajorType; //报警主类型(new)
int m_nMinorType; //报警子类型(new)
}_PACKED_1_;
/**********************************************************************/
#ifdef PRAGMA_PACK
#ifdef WIN32
#pragma pack(pop)
#endif
#endif
/**********************************************************************/
#endif //_ALARMLOGQUERYPARAM_H_
| [
"paxan222@yandex.ru"
] | paxan222@yandex.ru |
b0d2fb49bd805b6bd4864c925cf46cd5914ad0f9 | fa3050f5e5ee850ba39ccb602804c001d9b4dede | /chromeos/components/eche_app_ui/eche_app_manager.cc | 84acce45c7f7558cf2498bbe42c19b92b96dfad9 | [
"BSD-3-Clause"
] | permissive | wayou/chromium | a64c9df7d9c6190f8f9f730e7f68a998ffcabfc9 | f5f51fc460df28cef915df71b4161aaa6b668004 | refs/heads/main | 2023-06-27T18:09:41.425496 | 2021-09-08T23:02:28 | 2021-09-08T23:02:28 | 404,525,907 | 1 | 0 | BSD-3-Clause | 2021-09-08T23:38:08 | 2021-09-08T23:38:08 | null | UTF-8 | C++ | false | false | 4,391 | cc | // Copyright 2021 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/components/eche_app_ui/eche_app_manager.h"
#include "base/system/sys_info.h"
#include "chromeos/components/eche_app_ui/eche_signaler.h"
#include "chromeos/components/eche_app_ui/eche_uid_provider.h"
#include "chromeos/components/eche_app_ui/launch_app_helper.h"
#include "chromeos/components/eche_app_ui/system_info.h"
#include "chromeos/components/eche_app_ui/system_info_provider.h"
#include "chromeos/components/phonehub/phone_hub_manager.h"
#include "chromeos/services/secure_channel/public/cpp/client/connection_manager_impl.h"
namespace chromeos {
namespace {
const char kSecureChannelFeatureName[] = "eche";
const char kMetricNameResult[] = "Eche.Connection.Result";
const char kMetricNameDuration[] = "Eche.Connection.Duration";
const char kMetricNameLatency[] = "Eche.Connectivity.Latency";
} // namespace
namespace eche_app {
EcheAppManager::EcheAppManager(
PrefService* pref_service,
std::unique_ptr<SystemInfo> system_info,
phonehub::PhoneHubManager* phone_hub_manager,
device_sync::DeviceSyncClient* device_sync_client,
multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client,
secure_channel::SecureChannelClient* secure_channel_client,
LaunchAppHelper::LaunchEcheAppFunction launch_eche_app_function,
LaunchAppHelper::CloseEcheAppFunction close_eche_app_function,
LaunchAppHelper::LaunchNotificationFunction launch_notification_function)
: connection_manager_(
std::make_unique<secure_channel::ConnectionManagerImpl>(
multidevice_setup_client,
device_sync_client,
secure_channel_client,
kSecureChannelFeatureName,
kMetricNameResult,
kMetricNameLatency,
kMetricNameDuration)),
feature_status_provider_(std::make_unique<EcheFeatureStatusProvider>(
phone_hub_manager,
device_sync_client,
multidevice_setup_client,
connection_manager_.get())),
launch_app_helper_(
std::make_unique<LaunchAppHelper>(phone_hub_manager,
launch_eche_app_function,
close_eche_app_function,
launch_notification_function)),
eche_notification_click_handler_(
std::make_unique<EcheNotificationClickHandler>(
phone_hub_manager,
feature_status_provider_.get(),
launch_app_helper_.get())),
eche_connector_(
std::make_unique<EcheConnector>(feature_status_provider_.get(),
connection_manager_.get())),
signaler_(std::make_unique<EcheSignaler>(eche_connector_.get(),
connection_manager_.get())),
system_info_provider_(
std::make_unique<SystemInfoProvider>(std::move(system_info))),
uid_(std::make_unique<EcheUidProvider>(pref_service)),
eche_recent_app_click_handler_(
std::make_unique<EcheRecentAppClickHandler>(
phone_hub_manager,
feature_status_provider_.get(),
launch_app_helper_.get())) {}
EcheAppManager::~EcheAppManager() = default;
void EcheAppManager::BindSignalingMessageExchangerInterface(
mojo::PendingReceiver<mojom::SignalingMessageExchanger> receiver) {
signaler_->Bind(std::move(receiver));
}
void EcheAppManager::BindSystemInfoProviderInterface(
mojo::PendingReceiver<mojom::SystemInfoProvider> receiver) {
system_info_provider_->Bind(std::move(receiver));
}
void EcheAppManager::BindUidGeneratorInterface(
mojo::PendingReceiver<mojom::UidGenerator> receiver) {
uid_->Bind(std::move(receiver));
}
// NOTE: These should be destroyed in the opposite order of how these objects
// are initialized in the constructor.
void EcheAppManager::Shutdown() {
eche_recent_app_click_handler_.reset();
uid_.reset();
system_info_provider_.reset();
signaler_.reset();
eche_connector_.reset();
eche_notification_click_handler_.reset();
launch_app_helper_.reset();
feature_status_provider_.reset();
connection_manager_.reset();
}
} // namespace eche_app
} // namespace chromeos
| [
"chromium-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | chromium-scoped@luci-project-accounts.iam.gserviceaccount.com |
f7c72ebe1f033b968c4a891c1a72c2a7987cb386 | 67fc9e51437e351579fe9d2d349040c25936472a | /wrappers/7.0.0/vtkExtractSelectedGraphWrap.cc | f7a20507262ccbc2a2776d382004723bd7475eb0 | [] | permissive | axkibe/node-vtk | 51b3207c7a7d3b59a4dd46a51e754984c3302dec | 900ad7b5500f672519da5aa24c99aa5a96466ef3 | refs/heads/master | 2023-03-05T07:45:45.577220 | 2020-03-30T09:31:07 | 2020-03-30T09:31:07 | 48,490,707 | 6 | 0 | BSD-3-Clause | 2022-12-07T20:41:45 | 2015-12-23T12:58:43 | C++ | UTF-8 | C++ | false | false | 11,463 | cc | /* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */
#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>
#include "vtkGraphAlgorithmWrap.h"
#include "vtkExtractSelectedGraphWrap.h"
#include "vtkObjectWrap.h"
#include "vtkAlgorithmOutputWrap.h"
#include "vtkInformationWrap.h"
#include "../../plus/plus.h"
using namespace v8;
extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkExtractSelectedGraphWrap::ptpl;
VtkExtractSelectedGraphWrap::VtkExtractSelectedGraphWrap()
{ }
VtkExtractSelectedGraphWrap::VtkExtractSelectedGraphWrap(vtkSmartPointer<vtkExtractSelectedGraph> _native)
{ native = _native; }
VtkExtractSelectedGraphWrap::~VtkExtractSelectedGraphWrap()
{ }
void VtkExtractSelectedGraphWrap::Init(v8::Local<v8::Object> exports)
{
Nan::SetAccessor(exports, Nan::New("vtkExtractSelectedGraph").ToLocalChecked(), ConstructorGetter);
Nan::SetAccessor(exports, Nan::New("ExtractSelectedGraph").ToLocalChecked(), ConstructorGetter);
}
void VtkExtractSelectedGraphWrap::ConstructorGetter(
v8::Local<v8::String> property,
const Nan::PropertyCallbackInfo<v8::Value>& info)
{
InitPtpl();
info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}
void VtkExtractSelectedGraphWrap::InitPtpl()
{
if (!ptpl.IsEmpty()) return;
v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
VtkGraphAlgorithmWrap::InitPtpl( );
tpl->Inherit(Nan::New<FunctionTemplate>(VtkGraphAlgorithmWrap::ptpl));
tpl->SetClassName(Nan::New("VtkExtractSelectedGraphWrap").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1);
Nan::SetPrototypeMethod(tpl, "FillInputPortInformation", FillInputPortInformation);
Nan::SetPrototypeMethod(tpl, "fillInputPortInformation", FillInputPortInformation);
Nan::SetPrototypeMethod(tpl, "GetClassName", GetClassName);
Nan::SetPrototypeMethod(tpl, "getClassName", GetClassName);
Nan::SetPrototypeMethod(tpl, "GetRemoveIsolatedVertices", GetRemoveIsolatedVertices);
Nan::SetPrototypeMethod(tpl, "getRemoveIsolatedVertices", GetRemoveIsolatedVertices);
Nan::SetPrototypeMethod(tpl, "IsA", IsA);
Nan::SetPrototypeMethod(tpl, "isA", IsA);
Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);
Nan::SetPrototypeMethod(tpl, "RemoveIsolatedVerticesOff", RemoveIsolatedVerticesOff);
Nan::SetPrototypeMethod(tpl, "removeIsolatedVerticesOff", RemoveIsolatedVerticesOff);
Nan::SetPrototypeMethod(tpl, "RemoveIsolatedVerticesOn", RemoveIsolatedVerticesOn);
Nan::SetPrototypeMethod(tpl, "removeIsolatedVerticesOn", RemoveIsolatedVerticesOn);
Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);
Nan::SetPrototypeMethod(tpl, "SetAnnotationLayersConnection", SetAnnotationLayersConnection);
Nan::SetPrototypeMethod(tpl, "setAnnotationLayersConnection", SetAnnotationLayersConnection);
Nan::SetPrototypeMethod(tpl, "SetRemoveIsolatedVertices", SetRemoveIsolatedVertices);
Nan::SetPrototypeMethod(tpl, "setRemoveIsolatedVertices", SetRemoveIsolatedVertices);
Nan::SetPrototypeMethod(tpl, "SetSelectionConnection", SetSelectionConnection);
Nan::SetPrototypeMethod(tpl, "setSelectionConnection", SetSelectionConnection);
#ifdef VTK_NODE_PLUS_VTKEXTRACTSELECTEDGRAPHWRAP_INITPTPL
VTK_NODE_PLUS_VTKEXTRACTSELECTEDGRAPHWRAP_INITPTPL
#endif
ptpl.Reset( tpl );
}
void VtkExtractSelectedGraphWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
if(!info.IsConstructCall())
{
Nan::ThrowError("Constructor not called in a construct call.");
return;
}
if(info.Length() == 0)
{
vtkSmartPointer<vtkExtractSelectedGraph> native = vtkSmartPointer<vtkExtractSelectedGraph>::New();
VtkExtractSelectedGraphWrap* obj = new VtkExtractSelectedGraphWrap(native);
obj->Wrap(info.This());
}
else
{
if(info[0]->ToObject() != vtkNodeJsNoWrap )
{
Nan::ThrowError("Parameter Error");
return;
}
}
info.GetReturnValue().Set(info.This());
}
void VtkExtractSelectedGraphWrap::FillInputPortInformation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsInt32())
{
if(info.Length() > 1 && info[1]->IsObject() && (Nan::New(VtkInformationWrap::ptpl))->HasInstance(info[1]))
{
VtkInformationWrap *a1 = ObjectWrap::Unwrap<VtkInformationWrap>(info[1]->ToObject());
int r;
if(info.Length() != 2)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->FillInputPortInformation(
info[0]->Int32Value(),
(vtkInformation *) a1->native.GetPointer()
);
info.GetReturnValue().Set(Nan::New(r));
return;
}
}
Nan::ThrowError("Parameter mismatch");
}
void VtkExtractSelectedGraphWrap::GetClassName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
char const * r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetClassName();
info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}
void VtkExtractSelectedGraphWrap::GetRemoveIsolatedVertices(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
bool r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->GetRemoveIsolatedVertices();
info.GetReturnValue().Set(Nan::New(r));
}
void VtkExtractSelectedGraphWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsString())
{
Nan::Utf8String a0(info[0]);
int r;
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->IsA(
*a0
);
info.GetReturnValue().Set(Nan::New(r));
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkExtractSelectedGraphWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
vtkExtractSelectedGraph * r;
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->NewInstance();
VtkExtractSelectedGraphWrap::InitPtpl();
v8::Local<v8::Value> argv[1] =
{ Nan::New(vtkNodeJsNoWrap) };
v8::Local<v8::Function> cons =
Nan::New<v8::FunctionTemplate>(VtkExtractSelectedGraphWrap::ptpl)->GetFunction();
v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
VtkExtractSelectedGraphWrap *w = new VtkExtractSelectedGraphWrap();
w->native = r;
w->Wrap(wo);
info.GetReturnValue().Set(wo);
}
void VtkExtractSelectedGraphWrap::RemoveIsolatedVerticesOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->RemoveIsolatedVerticesOff();
}
void VtkExtractSelectedGraphWrap::RemoveIsolatedVerticesOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
if(info.Length() != 0)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->RemoveIsolatedVerticesOn();
}
void VtkExtractSelectedGraphWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectWrap::ptpl))->HasInstance(info[0]))
{
VtkObjectWrap *a0 = ObjectWrap::Unwrap<VtkObjectWrap>(info[0]->ToObject());
vtkExtractSelectedGraph * r;
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
r = native->SafeDownCast(
(vtkObject *) a0->native.GetPointer()
);
VtkExtractSelectedGraphWrap::InitPtpl();
v8::Local<v8::Value> argv[1] =
{ Nan::New(vtkNodeJsNoWrap) };
v8::Local<v8::Function> cons =
Nan::New<v8::FunctionTemplate>(VtkExtractSelectedGraphWrap::ptpl)->GetFunction();
v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
VtkExtractSelectedGraphWrap *w = new VtkExtractSelectedGraphWrap();
w->native = r;
w->Wrap(wo);
info.GetReturnValue().Set(wo);
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkExtractSelectedGraphWrap::SetAnnotationLayersConnection(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkAlgorithmOutputWrap::ptpl))->HasInstance(info[0]))
{
VtkAlgorithmOutputWrap *a0 = ObjectWrap::Unwrap<VtkAlgorithmOutputWrap>(info[0]->ToObject());
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetAnnotationLayersConnection(
(vtkAlgorithmOutput *) a0->native.GetPointer()
);
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkExtractSelectedGraphWrap::SetRemoveIsolatedVertices(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsBoolean())
{
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetRemoveIsolatedVertices(
info[0]->BooleanValue()
);
return;
}
Nan::ThrowError("Parameter mismatch");
}
void VtkExtractSelectedGraphWrap::SetSelectionConnection(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
VtkExtractSelectedGraphWrap *wrapper = ObjectWrap::Unwrap<VtkExtractSelectedGraphWrap>(info.Holder());
vtkExtractSelectedGraph *native = (vtkExtractSelectedGraph *)wrapper->native.GetPointer();
if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkAlgorithmOutputWrap::ptpl))->HasInstance(info[0]))
{
VtkAlgorithmOutputWrap *a0 = ObjectWrap::Unwrap<VtkAlgorithmOutputWrap>(info[0]->ToObject());
if(info.Length() != 1)
{
Nan::ThrowError("Too many parameters.");
return;
}
native->SetSelectionConnection(
(vtkAlgorithmOutput *) a0->native.GetPointer()
);
return;
}
Nan::ThrowError("Parameter mismatch");
}
| [
"axkibe@gmail.com"
] | axkibe@gmail.com |
cebc719ade9bed12a22a2ad820dad3821d7d1fb0 | 696aa5c9fd54318b552933a917183f7f0647d193 | /lib/ros_lib/champ_msgs/Contacts.h | 800a16e8b43f47d3f7f231cd5de68296c37ddb8a | [] | no_license | mattwilliamson/champ-firmware | 1d38d5f2e9d1b8fb3e0b817bddabde926f2b3fe6 | 7cde708fc0a1509ed878df20e79caa0695963aa2 | refs/heads/master | 2023-04-07T06:46:34.192489 | 2020-09-12T15:01:41 | 2020-09-12T15:01:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,402 | h | #ifndef _ROS_champ_msgs_Contacts_h
#define _ROS_champ_msgs_Contacts_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace champ_msgs
{
class Contacts : public ros::Msg
{
public:
uint32_t contacts_length;
typedef bool _contacts_type;
_contacts_type st_contacts;
_contacts_type * contacts;
Contacts():
contacts_length(0), contacts(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->contacts_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->contacts_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->contacts_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->contacts_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->contacts_length);
for( uint32_t i = 0; i < contacts_length; i++){
union {
bool real;
uint8_t base;
} u_contactsi;
u_contactsi.real = this->contacts[i];
*(outbuffer + offset + 0) = (u_contactsi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->contacts[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t contacts_lengthT = ((uint32_t) (*(inbuffer + offset)));
contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
contacts_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->contacts_length);
if(contacts_lengthT > contacts_length)
this->contacts = (bool*)realloc(this->contacts, contacts_lengthT * sizeof(bool));
contacts_length = contacts_lengthT;
for( uint32_t i = 0; i < contacts_length; i++){
union {
bool real;
uint8_t base;
} u_st_contacts;
u_st_contacts.base = 0;
u_st_contacts.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_contacts = u_st_contacts.real;
offset += sizeof(this->st_contacts);
memcpy( &(this->contacts[i]), &(this->st_contacts), sizeof(bool));
}
return offset;
}
const char * getType(){ return "champ_msgs/Contacts"; };
const char * getMD5(){ return "3470d51bc28d5527f9ed97eb122d52f4"; };
};
}
#endif | [
"jimenojmm@gmail.com"
] | jimenojmm@gmail.com |
6b8298bc2535b5eebaff1ff37fd507e781bfc8c9 | 7d228f077214f798c1fa6ee2a486a25c01d72cce | /xic/src/edit/edit.cc | 6352f41338765b230703af1a727533d9d6dc229d | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | Plourde-Research-Lab/xictools | 1f3de596f5de4d9c9c5fab2a021e530f1f258ce9 | 070b9089607f9a99aabe8d11849b0e4d1fe4fcb8 | refs/heads/master | 2021-07-08T13:21:29.734753 | 2017-10-04T16:08:10 | 2017-10-04T16:08:10 | 106,029,821 | 0 | 1 | null | 2017-10-06T17:04:21 | 2017-10-06T17:04:21 | null | UTF-8 | C++ | false | false | 17,006 | cc |
/*========================================================================*
* *
* Distributed by Whiteley Research Inc., Sunnyvale, California, USA *
* http://wrcad.com *
* Copyright (C) 2017 Whiteley Research Inc., all rights reserved. *
* Author: Stephen R. Whiteley, except as indicated. *
* *
* As fully as possible recognizing licensing terms and conditions *
* imposed by earlier work from which this work was derived, if any, *
* this work is released under the Apache License, Version 2.0 (the *
* "License"). You may not use this file except in compliance with *
* the License, and compliance with inherited licenses which are *
* specified in a sub-header below this one if applicable. A copy *
* of the License is provided with this distribution, or you may *
* obtain a copy of the License at *
* *
* http://www.apache.org/licenses/LICENSE-2.0 *
* *
* See the License for the specific language governing permissions *
* and limitations under the License. *
* *
* 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 NON- *
* INFRINGEMENT. IN NO EVENT SHALL WHITELEY RESEARCH INCORPORATED *
* OR STEPHEN R. WHITELEY 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. *
* *
*========================================================================*
* XicTools Integrated Circuit Design System *
* *
* Xic Integrated Circuit Layout and Schematic Editor *
* *
*========================================================================*
$Id:$
*========================================================================*/
#include "config.h"
#include "main.h"
#include "fio.h"
#include "edit.h"
#include "edit_menu.h"
#include "extif.h"
#include "undolist.h"
#include "dsp_inlines.h"
#include "ghost.h"
#include "tech.h"
#include "promptline.h"
#include "pushpop.h"
#include "menu.h"
#include "edit_menu.h"
#include "events.h"
#include "grip.h"
#include "errorlog.h"
namespace {
// This is called when the standard via table is created, on
// addition of the first standard via. This will un-gray the menu
// entry.
//
void via_notify(bool b)
{
if (DSP()->CurMode() == Physical) {
MenuBox *mb = Menu()->FindMainMenu("edit");
if (mb)
Menu()->SetSensitive(mb->menu[editMenuCrvia].cmd.caller, b);
}
}
}
cEdit::cEdit()
{
ed_object_list = 0;
ed_press_layer = 0;
ed_popup = 0;
ed_menu_head = 0;
ed_push_data = 0;
ed_pcsuper = 0;
ed_pcparams = 0;
ed_cur_grip = 0;
ed_gripdb = 0;
ed_wire_style = CDWIRE_EXTEND;
ed_move_or_copy = CDmove;
ed_lchange_mode = LCHGnone;
ed_label_x = 0;
ed_label_y = 0;
ed_label_width = 0;
ed_label_height = 0;
ed_label_xform = 0;
ed_place_ref = PL_ORIGIN;
ed_stretch_box_code = 0;
ed_h_justify = 0;
ed_v_justify = 0;
ed_menu_len = 0;
ed_auto_abut_mode = AbutMode1;
ed_hide_grips = false;
ed_replacing = false;
ed_use_array = false;
ed_no_wire_width_mag = false;
for (int i = 0; i < ED_YANK_DEPTH; i++)
ed_yank_buffer[i] = 0;
for (int i = 0; i < ED_LEXPR_STORES; i++)
ed_lexpr_stores[i] = 0;
// Instantiate ghosting.
new cEditGhost;
// Instantiate undo processing.
new cUndoList;
setupBangCmds();
setupVariables();
initMainState();
loadScriptFuncs();
Tech()->RegisterHasStdVia(&via_notify);
}
// Set the editing capability on/off in accord with the immutable flag
// of the current cell. If there is no current cell, the passed
// argument state is used.
//
void
cEdit::setEditingMode(bool edit)
{
CDs *sd = CurCell(DSP()->CurMode());
if (sd)
edit = !sd->isImmutable();
if (DSP()->MainWdesc()->DbType() != WDcddb)
return;
if (edit) {
Menu()->HideButtonMenu(false);
Menu()->DisableMainMenuItem("edit", MenuFLATN, false);
Menu()->DisableMainMenuItem("edit", MenuJOIN, false);
Menu()->DisableMainMenuItem("edit", MenuLEXPR, false);
Menu()->DisableMainMenuItem("edit", MenuPRPTY, false);
Menu()->DisableMainMenuItem("edit", MenuCPROP, false);
Menu()->DisableMainMenuItem("mod", 0, false);
Menu()->MenuButtonSet("edit", MenuCEDIT, true);
}
else {
EV()->InitCallback();
Menu()->HideButtonMenu(true);
EditIf()->ulListFinalize(false);
Menu()->DisableMainMenuItem("edit", MenuFLATN, true);
Menu()->DisableMainMenuItem("edit", MenuJOIN, true);
Menu()->DisableMainMenuItem("edit", MenuLEXPR, true);
Menu()->DisableMainMenuItem("edit", MenuPRPTY, true);
Menu()->DisableMainMenuItem("edit", MenuCPROP, true);
Menu()->DisableMainMenuItem("mod", 0, true);
Menu()->MenuButtonSet("edit", MenuCEDIT, false);
}
XM()->PopUpCells(0, MODE_UPD);
}
// This should be called on entering editing commands, and the command
// should abort on a true return. Program modes that prohibit editing
// should be checked here.
//
bool
cEdit::noEditing()
{
if (DSP()->CurMode() == Physical && ExtIf()->isExtractionView()) {
PL()->ShowPrompt("No editing in Extraction View!");
return (true);
}
return (false);
}
//-----------------------------------------------------------------------------
// Misc wrappers
namespace ed_edit {
// This holds state for mode switching.
//
struct sEditState
{
sEditState()
{
PhysCX = ElecCX = 0;
PhysUL = ElecUL = 0;
}
CXstate *PhysCX;
CXstate *ElecCX;
ULstate *PhysUL;
ULstate *ElecUL;
};
}
void
cEdit::invalidateLayer(CDs *sd, CDl *ld)
{
Ulist()->InvalidateLayer(sd, ld);
PP()->InvalidateLayer(sd, ld);
ed_edit::sEditState *es = XM()->hist().editState();
if (es) {
if (es->PhysUL) {
Oper::purge(es->PhysUL->operations, sd, ld);
Oper::purge(es->PhysUL->redo_list, sd, ld);
}
if (es->ElecUL) {
Oper::purge(es->ElecUL->operations, sd, ld);
Oper::purge(es->ElecUL->redo_list, sd, ld);
}
if (es->PhysCX) {
es->PhysCX->context->purge(sd, ld);
es->PhysCX->context_history->purge(sd, ld);
}
if (es->ElecCX) {
es->ElecCX->context->purge(sd, ld);
es->ElecCX->context_history->purge(sd, ld);
}
}
}
void
cEdit::invalidateObject(CDs *sd, CDo *od, bool save)
{
Ulist()->InvalidateObject(sd, od, save);
PP()->InvalidateObject(sd, od, save);
if (!sd)
return;
ed_edit::sEditState *es = XM()->hist().editState();
if (es) {
if (es->PhysUL) {
Oper::purge(es->PhysUL->operations, sd, od);
Oper::purge(es->PhysUL->redo_list, sd, od);
}
if (es->ElecUL) {
Oper::purge(es->ElecUL->operations, sd, od);
Oper::purge(es->ElecUL->redo_list, sd, od);
}
if (es->PhysCX) {
es->PhysCX->context =
es->PhysCX->context->purge(sd, od);
es->PhysCX->context_history =
es->PhysCX->context_history->purge(sd, od);
}
if (es->ElecCX) {
es->ElecCX->context =
es->ElecCX->context->purge(sd, od);
es->ElecCX->context_history =
es->ElecCX->context_history->purge(sd, od);
}
}
}
void
cEdit::clearSaveState()
{
delete XM()->hist().editState();
XM()->hist().setEditState(0);
}
void
cEdit::popState(DisplayMode mode)
{
ed_edit::sEditState *es = XM()->hist().editState();
if (!es) {
es = new ed_edit::sEditState;
XM()->hist().setEditState(es);
}
if (mode == Physical) {
es->PhysCX = PP()->PopState();
es->PhysUL = Ulist()->PopState();
}
else {
es->ElecCX = PP()->PopState();
es->ElecUL = Ulist()->PopState();
}
}
void
cEdit::pushState(DisplayMode mode)
{
ed_edit::sEditState *es = XM()->hist().editState();
if (es) {
if (mode == Physical) {
PP()->PushState(es->PhysCX);
es->PhysCX = 0;
Ulist()->PushState(es->PhysUL);
es->PhysUL = 0;
}
else {
PP()->PushState(es->ElecCX);
es->ElecCX = 0;
Ulist()->PushState(es->ElecUL);
es->ElecUL = 0;
}
}
else {
if (mode == Physical) {
PP()->PushState(0);
Ulist()->PushState(0);
}
else {
PP()->PushState(0);
Ulist()->PushState(0);
}
}
}
//-----------------------------------------------------------------------------
// UndoList interface
void
cEdit::ulUndoOperation()
{
Ulist()->UndoOperation();
}
void
cEdit::ulRedoOperation()
{
Ulist()->RedoOperation();
}
bool
cEdit::ulHasRedo()
{
return (Ulist()->HasRedo());
}
bool
cEdit::ulHasChanged()
{
return (Ulist()->HasChanged());
}
bool
cEdit::ulCommitChanges(bool redisplay, bool nodrc)
{
return (Ulist()->CommitChanges(redisplay, nodrc));
}
void
cEdit::ulListFinalize(bool keep_undo)
{
Ulist()->ListFinalize(keep_undo);
}
void
cEdit::ulListBegin(bool noreinit, bool nocheck)
{
Ulist()->ListBegin(noreinit, nocheck);
}
void
cEdit::ulListCheck(const char *cmd, CDs *sdesc, bool selected)
{
Ulist()->ListCheck(cmd, sdesc, selected);
}
op_change_t *
cEdit::ulFindNext(const op_change_t *c)
{
const Ochg *o = static_cast<const Ochg*>(c);
return (o ? o->next_chg() : 0);
}
// Set up undo list state for pcell evaluation.
//
void
cEdit::ulPCevalSet(CDs *sdesc, ulPCstate *pcstate)
{
*pcstate = (ulPCstate)Ulist()->RotateUndo(0);
Ulist()->ListCheckPush("pceval", sdesc, false, true);
}
// Revert undo state after pcell evaluation.
//
void
cEdit::ulPCevalReset(ulPCstate *pcstate)
{
Ulist()->ListPop();
Oper *cur = Ulist()->RotateUndo(0);
Oper::destroy(cur);
Ulist()->RotateUndo((Oper*)*pcstate);
Ulist()->RotateUndo((Oper*)*pcstate);
}
// When the current cell is a pcell sub-master and we apply a new
// parameter set as a property change, the undo list is freed when the
// master is cleared. Thus, any previous property application will be
// lost from the undo list. Here we provide some hackery around this.
// These calls should surround the sub-master update operation.
// Call this before a sub-master reparameterization when the
// sub-master is the curremt cell. This extracts and returns the cell
// property changes associated with the current cell, and frees other
// operations. The operations list will be cleared anyway when the
// sub-master is cleared before evaluation.
//
void
cEdit::ulPCreparamSet(ulPCstate *pcstate)
{
*pcstate = Ulist()->GetPcPrmChanges();
}
// Call this after the pcell sub-master current cell has been
// reparameterized. This puts the reparameterization operations back
// on the operations list, allowing undo/redo of these operations.
//
void
cEdit::ulPCreparamReset(ulPCstate *pcstate)
{
Ulist()->ResetPcPrmChanges(pcstate);
}
//-----------------------------------------------------------------------------
// Context Push/Pop interface
namespace {
// State storage for context push/pop.
struct PPstate : public pp_state_t
{
PPstate()
{
ppUndoList = Ulist()->RotateUndo(0);
ppRedoList = Ulist()->RotateRedo(0);
}
~PPstate()
{
Oper::destroy(ppUndoList);
Oper::destroy(ppRedoList);
}
void purge(const CDs *sd, const CDl *ld)
{
Oper::purge(ppUndoList, sd, ld);
Oper::purge(ppRedoList, sd, ld);
}
void purge(const CDs *sd, const CDo *od)
{
Oper::purge(ppUndoList, sd, od);
Oper::purge(ppRedoList, sd, od);
}
void rotate()
{
Ulist()->RotateUndo(ppUndoList);
ppUndoList = 0;
Ulist()->RotateRedo(ppRedoList);
ppRedoList = 0;
}
private:
Oper *ppUndoList; // operations
Oper *ppRedoList; // redo list
};
}
pp_state_t *
cEdit::newPPstate()
{
return (new PPstate());
}
//
// The code below will save and restore the current transform and
// other settings. It is intended for saving and reverting state
// during PCell evaluation. We would like for PCell evaluation to not
// make permanent state changes.
//
// What about variables? PCell scripts should use PushVar/PopVar
// exclusively. During PCell evaluation, a flag is set in SIlcx,
// which can be used to lock out certain script functions such as Set
// and Unset.
namespace {
struct sReverter
{
sReverter()
{
rv_tx = *GEO()->curTx();
rv_array_params = ED()->arrayParams();
rv_45 = ED()->state45();
rv_wire_style = ED()->getWireStyle();
rv_move_or_copy = ED()->moveOrCopy();
rv_lchange_mode = ED()->getLchgMode();
rv_place_ref = ED()->instanceRef();
rv_stretch_box_code = ED()->stretchBoxCode();
rv_h_justify = ED()->horzJustify();
rv_v_justify = ED()->vertJustify();
rv_auto_abut_mode = ED()->pcellAbutMode();
rv_hide_grips = ED()->hideGrips();
rv_replacing = ED()->replacing();
rv_use_array = ED()->useArray();
rv_no_wire_width_mag = ED()->noWireWidthMag();
}
~sReverter()
{
GEO()->setCurTx (rv_tx);
ED()->setArrayParams (rv_array_params);
ED()->setState45 (rv_45);
ED()->setWireStyle (rv_wire_style);
ED()->setMoveOrCopy (rv_move_or_copy);
ED()->setLchgMode (rv_lchange_mode);
ED()->setInstanceRef (rv_place_ref);
ED()->setStretchBoxCode (rv_stretch_box_code);
ED()->setHorzJustify (rv_h_justify);
ED()->setVertJustify (rv_v_justify);
ED()->setPCellAbutMode (rv_auto_abut_mode);
ED()->setHideGrips (rv_hide_grips);
ED()->setReplacing (rv_replacing);
ED()->setUseArray (rv_use_array);
ED()->setNoWireWidthMag (rv_no_wire_width_mag);
}
private:
sCurTx rv_tx;
iap_t rv_array_params;
sEdit45 rv_45;
WireStyle rv_wire_style;
CDmcType rv_move_or_copy;
LCHGmode rv_lchange_mode;
PLref rv_place_ref;
int rv_stretch_box_code;
short rv_h_justify;
short rv_v_justify;
AbutMode rv_auto_abut_mode;
bool rv_hide_grips;
bool rv_replacing;
bool rv_use_array;
bool rv_no_wire_width_mag;
};
}
void *
cEdit::saveState()
{
return (new sReverter);
}
void
cEdit::revertState(void *arg)
{
delete ((sReverter*)arg);
}
| [
"stevew@wrcad.com"
] | stevew@wrcad.com |
761d7c03a58bfd459c0693ad6ba039675bcdd59a | 07b1bf70d0742700b436e80d3e45f640c011c79a | /BigNum.h | cc74900c38f1705494c0a99852bb5f48c2ccde72 | [] | no_license | wuyinglong123/main | 37b4d5ee98155e7685a74dc078b0ce6e188af75f | b60bb0f136d93a5fbbbbb05886eeb5d0061003fa | refs/heads/master | 2020-05-01T10:02:19.869401 | 2019-03-24T16:42:19 | 2019-03-24T16:42:19 | 177,412,931 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 257 | h | #ifndef BIGNUM_H
#define BIGNUM_H
#include<string>
#include<iostream>
using namespace std;
class BigNum{
private:
string a;
string b;
public:
void pluss(string a,string b);
void subc(string a,string b);
void multi(string a,string b);
};
#endif
| [
"2200198424@qq.com"
] | 2200198424@qq.com |
1e8457faba613c264faea65cd8bcdf85c0a38aa3 | 760f5e75f7055e8958cfd6925fe882e1ce992728 | /elog_serialize.hpp | f7f3bd99c7a66a44f5ae4b76dc2c8e79159f6ab6 | [
"Apache-2.0"
] | permissive | jianbaishi/phosphor-logging | 6159c435ee445540a4f3779857eeac0127675b70 | 80aa4762f78f1044d15c918d72316aa388ba0a02 | refs/heads/master | 2020-03-25T01:22:02.190672 | 2018-07-19T02:29:56 | 2018-07-20T09:02:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 997 | hpp | #pragma once
#include <string>
#include <vector>
#include <experimental/filesystem>
#include "elog_entry.hpp"
#include "config.h"
namespace phosphor
{
namespace logging
{
namespace fs = std::experimental::filesystem;
/** @brief Serialize and persist error d-bus object
* @param[in] a - const reference to error entry.
* @param[in] dir - pathname of directory where the serialized error will
* be placed.
* @return fs::path - pathname of persisted error file
*/
fs::path serialize(const Entry& e,
const fs::path& dir = fs::path(ERRLOG_PERSIST_PATH));
/** @brief Deserialze a persisted error into a d-bus object
* @param[in] path - pathname of persisted error file
* @param[in] e - reference to error object which is the target of
* deserialization.
* @return bool - true if the deserialization was successful, false otherwise.
*/
bool deserialize(const fs::path& path, Entry& e);
} // namespace logging
} // namespace phosphor
| [
"patrick@stwcx.xyz"
] | patrick@stwcx.xyz |
d03231c66d957eb65d2464e211b3641ede95fe2e | e0cb5434cf572cde89797f658ec289024a82ebee | /app_modules/99_template/src/template_settings.hpp | e143821c1dca4feaa588d7180e4c2eff4d7fc9c2 | [
"Apache-2.0"
] | permissive | LucaRitz/learn_with_tello | d236defb03ccd03b0d5b91cf80e3d76f78be6026 | f7fc45e7a9e9a2903638ec8367c9b355a4f1afc9 | refs/heads/master | 2022-12-27T01:03:25.304434 | 2020-10-07T13:38:13 | 2020-10-07T13:38:13 | 288,721,035 | 0 | 0 | Apache-2.0 | 2020-10-02T13:54:06 | 2020-08-19T12:05:44 | C | UTF-8 | C++ | false | false | 199 | hpp | #pragma once
#include <common/settings.hpp>
class TemplateSettings : public ISettings {
public:
TemplateSettings();
void aValue(int aValue);
int aValue();
private:
int _aValue;
}; | [
"ritz.luca@gmail.com"
] | ritz.luca@gmail.com |
aeec727fc2e442bcbe055af58b7f15a9b9ed96f5 | 9e92d93a73ac02d2f2c066d5880ff3df44cb7181 | /sort.hpp | 09515ccffc551c5e0ef1133fc78ed55a20b13654 | [] | no_license | mlcollard/sortTDDDemo020 | e7fa7741a8aab4865de4c12a6bd53ab81596cbdd | 128715dfcdf33cb22247ef860fe59409b8108f1d | refs/heads/main | 2023-08-20T12:12:21.724218 | 2021-10-20T20:23:40 | 2021-10-20T20:23:40 | 419,076,023 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 200 | hpp | /*
sort.hpp
Sorting functions
*/
#ifndef INCLUDED_SORT_HPP
#define INCLUDED_SORT_HPP
#include <vector>
// sort the entire vector in ascending order
void sort(std::vector<int>& v);
#endif
| [
"collard@uakron.edu"
] | collard@uakron.edu |
57810483ef82b80c70746432f68909f967ee1f34 | fc6d01c0a4ff1dd611a97b4a1999ba3e0ec051b5 | /Palindrome Partitioning.cpp | 936979d6cf4f031a8973b9836014aaa1ba138222 | [
"MIT"
] | permissive | fz1989/LeetCode | 9e32ffbf13073b89a4d2b3b19a5a3cada5c09cc4 | 6d9c3ddf3e2048c7be456902841d7e5fc80cd741 | refs/heads/master | 2020-06-04T01:13:25.302987 | 2014-03-04T13:41:23 | 2014-03-04T13:41:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,454 | cpp | class Solution {
private:
bool isPalindrome[500][500];
int N;
vector<vector<string> > ret;
string S;
public:
vector<vector<string> > partition(string s) {
S = s;
N = s.size();
string buf[N];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
isPalindrome[i][j] = 0;
if (i == j || (i + 1 == j && s[i] == s[j])) {
isPalindrome[i][j] = true;
}
}
}
for (int i = 3; i <= N; i++) {
for (int st = 0; st + i <= N; st++) {
int ed = st + i -1;
if (s[st] == s[ed] && isPalindrome[st + 1][ed - 1]) {
isPalindrome[st][ed] = 1;
}
}
}
partitionHelper(0, 0, 0, "", buf);
return ret;
}
void partitionHelper(int st, int ed, int cnt, string tmp, string buf[]) {
if (ed >= N) {
int a;
a = 1;
if (st == ed) {
vector <string> tmp;
for (int i = 0; i < cnt; i++) {
tmp.push_back(buf[i]);
}
ret.push_back(tmp);
}
return;
}
tmp += S[ed];
if (isPalindrome[st][ed]) {
buf[cnt] = tmp;
partitionHelper(ed + 1, ed + 1, cnt + 1, "", buf);
}
partitionHelper(st, ed + 1, cnt, tmp, buf);
}
}; | [
"fz1989fz@gmail.com"
] | fz1989fz@gmail.com |
fe582dab18789da101c8bcf903dca7355ad26330 | 109c01948f93608676acace87ad3d5ab3c981632 | /BattleTank/Source/BattleTank/Private/TankAIController.cpp | 5397680e9e85adf97423ca85764ef9a3d94d19e7 | [] | no_license | DiegoWRost-Udemy-UnrealCourse/04_BattleTank | 75bad60de4844d898eebd02436efb9a0e2dda820 | c5c7d5eaf21029d98aae363797a711bf391b0040 | refs/heads/master | 2021-07-04T23:43:05.806477 | 2018-11-15T19:11:19 | 2018-11-15T19:11:19 | 109,422,337 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 745 | cpp | // Fill out your copyright notice in the Description page of Project Settings.
#include "TankAIController.h"
#include "Tank.h"
// Depends on movement component via pathfinding system
void ATankAIController::BeginPlay()
{
Super::BeginPlay();
}
// Called every frame
void ATankAIController::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
auto PlayerTank = Cast<ATank>(GetWorld()->GetFirstPlayerController()->GetPawn());
auto ControlledTank = Cast<ATank>(GetPawn());
if (ensure(PlayerTank))
{
// Move towards player
MoveToActor(PlayerTank, AcceptanceRadius); // TODO check radius is in cm
// Aim towards the player
ControlledTank->AimAt(PlayerTank->GetActorLocation());
ControlledTank->Fire(); // TODO limit firing rate
}
} | [
"diego.wr@gmail.com"
] | diego.wr@gmail.com |
1cb3d9e82685cd25f81bb007b35af9deaa6f85c3 | aa061248d4584e062226426686aafa36c1cc0ccc | /tem/SymbolTable.h | ab83f9adb60d6148d4855ee6cbd967410670def6 | [] | no_license | shamiul94/Compiler-Project | bff20a7c252f3361d696116869c2a8ce1c8b5bf9 | 5c1f3fc5596ea6f4ba2042b72b15299cef513bc6 | refs/heads/master | 2020-03-11T16:00:08.795026 | 2019-01-29T11:04:46 | 2019-01-29T11:04:46 | 130,102,605 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,866 | h |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
class symbolInfo
{
string symbolName, symbolType;
public:
ll i, j, tableId;
symbolInfo *next;
symbolInfo();
symbolInfo(string name, string type);
void setSymbolName(string name);
void setSymbolType(string type);
void setAll(string name, string type);
string getSymbolName();
string getSymbolType();
};
symbolInfo::symbolInfo()
{
symbolName = "";
symbolType = "";
next = 0;
}
symbolInfo::symbolInfo(string name, string type)
{
symbolName = name;
symbolType = type;
next = 0;
}
void symbolInfo::setSymbolName(string name)
{
symbolName = name;
}
void symbolInfo::setSymbolType(string type)
{
symbolType = type;
}
void symbolInfo::setAll(string name, string type)
{
symbolName = name;
symbolType = type;
}
string symbolInfo::getSymbolName()
{
return symbolName;
}
string symbolInfo::getSymbolType()
{
return symbolType;
}
class scopeTable
{
symbolInfo j;
public:
symbolInfo *Arr;
scopeTable *parentScopeTable;
ll id, N;
scopeTable(ll n);
~scopeTable();
ll hash(string varName);
bool insert(string varName, string varType);
bool Delete(string varName);
symbolInfo *lookUp(string varName);
void printScopeTable();
};
scopeTable::scopeTable(ll n)
{
Arr = new symbolInfo[n];
parentScopeTable = 0;
N = n;
id = 1;
}
bool scopeTable::insert(string varName, string varType)
{
symbolInfo tem(varName, varType);
ll positionInArray = hash(varName);
symbolInfo *head;
head = &Arr[positionInArray];
symbolInfo *curr;
curr = head;
ll num = 0;
while (curr->next != 0)
{
curr = curr->next;
num++;
if (curr != 0)
{
if (curr->getSymbolName() == varName)
{
return false;
}
}
}
symbolInfo *NewVar;
NewVar = new symbolInfo();
NewVar->setAll(varName, varType);
NewVar->i = positionInArray;
NewVar->j = num;
NewVar->tableId = id;
curr->next = NewVar;
return true;
}
symbolInfo *scopeTable::lookUp(string varName)
{
ll positionInArray = hash(varName);
symbolInfo *curr = &Arr[positionInArray];
while (curr->next != 0)
{
curr = curr->next;
if (curr != 0)
{
if (curr->getSymbolName() == varName)
{
return curr;
}
}
}
return 0;
}
bool scopeTable::Delete(string varName)
{
ll positionInArray = hash(varName);
symbolInfo *curr = &Arr[positionInArray];
symbolInfo *prev = 0;
while (curr->next != 0)
{
prev = curr;
curr = curr->next;
if (curr != 0)
{
if (curr->getSymbolName() == varName)
{
prev->next = curr->next;
free(curr);
return true;
}
}
}
return false;
}
void scopeTable::printScopeTable()
{
for (ll i = 0; i < N; i++)
{
cout << i << " --> ";
symbolInfo *curr = &Arr[i];
while (curr != 0)
{
curr = curr->next;
if (curr != 0)
{
cout << "< " << curr->getSymbolName() << ':' << curr->getSymbolType() << " >";
}
if (curr != 0 && curr->next != 0)
{
cout << " , ";
}
}
cout << endl;
}
return;
}
ll scopeTable::hash(string name)
{
ll mod = N;
ll c = 16777619;
ll tem, ret = 0;
for (ll i = 0; i < name.size(); i++)
{
tem = c ^ (ll) name[i];
tem *= 193;
tem = c ^ (ll) name[i];
tem = tem % mod;
ret = (ret % mod + tem % mod) % mod;
}
return ret;
}
scopeTable::~scopeTable()
{
free(Arr);
free(parentScopeTable);
}
class symbolTable
{
public:
ll N;
scopeTable *currentScopeTable;
symbolTable(ll n);
void enterScope();
void exitScope();
bool insert(string varName, string varType);
bool remove(string varName);
symbolInfo *lookUp(string varName);
void printCurrentScopeTable();
void printAllScopeTable();
};
symbolTable::symbolTable(ll n)
{
N = n;
scopeTable *tem;
tem = new scopeTable(N);
currentScopeTable = tem;
}
void symbolTable::enterScope()
{
scopeTable *newScopeTable = new scopeTable(N);
newScopeTable->id = currentScopeTable->id + 1;
newScopeTable->parentScopeTable = currentScopeTable;
currentScopeTable = newScopeTable;
return;
}
void symbolTable::exitScope()
{
scopeTable *parent;
parent = currentScopeTable->parentScopeTable;
free(currentScopeTable);
currentScopeTable = parent;
return;
}
bool symbolTable::insert(string varName, string varType)
{
bool inserted = currentScopeTable->insert(varName, varType);
return (inserted) ? true : false;
}
bool symbolTable::remove(string varName)
{
bool deleted = currentScopeTable->Delete(varName);
return (deleted) ? true : false;
}
symbolInfo *symbolTable::lookUp(string varName)
{
scopeTable *tem;
tem = currentScopeTable;
while (tem != 0)
{
symbolInfo *found = tem->lookUp(varName);
if (found != 0)
{
return found;
}
tem = tem->parentScopeTable;
}
return 0;
}
void symbolTable::printCurrentScopeTable()
{
cout << "ScopeTable # " << currentScopeTable->id << endl;
currentScopeTable->printScopeTable();
return;
}
void symbolTable::printAllScopeTable()
{
scopeTable *tem;
tem = currentScopeTable;
while (tem != 0)
{
cout << "ScopeTable # " << tem->id << endl;
tem->printScopeTable();
tem = tem->parentScopeTable;
}
return;
}
| [
"1505038.sh@ugrad.cse.buet.ac.bd"
] | 1505038.sh@ugrad.cse.buet.ac.bd |
00a1ba077981c0f527d232f77a7f1649883c2063 | a16dadb0b36f9da69f208573b08b21ceb1dec7e1 | /TriggerDecision/app/RunSmartTriggerLatency.cxx | 3fe3dfc50a4b63095ccbff65f87cd2af7b03a4a1 | [] | no_license | plasorak/Clustering | 36edbb79b25eb3e767412bfc293be17009b01ca0 | a753bf9bceadd004ad5a59e5d73e3d2fff1aa5b6 | refs/heads/master | 2023-04-27T10:51:38.766429 | 2023-02-08T15:44:38 | 2023-02-08T15:44:38 | 142,597,488 | 0 | 7 | null | 2023-02-08T15:44:40 | 2018-07-27T15:59:30 | C++ | UTF-8 | C++ | false | false | 1,866 | cxx | //____________________________________________________________________
//
// $Id$
// Author: Pierre Lasorak <plasorak@Pierres-MacBook-Pro.local>
// Update: 2019-02-14 15:38:26+0000
// Copyright: 2019 (C) Pierre Lasorak
//
//
#include "TriggerDecision/StatisticalTest.hh"
#include "TriggerDecision/TriggerLatencyCalculator.hh"
#include "Utils/Helper.h"
#include "Utils/CLI11.hpp"
#include "TCanvas.h"
#include "TColor.h"
#include "TFile.h"
#include "TGraph.h"
#include "TH1D.h"
#include "TLegend.h"
#include <TMath.h>
#include "TPad.h"
#include "TRandom3.h"
#include "TText.h"
#include "TVectorT.h"
#include <chrono>
#include <iostream>
#include <vector>
int main(int argc, char** argv) {
CLI::App app{"SmartTrigger"};
std::string InputFileName = "";
std::string OutputFileName = "";
std::string Method = "Likelihood";
int Config, nToy, nThread=1, nEvent;
app.add_option("--ntoy", nToy, "Number of toys to throw" )->required();
app.add_option("--nthread", nThread, "Number of threads to use" );
app.add_option("--nevent", nEvent, "Number of event in the SN")->required();
app.add_option("--config", Config, "Which config to run on" )->required();
app.add_option("--output", OutputFileName, "Output file name (root)" )->required();
app.add_option("--input", InputFileName, "Input file nam (root)" )->required();
app.add_option("--method", Method, "Method can be \"Likelihood\", \"LikelihoodNorm\" or \"LikelihoodShape\"")->required();
CLI11_PARSE(app, argc, argv);
TriggerLatencyCalculator tlc(nEvent, 10, nToy, nThread, Config, InputFileName, OutputFileName, Method);
tlc.Compute();
return 0;
}
//____________________________________________________________________
//
// EOF
//
//____________________________________________________________________
//
| [
"plasorak@fnal.com"
] | plasorak@fnal.com |
e1f9e7afb217ce67d866e1b85329c38fed4ae7bd | e5de536559fc4cee91dc41854222f752ed53d187 | /testconst/main.cpp | 14d5b129a0eca6fcc209884518f5ca90c2945a97 | [] | no_license | sw1024/testcpp | d2e6c09df7a77bc06b8583542574042412a64c09 | ecee919827baf8602b34e74277e4cf99ef055ee3 | refs/heads/master | 2022-11-21T01:21:21.283392 | 2020-07-18T09:27:13 | 2020-07-18T09:27:13 | 280,622,780 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 116 | cpp | #include "a.h"
#include <iostream>
void printA();
int main()
{
std::cout<<a<<std::endl;
printA();
return 0;
}
| [
"1106012118@qq.com"
] | 1106012118@qq.com |
bffea7e51b089a14bd7ee60582109f68088fff04 | df9ee1964d28cb4bdcceb66f11d25d1bd3f58e29 | /juego.h | 5de98ad9202cc492d02a95ecf10f9630ef1841a7 | [] | no_license | sammygm6/ProyectoFinalProgra3 | 1fa811f2fa19675238b58518a5be5117dbe5cdb4 | 34d571dbe49eb232f907e9094e818391627e28de | refs/heads/master | 2021-01-22T13:38:17.813019 | 2015-03-26T05:30:23 | 2015-03-26T05:30:23 | 32,647,114 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 541 | h | #ifndef JUEGO_H
#define JUEGO_H
#include <string>
using std::string;
class juego
{
string nombre;
double precio;
string clasificacion;
string tipo;
public:
juego(string,double,string,string);
juego(const juego&);
~juego();
string toString()const;
string getNombre()const;
double getPrecio()const;
string getClasificacion()const;
string getTipo()const;
void setNombre(string);
void setPrecio(double);
void setClasificacion(string);
void setTipo(string);
};
#endif // JUEGO_H
| [
"sammygm6@gmail.com"
] | sammygm6@gmail.com |
8a635a49225c4cee4308bdfeb44b4faa40767667 | 12ca06d0473657dfc85bb836fcacb74efc6e0b75 | /Rotator.cpp | 3f00f7ebf3d7292bfb8200431cfb57ceed27e4d2 | [] | no_license | suiqingsheng/adaptive-thresholder | 7fc1f4c5e3fb1416f47f97166eed2b822bb2e280 | bb5ab9e70559d2c87128cbd53d1418715b0dd4be | refs/heads/master | 2020-05-19T17:15:12.922982 | 2017-05-30T14:26:12 | 2017-05-30T14:26:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,298 | cpp | #include <Magick++.h>
#include <iostream>
#include <string>
#include <stdint.h>
#include <cassert>
#include <cstring>
#include <vector>
#include <cmath>
using namespace std;
using namespace Magick;
int usage(string argv0) {
cerr << "USAGE: " << argv0 << " <input_image> <output_image> [maxangle] [intervals]" << endl;
return 1;
}
class ImageWrapper {
const PixelPacket *pp;
const int colorShift;
const int width, height;
public:
ImageWrapper(const Image &image)
:
colorShift(8 * (sizeof(pp->green) - sizeof(uint8_t))),
width(image.size().width()),
height(image.size().height())
{
pp = image.getConstPixels(0, 0, width, height);
}
uint8_t gray(int x, int y) const {
int v = (*this)(x, y)->green >> colorShift;
assert(v < 256);
assert(v >= 0);
return v;
}
const PixelPacket *operator()(int x, int y) const {
if (x < 0)
x += width;
if (y < 0)
y += height;
if (x >= width)
x -= width;
if (y >= height)
y -= height;
assert(x >= 0 && y >= 0 && x < width && y < height);
return pp + y * width + x;
}
int isblack(int x, int y) const {
return gray(x, y) < 128;
}
int getColorShift() const {
return colorShift;
}
};
int lineScore(const Image &input, int deltay) {
Geometry g = input.size();
const int width = g.width();
const int height = g.height();
ImageWrapper iw(input);
std::vector<int> lineTotal(height, 0);
int dir = deltay > 0 ? 1 : (deltay < 0 ? -1 : 0);
int deltaerr = deltay * dir;
int cnt = 0;
for (int y0 = 0; y0 < height; y0++) {
int y = y0;
int error = 0;
lineTotal[y0] = 0;
for (int x = 0; x < width; x++) {
lineTotal[y0] += iw.isblack(x, y);
error += deltaerr;
if (2 * error >= width) {
y += dir;
error -= width;
}
}
if (lineTotal[y0])
cnt++;
}
return cnt;
}
void tilt(const Image &input, Image &output, int deltay) {
Geometry g = input.size();
const int width = g.width();
const int height = g.height();
ImageWrapper iw(input);
int dir = deltay > 0 ? 1 : (deltay < 0 ? -1 : 0);
int deltaerr = deltay * dir;
for (int y0 = 0; y0 < height; y0++) {
int y = y0;
int error = 0;
for (int x = 0; x < width; x++) {
*output.getPixels(x, y0, 1, 1) = *iw(x, y);
error += deltaerr;
if (2 * error >= width) {
y += dir;
error -= width;
}
}
}
}
int main(int argc, char **argv)
{
if (argc < 3 || argc > 5)
return usage(argv[0]);
int cols = 21;
double maxangle = 10;
if (argc > 3)
maxangle = atof(argv[3]);
if (argc > 4)
cols = atoi(argv[4]);
cout << "Processing `" << argv[1] << "' into `" << argv[2] << "'" << " with angular range from -" << maxangle << " to " << maxangle
<< " degrees and " << cols << " intervals" << endl;
InitializeMagick(*argv);
Image input;
Color black("black");
try {
input.read(argv[1]);
input.quantizeColorSpace(GRAYColorspace);
input.quantizeColors(256);
input.quantize();
std::vector<int> dy(cols);
std::vector<int> score(cols);
Image output(input.size(), "white");
int width = input.size().width();
int minpos = 0;
double range = tan(maxangle / 45 * atan(1.));
for (int i = 0; i < cols; i++) {
dy[i] = range * width * (2 * i - cols + 1) / (cols - 1);
score[i] = lineScore(input, dy[i]);
if (score[i] < score[minpos])
minpos = i;
}
if (minpos == 0 || minpos == (cols - 1)) {
cerr << "Angle range was too narrow" << endl;
return 2;
}
int a = dy[minpos - 1];
int b = dy[minpos + 1];
double w = 0.381966;
int c = a + w * (b - a);
int d = a + b - c;
int fc = lineScore(input, c);
int fd = lineScore(input, d);
while (b > d && d > c && c > a) {
if (fd > fc) {
b = d;
d = c;
c = a + b - d;
fd = fc;
fc = lineScore(input, c);
} else {
a = c;
c = d;
d = a + b - c;
fc = fd;
fd = lineScore(input, d);
}
}
int fa;
if (fd < fc) {
minpos = d;
fa = fd;
} else {
minpos = c;
fa = fc;
}
for (int i = std::min(d, c); i <= std::max(d, c) + 1; i++) {
int v = lineScore(input, i);
if (v < fa) {
fa = v;
minpos = i;
}
}
cout << "Optimum tilt = " << minpos << "px" << endl;
tilt(input, output, minpos);
output.write(argv[2]);
} catch (Exception &e) {
cerr << "Caught exception: " << e.what() << endl;
return 1;
}
return 0;
}
| [
"tsybulinhome@gmail.com"
] | tsybulinhome@gmail.com |
4fe40ac8ef7076f1a40cf09ad0a21cf74e6ace4e | 54f4746cf9004954696028ad3781baf10b3dc676 | /OOP345SBB/WS09/SecureData.h | 0e671867c94b64b47c6c5dbbe7519a981f2f09e7 | [] | no_license | chiro-pepe02/OOP345 | 3c18354951092c776de6b22b321df5ae7080d4a7 | f70df6704f5183e91045cceaa16362e3540ccc0e | refs/heads/master | 2020-09-15T15:42:10.628426 | 2019-04-17T19:47:03 | 2019-04-17T19:47:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 982 | h | // Name: Lean Junio
// Seneca Student ID: 019-109-123
// Seneca email: ljjunio@myseneca.ca
// Date of completion: 11/21/2018
//
// I confirm that the content of this file is created by me,
// with the exception of the parts provided to me by my professor.
// Workshop 9 - Multi-Threading
// SecureData.h
#ifndef W9_SECUREDATA_H
#define W9_SECUREDATA_H
#include <iostream>
namespace w9
{
class Cryptor {
public:
char operator()(char in, char key) const { return in ^ key; }
};
void converter(char*, char, int, const Cryptor&);
class SecureData {
char* text;
std::ostream* ofs;
int nbytes;
bool encoded;
void code(char);
public:
SecureData(const char*, char, std::ostream*);
SecureData(const SecureData&) = delete;
SecureData& operator=(const SecureData&) = delete;
~SecureData();
void display(std::ostream&) const;
void backup(const char*);
void restore(const char*, char);
};
std::ostream& operator<<(std::ostream&, const SecureData&);
}
#endif | [
"leanjunio@live.com"
] | leanjunio@live.com |
6b21b933ede56709912de990d003a2e1f48c882e | e299ad494a144cc6cfebcd45b10ddcc8efab54a9 | /llvm/lib/Target/R600/AMDGPUISelLowering.h | a3554a51c37c53494c4eb6e4cfda93944240f035 | [
"NCSA"
] | permissive | apple-oss-distributions/lldb | 3dbd2fea5ce826b2bebec2fe88fadbca771efbdf | 10de1840defe0dff10b42b9c56971dbc17c1f18c | refs/heads/main | 2023-08-02T21:31:38.525968 | 2014-04-11T21:20:22 | 2021-10-06T05:26:12 | 413,590,587 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,872 | h | //===-- AMDGPUISelLowering.h - AMDGPU Lowering Interface --------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
/// \file
/// \brief Interface definition of the TargetLowering class that is common
/// to all AMD GPUs.
//
//===----------------------------------------------------------------------===//
#ifndef AMDGPUISELLOWERING_H
#define AMDGPUISELLOWERING_H
#include "llvm/Target/TargetLowering.h"
namespace llvm {
class AMDGPUMachineFunction;
class MachineRegisterInfo;
class AMDGPUTargetLowering : public TargetLowering {
private:
void ExtractVectorElements(SDValue Op, SelectionDAG &DAG,
SmallVectorImpl<SDValue> &Args,
unsigned Start, unsigned Count) const;
SDValue LowerEXTRACT_SUBVECTOR(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerCONCAT_VECTORS(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerINTRINSIC_WO_CHAIN(SDValue Op, SelectionDAG &DAG) const;
/// \brief Lower vector stores by merging the vector elements into an integer
/// of the same bitwidth.
SDValue MergeVectorStore(const SDValue &Op, SelectionDAG &DAG) const;
/// \brief Split a vector store into multiple scalar stores.
/// \returns The resulting chain.
SDValue LowerUDIVREM(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerUINT_TO_FP(SDValue Op, SelectionDAG &DAG) const;
protected:
/// \brief Helper function that adds Reg to the LiveIn list of the DAG's
/// MachineFunction.
///
/// \returns a RegisterSDNode representing Reg.
virtual SDValue CreateLiveInRegister(SelectionDAG &DAG,
const TargetRegisterClass *RC,
unsigned Reg, EVT VT) const;
SDValue LowerGlobalAddress(AMDGPUMachineFunction *MFI, SDValue Op,
SelectionDAG &DAG) const;
/// \brief Split a vector load into multiple scalar loads.
SDValue SplitVectorLoad(const SDValue &Op, SelectionDAG &DAG) const;
SDValue SplitVectorStore(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSTORE(SDValue Op, SelectionDAG &DAG) const;
bool isHWTrueValue(SDValue Op) const;
bool isHWFalseValue(SDValue Op) const;
/// The SelectionDAGBuilder will automatically promote function arguments
/// with illegal types. However, this does not work for the AMDGPU targets
/// since the function arguments are stored in memory as these illegal types.
/// In order to handle this properly we need to get the origianl types sizes
/// from the LLVM IR Function and fixup the ISD:InputArg values before
/// passing them to AnalyzeFormalArguments()
void getOriginalFunctionArgs(SelectionDAG &DAG,
const Function *F,
const SmallVectorImpl<ISD::InputArg> &Ins,
SmallVectorImpl<ISD::InputArg> &OrigIns) const;
void AnalyzeFormalArguments(CCState &State,
const SmallVectorImpl<ISD::InputArg> &Ins) const;
public:
AMDGPUTargetLowering(TargetMachine &TM);
virtual bool isFAbsFree(EVT VT) const;
virtual bool isFNegFree(EVT VT) const;
virtual MVT getVectorIdxTy() const;
virtual SDValue LowerReturn(SDValue Chain, CallingConv::ID CallConv,
bool isVarArg,
const SmallVectorImpl<ISD::OutputArg> &Outs,
const SmallVectorImpl<SDValue> &OutVals,
SDLoc DL, SelectionDAG &DAG) const;
virtual SDValue LowerCall(CallLoweringInfo &CLI,
SmallVectorImpl<SDValue> &InVals) const {
CLI.Callee.dump();
llvm_unreachable("Undefined function");
}
virtual SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerIntrinsicIABS(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerIntrinsicLRP(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerMinMax(SDValue Op, SelectionDAG &DAG) const;
virtual const char* getTargetNodeName(unsigned Opcode) const;
virtual SDNode *PostISelFolding(MachineSDNode *N, SelectionDAG &DAG) const {
return N;
}
// Functions defined in AMDILISelLowering.cpp
public:
/// \brief Determine which of the bits specified in \p Mask are known to be
/// either zero or one and return them in the \p KnownZero and \p KnownOne
/// bitsets.
virtual void computeMaskedBitsForTargetNode(const SDValue Op,
APInt &KnownZero,
APInt &KnownOne,
const SelectionDAG &DAG,
unsigned Depth = 0) const;
virtual bool getTgtMemIntrinsic(IntrinsicInfo &Info,
const CallInst &I, unsigned Intrinsic) const;
/// We want to mark f32/f64 floating point values as legal.
bool isFPImmLegal(const APFloat &Imm, EVT VT) const;
/// We don't want to shrink f64/f32 constants.
bool ShouldShrinkFPConstant(EVT VT) const;
private:
void InitAMDILLowering();
SDValue LowerSREM(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSREM8(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSREM16(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSREM32(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSREM64(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSDIV(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSDIV24(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSDIV32(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSDIV64(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerSIGN_EXTEND_INREG(SDValue Op, SelectionDAG &DAG) const;
EVT genIntType(uint32_t size = 32, uint32_t numEle = 1) const;
SDValue LowerBRCOND(SDValue Op, SelectionDAG &DAG) const;
SDValue LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const;
};
namespace AMDGPUISD {
enum {
// AMDIL ISD Opcodes
FIRST_NUMBER = ISD::BUILTIN_OP_END,
CALL, // Function call based on a single integer
UMUL, // 32bit unsigned multiplication
DIV_INF, // Divide with infinity returned on zero divisor
RET_FLAG,
BRANCH_COND,
// End AMDIL ISD Opcodes
DWORDADDR,
FRACT,
COS_HW,
SIN_HW,
FMAX,
SMAX,
UMAX,
FMIN,
SMIN,
UMIN,
URECIP,
DOT4,
TEXTURE_FETCH,
EXPORT,
CONST_ADDRESS,
REGISTER_LOAD,
REGISTER_STORE,
LOAD_INPUT,
SAMPLE,
SAMPLEB,
SAMPLED,
SAMPLEL,
FIRST_MEM_OPCODE_NUMBER = ISD::FIRST_TARGET_MEMORY_OPCODE,
STORE_MSKOR,
LOAD_CONSTANT,
TBUFFER_STORE_FORMAT,
LAST_AMDGPU_ISD_NUMBER
};
} // End namespace AMDGPUISD
} // End namespace llvm
#endif // AMDGPUISELLOWERING_H
| [
"91980991+AppleOSSDistributions@users.noreply.github.com"
] | 91980991+AppleOSSDistributions@users.noreply.github.com |
f4bc26b16f356109a87bef61cfdc4f6e3e53e37d | 0149a18329517d09305285f16ab41a251835269f | /Problem Set Volumes/Volume 12 (1200-1299)/UVa_1239_Greatest_K-Palindrome_Substring.cpp | 1e4f4d73866ee0dcf9ff1d60cc221b539c4ebe97 | [] | no_license | keisuke-kanao/my-UVa-solutions | 138d4bf70323a50defb3a659f11992490f280887 | f5d31d4760406378fdd206dcafd0f984f4f80889 | refs/heads/master | 2021-05-14T13:35:56.317618 | 2019-04-16T10:13:45 | 2019-04-16T10:13:45 | 116,445,001 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,113 | cpp |
/*
UVa 1239 - Greatest K-Palindrome Substring
To build using Visual Studio 2012:
cl -EHsc -O2 UVa_1239_Greatest_K-Palindrome_Substring.cpp
This is an accepted solution.
*/
#include <cstdio>
#include <cstring>
const int nr_chars_max = 1000;
int K;
char S[nr_chars_max + 1];
int nr_changed_chars[nr_chars_max][nr_chars_max];
// nr_changed_chars[i][j] is the number of changed chars for S[i][j] to be a palindrome
int main()
{
int T;
scanf("%d", &T);
while (T--) {
scanf("%s %d", S, &K);
int length = strlen(S), longest = 1;
for (int i = 0; i < length; i++)
nr_changed_chars[i][i] = 0;
for (int i = 0; i < length - 1; i++) {
nr_changed_chars[i][i + 1] = (S[i] != S[i + 1]) ? 1 : 0;
if (nr_changed_chars[i][i + 1] <= K)
longest = 2;
}
for (int l = 3; l <= length; l++)
for (int i = 0; i < length - l + 1; i++) {
int j = i + l - 1;
nr_changed_chars[i][j] = nr_changed_chars[i + 1][j - 1] + ((S[i] != S[j]) ? 1 : 0);
if (nr_changed_chars[i][j] <= K)
longest = l;
}
printf("%d\n", longest);
}
return 0;
}
| [
"keisuke.kanao.154@gmail.com"
] | keisuke.kanao.154@gmail.com |
9787d2b84966e9cc256d3d7890257da076106cfd | 9b1a0e9ac2c5ffc35f368ca5108cd8953eb2716d | /2/03 Artificial Intelligence/03 Carter/ai_behaviour_wander.cpp | ace620f4ec966d6de657e8ffd31227615186068d | [] | no_license | TomasRejhons/gpg-source-backup | c6993579e96bf5a6d8cba85212f94ec20134df11 | bbc8266c6cd7df8a7e2f5ad638cdcd7f6298052e | refs/heads/main | 2023-06-05T05:14:00.374344 | 2021-06-16T15:08:41 | 2021-06-16T15:08:41 | 377,536,509 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 242 | cpp | #include "standard_headers.hpp"
#include "ai_behaviour_wander.hpp"
#include "entities.hpp"
#include "ai_brain.hpp"
void CAIBehaviourWander::Update(void)
{
C2DCoordF pos = PEntity->FindWanderPos();
Action_MoveToPos(pos);
}
| [
"t.rejhons@gmail.com"
] | t.rejhons@gmail.com |
f108ba498d13af1b5a99179dec4b04f8569b8b8b | c26e0e749d9c394303d3a5ec0f8805ba797ed6f2 | /src/PointsTo/AlgoAndersen.h | 7be8b0090dbfbb91d0c2bb7c7906621de09a9a74 | [] | no_license | ddropik/LLVMSlicer | 68246b7a4e1d8813450deb46f5143e85587ea3cb | b464219a3aacd0e3ba678cdf5336b9d99451927e | refs/heads/master | 2021-01-17T13:35:35.510815 | 2012-08-09T19:27:44 | 2012-08-09T19:29:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,179 | h | // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
#ifndef POINTSTO_ALGOANDERSEN_H
#define POINTSTO_ALGOANDERSEN_H
#include "PredefContainers.h"
#include "PointsTo.h"
namespace llvm { namespace ptr {
struct ANDERSEN {};
}}
namespace llvm { namespace ptr {
PointsToSets<ANDERSEN>::Type&
computePointsToSets(ProgramStructure const& P,
PointsToSets<ANDERSEN>::Type& S,
ANDERSEN);
RuleFunction<ANDERSEN>::Type
getRuleFunction(ASSIGNMENT<
VARIABLE<const llvm::Value *>,
VARIABLE<const llvm::Value *>
> const& E,
ANDERSEN);
RuleFunction<ANDERSEN>::Type getRuleFunction(
ASSIGNMENT<
VARIABLE<const llvm::Value *>,
REFERENCE<
VARIABLE<const llvm::Value *> >
> const& E,
ANDERSEN);
RuleFunction<ANDERSEN>::Type
getRuleFunction(ASSIGNMENT<
VARIABLE<const llvm::Value *>,
DEREFERENCE< VARIABLE<const llvm::Value *> >
> const& E,
ANDERSEN);
RuleFunction<ANDERSEN>::Type
getRuleFunction(ASSIGNMENT<
DEREFERENCE< VARIABLE<const llvm::Value *> >,
VARIABLE<const llvm::Value *>
> const& E,
ANDERSEN);
RuleFunction<ANDERSEN>::Type
getRuleFunction(ASSIGNMENT<
DEREFERENCE<
VARIABLE<const llvm::Value *> >,
REFERENCE<
VARIABLE<const llvm::Value *> >
> const& E,
ANDERSEN);
RuleFunction<ANDERSEN>::Type
getRuleFunction(ASSIGNMENT<
DEREFERENCE<
VARIABLE<const llvm::Value *> >,
DEREFERENCE<
VARIABLE<const llvm::Value *> >
> const& E,
ANDERSEN);
RuleFunction<ANDERSEN>::Type
getRuleFunction(ASSIGNMENT<
VARIABLE<const llvm::Value *>,
ALLOC<const llvm::Value *>
> const& E,
ANDERSEN);
RuleFunction<ANDERSEN>::Type
getRuleFunction(ASSIGNMENT<
VARIABLE<const llvm::Value *>,
NULLPTR<const llvm::Value *>
> const& E,
ANDERSEN);
RuleFunction<ANDERSEN>::Type
getRuleFunction(ASSIGNMENT<
DEREFERENCE<
VARIABLE<const llvm::Value *> >,
NULLPTR<const llvm::Value *>
> const& E,
ANDERSEN);
}}
#endif
| [
"jirislaby@gmail.com"
] | jirislaby@gmail.com |
8e116236b7d995097abbac6f8a5c0f36af54700d | 4bd300d451a4dc2f1df37243fcd3047b5564a914 | /07 指针/03 空指针和野指针.cpp | 1508daf505f7ecda4024c47bb146beba5cd00cf2 | [
"MIT"
] | permissive | AlicePolk/cpp- | 24c865ca70a11a931c42192db4ebdb4924cf72e8 | 5bc3b1ea7fde780d0c45632fad083d583d65fb66 | refs/heads/master | 2022-12-14T16:39:02.316754 | 2020-09-12T01:46:51 | 2020-09-12T01:46:51 | 224,430,332 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 559 | cpp | //#include<iostream>
//using namespace std;
//
////空指针
//void test01() {
//
// //指针变量p指向内存地址编号为0的空间
// int * p = NULL;
//
// //访问空指针报错
// //内存编号0 ~255为系统占用内存，不允许用户访问
// cout << *p << endl;
//
//}
//
////野指针
//void test02() {
//
// //指针变量p指向内存地址编号为0x1100的空间
// int * p = (int *)0x1100;
//
// //访问野指针报错
// cout << *p << endl;
//
//}
//
//int mian()
//{
// //test01();
// test02();
// system("pause");
// return 0;
//} | [
"474788892@qq.com"
] | 474788892@qq.com |
0f0ec58ea891b2b3901642b751ad2b03043684bd | 1eea18984245d5d44e423f228874bf84e9f39b45 | /tests/transports/splice/test_splice_rules.cpp | 4f76cef563a3ce2fff21f3eed8ffdd56842b7083 | [] | no_license | amrahimi/madara | ef4f8237f8c691d0f91a4c22b76497c3a841d4a7 | 669a624d4558452dd24321f976f995d6dd0df7a1 | refs/heads/master | 2020-03-27T11:53:23.922645 | 2018-08-28T21:18:39 | 2018-08-28T21:18:39 | 146,512,277 | 0 | 0 | null | 2018-08-28T22:10:03 | 2018-08-28T22:10:03 | null | UTF-8 | C++ | false | false | 3,564 | cpp |
#include <string>
#include <vector>
#include <iostream>
#include <sstream>
#include <assert.h>
#include "madara/knowledge/KnowledgeBase.h"
#include "madara/logger/GlobalLogger.h"
namespace knowledge = madara::knowledge;
namespace transport = madara::transport;
namespace logger = madara::logger;
typedef knowledge::KnowledgeRecord::Integer Integer;
std::string host ("");
madara::transport::QoSTransportSettings settings;
void handle_arguments (int argc, char ** argv)
{
for (int i = 1; i < argc; ++i)
{
std::string arg1 (argv[i]);
if (arg1 == "-o" || arg1 == "--host")
{
if (i + 1 < argc)
host = argv[i + 1];
++i;
}
else if (arg1 == "-d" || arg1 == "--domain")
{
if (i + 1 < argc)
settings.write_domain = argv[i + 1];
++i;
}
else if (arg1 == "-i" || arg1 == "--id")
{
if (i + 1 < argc)
{
std::stringstream buffer (argv[i + 1]);
buffer >> settings.id;
}
++i;
}
else if (arg1 == "-f" || arg1 == "--logfile")
{
if (i + 1 < argc)
{
logger::global_logger->add_file (argv[i + 1]);
}
++i;
}
else if (arg1 == "-l" || arg1 == "--level")
{
if (i + 1 < argc)
{
std::stringstream buffer (argv[i + 1]);
int level;
buffer >> level;
logger::global_logger->set_level (level);
}
++i;
}
else if (arg1 == "-p" || arg1 == "--drop-rate")
{
if (i + 1 < argc)
{
double drop_rate;
std::stringstream buffer (argv[i + 1]);
buffer >> drop_rate;
settings.update_drop_rate (drop_rate,
madara::transport::PACKET_DROP_DETERMINISTIC);
}
++i;
}
else
{
madara_logger_ptr_log (logger::global_logger.get (), logger::LOG_ALWAYS,
"\nProgram summary for %s:\n\n" \
" Test the Splice DDS transport. Requires 2+ processes. The result of\n" \
" running these processes should be that each process reports\n" \
" shutdown being set to 1.\n\n" \
" [-o|--host hostname] the hostname of this process (def:localhost)\n" \
" [-d|--domain domain] the knowledge domain to send and listen to\n" \
" [-i|--id id] the id of this agent (should be non-negative)\n" \
" [-l|--level level] the logger level (0+, higher is higher detail)\n" \
" [-f|--logfile file] log to a file\n" \
"\n",
argv[0]);
exit (0);
}
}
}
int main (int argc, char ** argv)
{
handle_arguments (argc, argv);
settings.type = madara::transport::SPLICE;
settings.reliability = madara::transport::RELIABLE;
madara::knowledge::WaitSettings wait_settings;
wait_settings.max_wait_time = 10;
if (settings.id == 0)
settings.on_data_received_logic = "out_of_resources => emergency = 1; emergency => shutdown = 1";
else
settings.on_data_received_logic = "heavy_processes > 0 => out_of_resources = 1; emergency => shutdown = 1";
madara::knowledge::KnowledgeBase knowledge (host, settings);
knowledge.set (".id", (Integer) settings.id);
if (settings.id == 0)
{
madara::knowledge::CompiledExpression compiled =
knowledge.compile ("heavy_processes = 1 ;> shutdown");
knowledge.wait (compiled, wait_settings);
}
else
{
madara::knowledge::CompiledExpression compiled =
knowledge.compile ("shutdown");
knowledge.wait (compiled, wait_settings);
}
knowledge.print_knowledge ();
return 0;
} | [
"jedmondson@gmail.com"
] | jedmondson@gmail.com |
2a0fabdb06b5ec2d1020c22646ff1503b0c3e376 | 59c47e1f8b2738fc2b824462e31c1c713b0bdcd7 | /006-All_Test_Demo/000-vital/000-sodimas_notice/000-code/SOD_DISPLAY-old/BST_IDE/ui/graphics/graphicsbutton.cpp | c96e1372ca97a6a9a8114b26984e4f42db1fc0a7 | [] | no_license | casterbn/Qt_project | 8efcc46e75e2bbe03dc4aeaafeb9e175fb7b04ab | 03115674eb3612e9dc65d4fd7bcbca9ba27f691c | refs/heads/master | 2021-10-19T07:27:24.550519 | 2019-02-19T05:26:22 | 2019-02-19T05:26:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,488 | cpp | #include "graphicsbutton.h"
GraphicsButton::GraphicsButton(QGraphicsItem *parent) :
GraphicsOperate(parent)
{
}
bool GraphicsButton::Start()
{
if(GraphicsOperate::Start() == false)
return false;
m_ButtonState = PIC_DARK;
emit sUpdateCom(0);
return true;
}
bool GraphicsButton::PaintEffect(QPainter *p)
{
if(m_AreaAnimate == 0)
{
//>@首先绘制按钮底图
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(PIC_DARK):(PIC_LIGHT)), rect());
//>@最终绘制文字
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(TEXT_DARK):(TEXT_LIGHT)), rect());
return false;
}
switch(m_AreaAnimate->mEffectType)
{
case EffectTypeSpread:
{
//>@首先绘制按钮底图
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(PIC_DARK):(PIC_LIGHT)), rect());
//>@其次特效绘图
m_PixmapPointer.mLastPointer = GetPixmap(PIC_EFFECT);
m_PixmapPointer.mCurPointer = m_PixmapPointer.mLastPointer;
Paint2D_Spread(p, rect());
//>@最终绘制文字
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(TEXT_DARK):(TEXT_LIGHT)), rect());
break;
}
case EffectTypeWheel:
{
//>@首先绘制按钮底图
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(PIC_DARK):(PIC_LIGHT)), rect());
//>@其次特效绘图
m_PixmapPointer.mLastPointer = GetPixmap(PIC_EFFECT);
m_PixmapPointer.mCurPointer = m_PixmapPointer.mLastPointer;
Paint2D_Wheel(p, rect());
//>@最终绘制文字
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(TEXT_DARK):(TEXT_LIGHT)), rect());
break;
}
case EffectTypeRotate:
{
QImage tmpImage(size().toSize(), QImage::Format_ARGB32_Premultiplied);
if(tmpImage.isNull())
return false;
tmpImage.fill(Qt::transparent);
QPainter painter(&tmpImage);
//>@首先绘制按钮底图
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(PIC_DARK):(PIC_LIGHT)), rect());
//>@绘制文字
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(TEXT_DARK):(TEXT_LIGHT)), rect());
painter.end();
//>@最终特效绘图
m_PixmapPointer.mCurPointer = m_PixmapPointer.mLastPointer = QPixmap::fromImage(tmpImage);
Paint2D_Rotate(p, rect());
break;
}
case EffectTypeSlipCycle:
{
//>@首先绘制按钮底图
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(PIC_DARK):(PIC_LIGHT)), rect());
//>@其次特效绘图
m_PixmapPointer.mLastPointer = GetPixmap(PIC_EFFECT);
m_PixmapPointer.mCurPointer = m_PixmapPointer.mLastPointer;
Paint2D_Slipcycle(p, rect());
//>@最终绘制文字
DrawPixmap(p, GetPixmap((m_ButtonState == PIC_DARK)?(TEXT_DARK):(TEXT_LIGHT)), rect());
break;
}
default:
Paint2D_None(p, rect());
break;
}
return true;
}
void GraphicsButton::updateEffect(AREA_OPERATE pOperate, QVariant pPara)
{
switch(pOperate)
{
case OPERATE_KEYPRESS:
{
if(m_ButtonState == PIC_LIGHT)
{
updateEffect(OPERATE_KEYRELEASE, pPara);
return;
}
m_ButtonState = PIC_LIGHT;
emit reportEffect(OPERATE_KEYPRESS, QVariant(GetCurType()));
break;
}
case OPERATE_KEYLIGHT:
{
if(m_ButtonState == PIC_LIGHT)
return;
pOperate = OPERATE_KEYPRESS;
m_ButtonState = PIC_LIGHT;
break;
}
case OPERATE_KEYRELEASE:
{
if(m_ButtonState == PIC_DARK)
return;
if(m_Animator.state() == QTimeLine::Running)
return;
m_ButtonState = PIC_DARK;
emit reportEffect(OPERATE_KEYCANCEL, QVariant(GetCurType()));
break;
}
default:
return;
}
m_OperateInfo[STEP0].mValid = false;
m_OperateInfo[STEP1].mValid = false;
m_Animator.stop();
m_OperateInfo[STEP0].mValid = true;
m_OperateInfo[STEP0].mOperate = pOperate;
m_OperateInfo[STEP1].mValid = true;
m_OperateInfo[STEP1].mOperate = OPERATE_NONE;
//>@执行STEP0中的内容
OperateStep0();
}
//#################################################################################
//#################################################################################
DesignButton::DesignButton(QGraphicsItem *parent) :
GraphicsButton(parent)
{
QAction *tmpDefault = m_ActionGroup->addAction(tr("None"));
m_ActionGroup->addAction(tr("Press"));
m_ActionGroup->addAction(tr("Release"));
tmpDefault->setChecked(true);
}
QList<QAction*> DesignButton::GetActionList()
{
QList<QAction*> tmpList;
if(m_ActionGroup)
{
tmpList = m_ActionGroup->actions();
//>@根据当前已有的资源使能响应功能Action
for(int i=0;i<tmpList.count();i++)
{
QAction *tmpAction = tmpList.at(i);
if(tmpAction == 0)
continue;
tmpAction->setEnabled(true);
}
}
return tmpList;
}
void DesignButton::ExecAction(QAction *pAction)
{
if(pAction->text().compare("Press")==0)
updateEffect(OPERATE_KEYPRESS, QVariant());
else if(pAction->text().compare("Release")==0)
updateEffect(OPERATE_KEYRELEASE, QVariant());
}
//#################################################################################
//#################################################################################
GraphicsFloorButton::GraphicsFloorButton(QGraphicsItem *parent) :
GraphicsOperate(parent)
{
mRow = mColunm = mCount = 0;
mWidth = mHeight = mTextWidth = mTextHeight = 0;
mRSpace = mCSpace = mItemLSpace = mItemRSpace = 0;
}
bool GraphicsFloorButton::InitSubEffectPara(AREA_STYLE* pAreaStyle, QString pLabel, QString pContent)
{
if(pLabel.compare(PARA_PATTERN, Qt::CaseInsensitive) == 0)
{
if(pContent == QString("Grid"))
m_Pattern = PTN_FB_GRID;
else if(pContent == QString("Ellipse"))
m_Pattern = PTN_FB_ELLIPSE;
else if(pContent == QString("Guide"))
m_Pattern = PTN_FB_GUIDE;
}
else if(pLabel.compare(PARA_RSPACE, Qt::CaseInsensitive) == 0)
{
bool ok;
int dec = pContent.toInt(&ok, 10); //>@10进制
if(ok)
mRSpace = dec;
}
else if(pLabel.compare(PARA_CSPACE, Qt::CaseInsensitive) == 0)
{
bool ok;
int dec = pContent.toInt(&ok, 10); //>@10进制
if(ok)
mCSpace = dec;
}
else if(pLabel.compare(PARA_AMOUNT, Qt::CaseInsensitive) == 0)
{
bool ok;
int dec = pContent.toInt(&ok, 10); //>@10进制
if(ok)
mCount = dec;
}
else if(pLabel.compare(PARA_ROW, Qt::CaseInsensitive) == 0)
{
bool ok;
int dec = pContent.toInt(&ok, 10); //>@10进制
if(ok)
mRow = dec;
}
else if(pLabel.compare(PARA_COLUMN, Qt::CaseInsensitive) == 0)
{
bool ok;
int dec = pContent.toInt(&ok, 10); //>@10进制
if(ok)
mColunm = dec;
}
return true;
}
void GraphicsFloorButton::updateEffect(AREA_OPERATE pOperate, QVariant pPara)
{
switch(pOperate)
{
case OPERATE_ADD:
{
int tmpNewFloor = pPara.toInt();
FloorBtnInfo* tmpFloor = m_FloorBtnInfoList.at(tmpNewFloor);
if(tmpFloor && tmpFloor->mButtonItem)
tmpFloor->mButtonItem->updateEffect(OPERATE_KEYLIGHT, QVariant());
break;
}
case OPERATE_DEL:
{
int tmpDelFloor = pPara.toInt();
FloorBtnInfo* tmpFloor = m_FloorBtnInfoList.at(tmpDelFloor);
if(tmpFloor && tmpFloor->mButtonItem)
tmpFloor->mButtonItem->updateEffect(OPERATE_KEYRELEASE, QVariant());
break;
}
default:
return;
}
}
quint32 GraphicsFloorButton::GetMappedType(quint32 pType)
{
return pType;
}
//>@Type->MappedType
bool GraphicsFloorButton::AddButton(quint32 pType, GraphicsButton *&pButton, QRectF pRect)
{
if(pButton)
pButton->deleteLater();
pButton = new GraphicsButton(this);
pButton->SetComGeometory(pRect);
pButton->SetType(pType);
//>@获取资源
//>@映射信号到显示数字
quint32 tmpMappedType = GetMappedType(pType);
FLOOR_INFO tmpFloor(tmpMappedType);
QHash<int, RC_INFO*> tmpRcList;
tmpRcList.insert(PIC_DARK, m_EffectRC.value(PIC_DARK));
tmpRcList.insert(PIC_LIGHT, m_EffectRC.value(PIC_LIGHT));
tmpRcList.insert(PIC_EFFECT, m_EffectRC.value(PIC_EFFECT));
tmpRcList.insert(TEXT_DARK, CreateRcInfo(GetBtnRc(pRect.size(), tmpFloor, false)));
tmpRcList.insert(TEXT_LIGHT, CreateRcInfo(GetBtnRc(pRect.size(), tmpFloor, true)));
pButton->InitComponent(tmpRcList, m_EffectGroup);
//>@建立信号连接
connect(pButton, SIGNAL(reportEffect(AREA_OPERATE,QVariant)), this, SIGNAL(reportEffect(AREA_OPERATE,QVariant)));
return true;
}
bool GraphicsFloorButton::InitFloorBtnInfoList()
{
ReleaseFloorBtnInfoList();
switch(m_Pattern)
{
case PTN_FB_GRID:
{
qreal width = size().width();
qreal height = size().height();
if(mCount == 0 || mRow == 0 || mColunm == 0)
return false;
mWidth = width/(qreal)mColunm;
mHeight = height/(qreal)mRow;
mTextHeight = mHeight * 3.0 / 4.0;
mTextWidth = mTextHeight * 3.0 / 5.0;
int row = -1, column = -1;
for(quint32 i=0;i<mCount;i++)
{
if(i%mColunm == 0)
row += 1;
column = i - row*mColunm;
FloorBtnInfo *tmpFloorBtnInfo = new FloorBtnInfo;
tmpFloorBtnInfo->mRect = QRect(column*mWidth+mCSpace,
row*mHeight+mRSpace,
mWidth-2*(mCSpace),
mHeight-2*(mRSpace));
AddButton(i, tmpFloorBtnInfo->mButtonItem, tmpFloorBtnInfo->mRect);
m_FloorBtnInfoList.append(tmpFloorBtnInfo);
}
break;
}
case PTN_FB_ELLIPSE:
{
qreal width = size().width();
qreal height = size().height();
if(mCount == 0)
return false;
qreal tmpAngelDiff = 2*PI/(qreal)mCount;
qreal tmpBeginAngle = 0; //>@从0度开始排列
qreal tmpTwirlA = width / 3.0; //>@取椭圆的长半径a为1/3的长度，b为1/3的长度
qreal tmpTwirlB = height / 3.0;
int halfcount = (int)((qreal)mCount / 2.0 - 1);
mWidth = tmpTwirlA/(qreal)halfcount;
mHeight = tmpTwirlB/(qreal)halfcount;
mTextHeight = mHeight * 2.0 / 3.0;
mTextWidth = mTextHeight * 3.0 / 5.0;
QPointF tmpCentrePoint = QPointF(width/2.0, height/2.0);
for(quint32 i=0;i<mCount;i++)
{
FloorBtnInfo *tmpFloorBtnInfo = new FloorBtnInfo;
qreal tmpAngle = RegularAngle(tmpBeginAngle + tmpAngelDiff * i);
QPointF tmpItemCentrePoint = tmpCentrePoint + QPointF(tmpTwirlA*qCos(tmpAngle), -tmpTwirlB*qSin(tmpAngle));
tmpFloorBtnInfo->mRect = QRect(tmpItemCentrePoint.x() - mWidth/2.0 + mCSpace,
tmpItemCentrePoint.y() - mHeight/2.0 + mRSpace,
mWidth - 2*(mCSpace),
mHeight - 2*(mRSpace));
AddButton(i, tmpFloorBtnInfo->mButtonItem, tmpFloorBtnInfo->mRect);
m_FloorBtnInfoList.append(tmpFloorBtnInfo);
}
break;
}
case PTN_FB_GUIDE:
{
break;
}
default:
return false;
}
return true;
}
void GraphicsFloorButton::ReleaseFloorBtnInfoList()
{
for(int i=m_FloorBtnInfoList.count()-1;i>=0;i--)
{
FloorBtnInfo *tmpFloorBtnInfo = m_FloorBtnInfoList.takeAt(i);
if(tmpFloorBtnInfo == 0)
continue;
delete tmpFloorBtnInfo;
}
}
int GraphicsFloorButton::PrepareBtnChar(char pAscii, bool pLight)
{
if(pAscii >= '0' && pAscii <= '9')
return pLight ? (pAscii-'0'+14) : (pAscii-'0');
else if(pAscii >= 'A' && pAscii <= 'D')
return pLight ? (pAscii-'A'+24) : (pAscii-'A'+10);
return -1;
}
QPixmap GraphicsFloorButton::GetBtnRc(QSizeF pSize, FLOOR_INFO pFloorInfo, bool pLight)
{
//>@准备资源
QImage tmpImage(pSize.width(), pSize.height(), QImage::Format_ARGB32_Premultiplied);
if(tmpImage.isNull())
return QPixmap();
tmpImage.fill(Qt::transparent); //>@创建透明图层
QPainter painter(&tmpImage);
painter.translate(pSize.width()/2.0, pSize.height()/2.0);
//>@绘制文字
if(pFloorInfo.mHundredBits != 0xff)
{
DrawPixmap(&painter,
GetPixmap(PrepareBtnChar(pFloorInfo.mHundredBits, pLight), QSizeF(mTextWidth,mTextHeight)),
QRectF(-mTextWidth*3.0/2.0, -mTextHeight/2.0, mTextWidth, mTextHeight));
DrawPixmap(&painter,
GetPixmap(PrepareBtnChar(pFloorInfo.mTenBits, pLight), QSizeF(mTextWidth,mTextHeight)),
QRectF(-mTextWidth/2.0, -mTextHeight/2.0, mTextWidth, mTextHeight));
DrawPixmap(&painter,
GetPixmap(PrepareBtnChar(pFloorInfo.mSingleBits, pLight), QSizeF(mTextWidth,mTextHeight)),
QRectF(mTextWidth/2.0, -mTextHeight/2.0, mTextWidth, mTextHeight));
}
else if(pFloorInfo.mTenBits != 0xff)//>@表示没有百位有十位
{
DrawPixmap(&painter,
GetPixmap(PrepareBtnChar(pFloorInfo.mTenBits, pLight), QSizeF(mTextWidth,mTextHeight)),
QRectF(-mTextWidth, -mTextHeight/2.0, mTextWidth, mTextHeight));
DrawPixmap(&painter,
GetPixmap(PrepareBtnChar(pFloorInfo.mSingleBits, pLight), QSizeF(mTextWidth,mTextHeight)),
QRectF(0, -mTextHeight/2.0, mTextWidth, mTextHeight));
}
else if(pFloorInfo.mSingleBits != 0xff) //>@3456
{
DrawPixmap(&painter,
GetPixmap(PrepareBtnChar(pFloorInfo.mSingleBits, pLight), QSizeF(mTextWidth,mTextHeight)),
QRectF(-mTextWidth/2.0, -mTextHeight/2.0, mTextWidth, mTextHeight));
}
painter.end();
return QPixmap::fromImage(tmpImage);
}
bool GraphicsFloorButton::Start()
{
if(GraphicsComponent::Start() == false)
return false;
InitFloorBtnInfoList();
return true;
}
//#################################################################################
//#################################################################################
DesignFloorButton::DesignFloorButton(QGraphicsItem *parent) :
GraphicsFloorButton(parent)
{
QAction *tmpDefault = m_ActionGroup->addAction(tr("None"));
m_ActionGroup->addAction(tr("Press"));
m_ActionGroup->addAction(tr("Release"));
tmpDefault->setChecked(true);
}
QSize DesignFloorButton::GetRcSize(QString pRcName)
{
int tmpKey = GetKey(pRcName);
if((tmpKey >= 0 && tmpKey <= 13) || (tmpKey >= 50 && tmpKey <= 63))
return QSize(mTextWidth, mTextHeight);
return QSize(mWidth-mCSpace*2, mHeight-mRSpace*2);
}
QList<QAction*> DesignFloorButton::GetActionList()
{
QList<QAction*> tmpList;
if(m_ActionGroup)
{
tmpList = m_ActionGroup->actions();
//>@根据当前已有的资源使能响应功能Action
for(int i=0;i<tmpList.count();i++)
{
QAction *tmpAction = tmpList.at(i);
if(tmpAction == 0)
continue;
tmpAction->setEnabled(true);
}
}
return tmpList;
}
void DesignFloorButton::ExecAction(QAction *pAction)
{
if(pAction->text().compare("Press")==0)
{
int count = m_FloorBtnInfoList.count();
FloorBtnInfo *tmpFloor = m_FloorBtnInfoList.at(qrand() % count);
if(tmpFloor)
tmpFloor->mButtonItem->updateEffect(OPERATE_KEYPRESS, QVariant());
}
else if(pAction->text().compare("Release")==0)
{
int count = m_FloorBtnInfoList.count();
FloorBtnInfo *tmpFloor = m_FloorBtnInfoList.at(qrand() % count);
if(tmpFloor)
tmpFloor->mButtonItem->updateEffect(OPERATE_KEYRELEASE, QVariant());
}
}
| [
"1343726739@qq.com"
] | 1343726739@qq.com |
62db2ee1ced0edd53a2ad2fccd6936d517353ad2 | 20b2af5e275469261d95d4441303d567b5c03bba | /src/motion/Walking/StateHandling/WalkManState.hpp | 1bea18ffce0077c7b9b9fc88efd3f0cb0fb16a15 | [
"BSD-2-Clause"
] | permissive | humanoid-robotics-htl-leonding/robo-ducks-core | efd513dedf58377dadc6a3094dd5c01f13c32eb1 | 1644b8180214b95ad9ce8fa97318a51748b5fe3f | refs/heads/master | 2022-04-26T17:19:00.073468 | 2020-04-23T07:05:25 | 2020-04-23T07:05:25 | 181,146,731 | 7 | 0 | NOASSERTION | 2022-04-08T13:25:14 | 2019-04-13T09:07:29 | C++ | UTF-8 | C++ | false | false | 4,936 | hpp | #pragma once
#include "Data/BodyPose.hpp"
#include "Data/CycleInfo.hpp"
#include "Data/KickConfigurationData.hpp"
#include "Data/MotionActivation.hpp"
#include "Data/MotionPlannerOutput.hpp"
#include "Data/MotionRequest.hpp"
#include "Data/WalkGenerator.hpp"
/**
* @brief WalkManState a wrapper to hold the shared state
*/
struct WalkManState
{
WalkManState(const MotionActivation& ma, const MotionPlannerOutput& mpo, const MotionRequest& mr,
const KickConfigurationData& kcd, const BodyPose& bp, const WalkGenerator& wg,
const CycleInfo& ci, float minTimeInStand)
: motionActivation(ma)
, motionPlannerOutput(mpo)
, motionRequest(mr)
, kickConfigurationData(kcd)
, bodyPose(bp)
, walkGenerator(wg)
, cycleInfo(ci)
, minTimeInStandBeforeLeaving(minTimeInStand)
{
}
/// passed content of external dependencies
/// some information about which motion is currently active
const MotionActivation& motionActivation;
/// the request of the motion planner
const MotionPlannerOutput& motionPlannerOutput;
/// the unmodified request comming from brain
const MotionRequest& motionRequest;
/// some parameters to perform in walk kicks
const KickConfigurationData& kickConfigurationData;
/// some information about the body pose (fallen etc.)
const BodyPose& bodyPose;
/// the generator that can the walking joints
const WalkGenerator& walkGenerator;
/// some information about the timing of the current cycle
const CycleInfo& cycleInfo;
/// the minimum time we need to stand before we can start walking again
const float minTimeInStandBeforeLeaving;
/// some additional private members that are calculated depending on the state
/// a function to calculate an offset to add to the poes of the swinging foot to create a kick
/// motion
std::function<KinematicMatrix(const float phase)> getKickFootOffset =
std::function<KinematicMatrix(float)>();
/// the speed that is requested from the walk generator
Pose speed = Pose();
/// the relative target in target mode
Pose target = Pose();
/// the relative direction we currently want to walk to
Pose walkPathGradient = Pose();
/// the last relative target
Pose lastTarget = Pose();
/// the last target processed
TimePoint lastTimeWalking = TimePoint(0);
/// the currently selected walk mode as understood by the generator
WalkGenerator::WalkMode walkMode = WalkGenerator::WalkMode::VELOCITY_MODE;
void setWalkParametersForVelocityMode(
const Velocity& velocity,
const std::function<KinematicMatrix(const float phase)>& getKickFootOffset =
std::function<KinematicMatrix(float)>())
{
assert(!velocity.isPercentage());
// in case of very small velocity requests in velocity mode we request clip to a small value
// epsilon (for division by 0 reasons, and for the fact that we might want to perform an
// inWalkKick with zero walk velocity). This will make the nao walk on the spot. If brain wants
// to stand (instead of walk on a spot) it has to use the target mode.
const float epsilon = 0.0000001f;
speed = velocity.translation.norm() < epsilon ? Pose(epsilon, 0.f, velocity.rotation)
: Pose(velocity.translation, velocity.rotation);
walkPathGradient = speed;
walkMode = WalkGenerator::WalkMode::VELOCITY_MODE;
this->getKickFootOffset = getKickFootOffset;
lastTarget = Pose(10000.f, 10000.f);
}
void setWalkParametersForTargetMode(const Velocity& velocityComponentLimits, const Pose& target,
const Pose& walkPathGradient)
{
assert(!velocityComponentLimits.isPercentage());
speed = Pose(velocityComponentLimits.translation, velocityComponentLimits.rotation);
this->walkPathGradient = walkPathGradient;
if (target != lastTarget)
{
this->target = lastTarget = target;
}
walkMode = WalkGenerator::WalkMode::TARGET_MODE;
this->getKickFootOffset = std::function<KinematicMatrix(float)>();
}
void setWalkParametersForStepSizeMode(
const Pose& stepPoseOffset,
const std::function<KinematicMatrix(const float phase)>& getKickFootOffset =
std::function<KinematicMatrix(float)>())
{
const float epsilon = 0.0000001f;
speed = stepPoseOffset.position.norm() < epsilon
? Pose(epsilon, 0.f, stepPoseOffset.orientation)
: Pose(stepPoseOffset.position, stepPoseOffset.orientation);
walkPathGradient = stepPoseOffset;
walkMode = WalkGenerator::WalkMode::STEP_SIZE_MODE;
this->getKickFootOffset = getKickFootOffset;
lastTarget = Pose(10000.f, 10000.f);
}
void setWalkParametersForStand()
{
speed = Pose();
walkMode = WalkGenerator::WalkMode::VELOCITY_MODE;
getKickFootOffset = std::function<KinematicMatrix(float)>();
lastTarget = Pose(10000.f, 10000.f);
}
};
| [
"rene.kost.951@gmail.com"
] | rene.kost.951@gmail.com |
c6884d5ee588d1070b63153cc4aa84899503b844 | 7fb5cbbf3544e6f3449deb6cf4286a57ec392394 | /cpplang/ex/9.6.1.cc | 6f7eda074fa4fb98eb501a8cafcbb9168d645d89 | [] | no_license | Airead/excise | 94201e3b718fec23549a1402d9f0b2f480f78e0c | ba46918a37aca4e01fce3d806cfa2da325c19257 | refs/heads/master | 2021-05-16T02:12:47.133734 | 2019-10-16T02:44:12 | 2019-10-16T02:44:12 | 2,176,767 | 3 | 1 | null | 2019-10-16T02:44:13 | 2011-08-09T00:43:17 | JavaScript | UTF-8 | C++ | false | false | 2,681 | cc | /**
* @file 9.6.1.cc
* @brief
* @author Airead Fan <fgh1987168@gmail.com>
* @date 2013/04/21 21:50:20
*/
/*
1. Here is a header file:
Note that setgolf() is overloaded. Using the first version of setgolf() would look like
this:
golf ann;
setgolf(ann, “Ann Birdfree”, 24);
The function call provides the information that’s stored in the ann structure. Using the
second version of setgolf() would look like this:
golf andy;
setgolf(andy);
The function would prompt the user to enter the name and handicap and store them in
the andy structure. This function could (but doesn’t need to) use the first version inter-
nally.
Put together a multifile program based on this header. One file, named golf.cpp, should
provide suitable function definitions to match the prototypes in the header file. A second
file should contain main() and demonstrate all the features of the prototyped functions.
For example, a loop should solicit input for an array of golf structures and terminate
when the array is full or the user enters an empty string for the golfer’s name. The
main() function should use only the prototyped functions to access the golf structures.
*/
#if 0
// golf.h -- for pe9-1.cpp
const int Len = 40;
struct golf
{
char fullname[Len];
int handicap;
};
// non-interactive version:
// function sets golf structure to provided name, handicap
// using values passed as arguments to the function
void setgolf(golf & g, const char * name, int hc);
// interactive version:
// function solicits name and handicap from user
// and sets the members of g to the values entered
// returns 1 if name is entered, 0 if name is empty string
int setgolf(golf & g);
// function resets handicap to new value
void handicap(golf & g, int hc);
// function displays contents of golf structure
void showgolf(const golf & g);
#endif
#include <iostream>
#include "golf.h"
int main(int argc, char *argv[])
{
const int Size = 3;
golf golfs[Size];
int num = 0;
setgolf(golfs[0], "Ann Birdfree", 24);
num++;
for (int i = 1; i < Size; i++) {
/* int ret;
* ret = setgolf(golfs[i]);
* if (ret == 0) { */
if (setgolf(golfs[i]) == 0) {
break;
}
num++;
}
std::cout << "\n=================================\n";
for (int i = 0; i < num; i++) {
showgolf(golfs[i]);
std::cout << std::endl;
}
std::cout << "\n=================================\n";
handicap(golfs[0], 48);
for (int i = 0; i < num; i++) {
showgolf(golfs[i]);
std::cout << std::endl;
}
std::cout << std::endl;
return 0;
}
| [
"fgh1987168@gmail.com"
] | fgh1987168@gmail.com |
f94b538f29ae2b323267f2db84ef0c4f9c45c7cd | 8b0fde12efef911788682d88e92e2e5f05348951 | /hw4/assign62/assign62.cpp | 8a107abb2f9dfe48237a74b84bc160d5e22fb9b4 | [] | no_license | rollerseth/CPlusPlus-Programs-1 | 12a4f7b221e2ff61e0e98f79182757ae8eca821b | c7d848524b5b5ba9bafa9fe531a3867bb74f4a66 | refs/heads/master | 2022-03-18T11:53:48.421389 | 2019-10-31T23:02:55 | 2019-10-31T23:02:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,594 | cpp | /*
#Filename: assign62.cpp
#Author: Seth Roller
#Date: 3/19/19
#Program Name: assign62.cpp
#Assignment Number: 62
#Problem: Will create a abstract data type(ADT)
queue through an dynamically allocated array
#Flow: The main file will have the layout for the menu
decision process. This utilizes a while true
loop until specified
#Sources:
*http://mathcs.wilkes.edu/~bracken/cs226/
*link above was used for the skeleton files
*Dr. Bracken aided me with using the mod operator to insert and delete
I have thoroughly tested my code and it works properly
*/
#include<fstream>
#include<cassert>
#include<iostream>
#include"queuea.h"
#include<string>
int main()
{
// for turnin
cout << endl;
// DECLARATIONS
queueClass queue1;
bool answer = true;
bool theLoop = true;
int option = 0;
int item = 0;
cout << endl;
cout << "Name: Seth Roller" << endl;
cout << "Lab Name: Queues" << endl;
cout << "Problem: An ADT called queue has been implemented ";
cout << endl;
cout << "so that users can modify a queues's contents." << endl;
cout << endl;
cout << "1. Enqueue data onto queue" << endl;
cout << "2. Dequeue and print data from the queue" << endl;
cout << "3. Print data at the front without dequeing" << endl;
cout << "4. Print entire queue" << endl;
cout << "5. Print status: empty or not empty" << endl;
cout << "6. Exit the menu loop" << endl << endl;
while (theLoop) {
cout << "Enter your option: ";
cin >> option;
cout << endl; // for turnin
// checks to see if the entered input is an integer
if (!cin.good()) {
cin.clear();
cin.ignore(120, '\n');
cout << "Invalid input!" << endl << endl;
cout << endl;
cout << "Please enter an integer that is between 1 and 6";
cout << "\n\n";
} // end of if
// goes to check whether the integer entered is valid
// through a switch case
else {
cout << "You entered " << option << endl << endl;
// if statement to check if option is in the bounds
if (option >= 1 && option < 6) {
switch (option) {
case 1:
while (true) {
cout << "Enter an integer: ";
cin >> item;
if (cin.good()) {
queue1.QueueInsert(item, answer);
cout << endl; // for turnin
cout << "You entered " << item << endl << endl;
break;
}
cout << endl << endl;
cout << "Invalid input, enter an integer";
cout << endl << endl;
cin.clear();
cin.ignore(120, '\n');
}
cout << item << " was added into the queue";
cout << "\n\n";
break;
case 2:
queue1.QueueDelete(item, answer);
if (answer == true)
cout << item << " has been deleted from the queue" << "\n\n";
else
cout << "The queue is empty" << "\n\n";
break;
case 3:
queue1.GetQueueFront(item, answer);
if (answer == true)
cout << "The front of the queue: " << item << endl;
cout << endl;
break;
case 4:
queue1.QueuePrint();
cout << endl;
break;
case 5:
if (queue1.QueueIsEmpty() == true)
cout << "The queue is empty" << endl << endl;
else
cout << "The queue is NOT empty" << endl << endl;
break;
} // end of switch
}
else if (option == 6) {
theLoop = false;
}
else {
cout << "Invalid Input!" << endl;
cout << "Please enter an integer that is between 1 and 6";
cout << endl << endl;
}
} // end of 1st else
}
return 0;
}//end of main
| [
"noreply@github.com"
] | rollerseth.noreply@github.com |
faec913994caa05ca0df67ab4491aa3225e8c462 | a3d6556180e74af7b555f8d47d3fea55b94bcbda | /components/exo/wayland/zcr_ui_controls.h | 7967a7c4ed9b6d40e31c8cfbcfcc87a7718bef8a | [
"BSD-3-Clause"
] | permissive | chromium/chromium | aaa9eda10115b50b0616d2f1aed5ef35d1d779d6 | a401d6cf4f7bf0e2d2e964c512ebb923c3d8832c | refs/heads/main | 2023-08-24T00:35:12.585945 | 2023-08-23T22:01:11 | 2023-08-23T22:01:11 | 120,360,765 | 17,408 | 7,102 | BSD-3-Clause | 2023-09-10T23:44:27 | 2018-02-05T20:55:32 | null | UTF-8 | C++ | false | false | 799 | h | // Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_EXO_WAYLAND_ZCR_UI_CONTROLS_H_
#define COMPONENTS_EXO_WAYLAND_ZCR_UI_CONTROLS_H_
#include <memory>
#include "base/component_export.h"
namespace exo::wayland {
class Server;
class COMPONENT_EXPORT(UI_CONTROLS_PROTOCOL) UiControls {
public:
explicit UiControls(Server* server);
UiControls(const UiControls&) = delete;
UiControls& operator=(const UiControls&) = delete;
~UiControls();
// Tracks button and mouse states as well as pending requests testing.
struct UiControlsState;
private:
std::unique_ptr<UiControlsState> state_;
};
} // namespace exo::wayland
#endif // COMPONENTS_EXO_WAYLAND_ZCR_UI_CONTROLS_H_
| [
"chromium-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | chromium-scoped@luci-project-accounts.iam.gserviceaccount.com |
69003c4d6ba95a78266f2aa71abd3732e820a817 | 32a97a55c0d38573310043e420c685f6943c798b | /code/app/src/scenario_benchmark.cpp | 379d30ecdd7a58109d864faa98c55b0ff9756900 | [] | no_license | allscale/allscale_amdados | 9af76a5fbd0ab4cc21b8c5bf0f1de6a9a6d94f7f | a080b6afc95d6f15f67a318854417fc45f187054 | refs/heads/master | 2020-03-30T01:52:23.638476 | 2018-10-09T12:51:40 | 2018-10-09T12:51:40 | 150,599,514 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 7,481 | cpp | //-----------------------------------------------------------------------------
// Author : Albert Akhriev, albert_akhriev@ie.ibm.com
// Copyright : IBM Research Ireland, 2017-2018
//-----------------------------------------------------------------------------
#include <cmath>
#include <iostream>
#include <iomanip>
#include <map>
#include <chrono>
#include "allscale/api/user/data/adaptive_grid.h"
#include "allscale/api/user/algorithm/pfor.h"
#include "allscale/api/core/io.h"
#include "allscale/utils/assert.h"
#include "allscale/utils/vector.h"
#include "amdados/app/amdados_utils.h"
#include "amdados/app/configuration.h"
#include "amdados/app/geometry.h"
#include "amdados/app/matrix.h"
#include "amdados/app/debugging.h"
#include "amdados/app/sensors_generator.h"
namespace amdados {
using ::allscale::api::user::data::Grid;
using ::allscale::api::user::data::GridPoint;
// Defined in "scenario_simulation.cpp":
void InitDependentParams(Configuration & conf);
void RunDataAssimilation(const Configuration & conf,
const Grid<point_array_t,2> & sensors,
const Grid<Matrix,2> & observations);
// Defined in "scenario_sensors.cpp":
void OptimizePointLocations(double_array_t & x, double_array_t & y);
void InitialGuess(const Configuration & conf,
double_array_t & x,
double_array_t & y,
const point2d_t & idx);
namespace {
//-----------------------------------------------------------------------------
// Generator or synthetic data for benchmarking.
//-----------------------------------------------------------------------------
void GenerateSensorData(const Configuration & conf,
Grid<point_array_t,2> & sensors,
Grid<Matrix,2> & observations)
{
// Define useful constants.
const point2d_t GridSize = GetGridSize(conf);
// const double fraction =
// Bound(conf.asDouble("sensor_fraction"), 0.001, 0.75);
const size2d_t finest_layer_size(conf.asUInt("subdomain_x"),
conf.asUInt("subdomain_y"));
// --- initialize sensor positions ---
// // Function scales a coordinate from [0..1] range to specified size.
// auto ScaleCoord = [](double v, index_t size) -> index_t {
// index_t i = static_cast<index_t>(std::floor(v * size));
// i = std::min(std::max(i, index_t(0)), size - 1);
// return i;
// };
//
// // Global (whole domain) sizes.
// const auto Nx = conf.asInt("subdomain_x") * GridSize.x;
// const auto Ny = conf.asInt("subdomain_y") * GridSize.y;
// const auto problem_size = Nx * Ny;
//
// // Generate pseudo-random sensor locations.
// const int Nobs = std::max(Round(fraction * problem_size), 1);
// std::cout << "\tfraction of sensor points = " << fraction;
// std::cout << ", #observations = " << Nobs << std::endl;
// double_array_t x(Nobs), y(Nobs);
// InitialGuess(conf, x, y, point2d_t(0,0));
// OptimizePointLocations(x, y);
// temporary sensor location storage
std::map< point2d_t, std::vector<point2d_t> > locations;
// // Save (scaled) sensor locations to temporary storage.
// for (int k = 0; k < Nobs; ++k) {
// auto xk = ScaleCoord(x[k], Nx);
// auto yk = ScaleCoord(y[k], Ny);
// // insert sensor position
// point2d_t pt{xk,yk};
// point2d_t idx = allscale::utils::elementwiseDivision(
// pt, finest_layer_size);
// assert_true((0 <= idx.x) && (idx.x < GridSize.x));
// assert_true((0 <= idx.y) && (idx.y < GridSize.y));
//
// locations[idx].push_back(pt % finest_layer_size);
// }
point_array_t sensor_positions;
SensorsGenerator().MakeSensors(conf, sensor_positions);
// Save sensor locations to temporary storage.
for (size_t k = 0; k < sensor_positions.size(); ++k) {
auto x = sensor_positions[k].x;
auto y = sensor_positions[k].y;
// insert sensor position
point2d_t pt{x,y};
point2d_t idx =
allscale::utils::elementwiseDivision(pt, finest_layer_size);
assert_true((0 <= idx.x) && (idx.x < GridSize.x));
assert_true((0 <= idx.y) && (idx.y < GridSize.y));
locations[idx].push_back(pt % finest_layer_size);
}
// --- initialize observations ---
const index_t Nt = static_cast<index_t>(conf.asUInt("Nt"));
assert_eq(sensors.size(), observations.size());
assert_eq(sensors.size(), GridSize);
::allscale::api::user::algorithm::pfor({0,0}, GridSize,
[&sensors, &observations, locations, Nt](const auto & idx) {
allscale::api::core::sema::needs_write_access_on(sensors[idx]);
allscale::api::core::sema::needs_write_access_on(observations[idx]);
// Clear the data structures.
sensors[idx].clear();
observations[idx].Clear();
// Copy sensor positions from temporary to simulation storage.
if (locations.find(idx) != locations.end()) {
sensors[idx] = locations.at(idx);
}
// Insert observations.
const auto num_observations = sensors[idx].size();
Matrix & m = observations[idx];
m.Resize(Nt, num_observations);
// Fill in observation values.
if (num_observations > 0) {
index_t t_step = Nt / num_observations;
for (std::size_t cnt = 0; cnt < num_observations; cnt++) {
m(t_step * cnt, cnt) = 1.0f;
}
}
});
}
} // anonymous namespace
//-----------------------------------------------------------------------------
// Function implements performance testing scenario for Amdados application.
// @param config_file name of configuration file.
// @param problem_size number of subdomains in either dimension.
//-----------------------------------------------------------------------------
void ScenarioBenchmark(const std::string & config_file, int problem_size)
{
MY_TIME_IT("Running scenario 'benchmark' ...")
// --- load configuration ---
// Read the configuration file.
Configuration conf;
conf.ReadConfigFile(config_file.c_str());
// over-ride problem size
conf.SetInt("num_subdomains_x", problem_size);
conf.SetInt("num_subdomains_y", problem_size);
// initialize dependent parameters
InitDependentParams(conf);
conf.PrintParameters();
// print some status info for the user
int steps = conf.asInt("Nt");
std::cout << "Running benchmark based on configuration file \""
<< config_file;
std::cout << "\" with domain size " << problem_size << "x" << problem_size;
std::cout << " for " << steps << " time steps ...\n";
// --- generate sensor data ---
std::cout << "Generating artificial sensory input data ...\n";
Grid<point_array_t,2> sensors(GetGridSize(conf));
Grid<Matrix,2> observations(GetGridSize(conf));
GenerateSensorData(conf, sensors, observations);
// --- run simulation ---
std::cout << "Running benchmark simulation ...\n";
auto start = std::chrono::high_resolution_clock::now();
// Run the simulation with data assimilation. Important: by this time
// some parameters had been initialized in InitDependentParams(..), so
// we can safely proceed to the main part of the simulation algorithm.
RunDataAssimilation(conf, sensors, observations);
auto end = std::chrono::high_resolution_clock::now();
auto duration = end - start;
// --- summarize performance data ---
double time = std::chrono::duration_cast<std::chrono::milliseconds>(
duration).count() / 1000.0;
std::cout << "Simulation took " << time << "s\n";
double throughput = (problem_size * problem_size * steps) / time;
std::cout << "Throughput: " << throughput << " sub-domains/s\n";
}
} // namespace amdados
| [
"albert_akhriev@ie.ibm.com"
] | albert_akhriev@ie.ibm.com |
f06f13b9f880968a8fecfbd7f4c54c3b13fa5748 | b5fddca944db7f6871b4f42e44908084aba1acb5 | /libretro-extract/LibretroDLL.cpp | 741628daabb0769d52e9fa7996f952207c463c7a | [] | no_license | pixl-project/repository.libretro | 303c1719fe9520fcd21c915fb2640ab5eaaff34f | 55645867ef3115787397e38727657541d1438a7b | refs/heads/master | 2021-01-15T08:40:49.388307 | 2014-05-31T07:13:53 | 2014-06-02T02:11:50 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,000 | cpp | /*
* Copyright (C) 2014 Team XBMC
* http://xbmc.org
*
* 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, 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 XBMC; see the file COPYING. If not, see
* <http://www.gnu.org/licenses/>.
*
*/
#include "LibretroDLL.h"
#include "xbmc_game_types.h"
#ifdef _WIN32
#include "dlfcn-win32.h"
#else
#include <dlfcn.h>
#endif
#include <assert.h>
#include <stdio.h>
using namespace LIBRETRO;
using namespace std;
#define ADDON_ID_TYPE "gameclient."
#define LIBRETRO_SUFFIX "_libretro"
CLibretroDLL::CLibretroDLL()
: m_libretroClient(NULL)
{
}
void CLibretroDLL::Unload(void)
{
if (m_libretroClient)
{
dlclose(m_libretroClient);
m_libretroClient = NULL;
}
m_strId.clear();
m_strLibraryDirectory.clear();
m_strSystemDirectory.clear();
m_strContentDirectory.clear();
m_strSaveDirectory.clear();
}
// Get directory part of path, or empty if path doesn't contain any directory separators
string GetDirectory(const string& path)
{
size_t pos = path.find_last_of("/\\");
if (pos != 0 && pos != string::npos)
{
// Don't include trailing slash, it causes some libretro clients to fail
return path.substr(0, pos);
}
return "";
}
// Get filename part of path, or entire path if path doesn't contain any directory separators
string GetFilename(const string& path)
{
size_t pos = path.find_last_of("/\\");
if (pos == string::npos)
return path;
else
return path.substr(pos + 1);
}
// If filename contains ".", the "." and trailing extension will be removed
string RemoveExtension(const string& filename)
{
size_t pos = filename.find_last_of(".");
if (pos == string::npos)
return filename;
else
return filename.substr(0, pos);
}
// If libraryName ends in "_libretro", the "_libretro" part will be stripped
string RemoveLibretroSuffix(const string& libraryName)
{
// TODO: Also check if string ends in "_libretro"
if (libraryName.length() < strlen(LIBRETRO_SUFFIX))
return libraryName;
else
return libraryName.substr(0, libraryName.length() - strlen(LIBRETRO_SUFFIX));
}
// Replace "_" with "."
string ReplaceUnderscoreWithPeriod(const string& str)
{
string strCopy(str);
for (string::iterator it = strCopy.begin(); it != strCopy.end(); ++it)
{
if (*it == '_')
*it = '.';
}
return strCopy;
}
string PrependAddonType(const string& baseId)
{
return ADDON_ID_TYPE + baseId;
}
// Convert functionPtr to a string literal
#define LIBRETRO_REGISTER_SYMBOL(dll, functionPtr) RegisterSymbol(dll, functionPtr, #functionPtr)
// Register symbols from DLL, cast to type T and store in member variable
template <typename T>
bool RegisterSymbol(void* dll, T& functionPtr, const char* strFunctionPtr)
{
return (functionPtr = (T)dlsym(dll, strFunctionPtr)) != NULL;
}
// Trailing slash causes some libretro cores to fail
void RemoveSlashAtEnd(std::string& path)
{
if (!path.empty())
{
char last = path[path.size() - 1];
if (last == '/' || last == '\\')
path.erase(path.size() - 1);
}
}
bool CLibretroDLL::Load(const game_client_properties& gameClientProps)
{
Unload();
m_libretroClient = dlopen(gameClientProps.library_path, RTLD_LAZY);
if (m_libretroClient == NULL)
{
printf("Unable to load %s", dlerror());
return false;
}
try
{
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_set_environment)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_set_video_refresh)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_set_audio_sample)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_set_audio_sample_batch)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_set_input_poll)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_set_input_state)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_init)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_deinit)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_api_version)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_get_system_info)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_get_system_av_info)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_set_controller_port_device)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_reset)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_run)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_serialize_size)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_serialize)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_unserialize)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_cheat_reset)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_cheat_set)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_load_game)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_load_game_special)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_unload_game)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_get_region)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_get_memory_data)) throw false;
if (!LIBRETRO_REGISTER_SYMBOL(m_libretroClient, retro_get_memory_size)) throw false;
}
catch (const bool& bSuccess)
{
printf("Unable to assign function %s", dlerror());
return bSuccess;
}
/*
* ID is determined from dll name. Remove the trailing "_libretro" and
* extension, convert "_" to "." and prefix with "gameclient.", e.g:
* bsnes_accuracy_libretro.dylib -> gameclient.bsnes.accuracy
*/
m_strId = PrependAddonType(
ReplaceUnderscoreWithPeriod(
RemoveLibretroSuffix(
RemoveExtension(
GetFilename(gameClientProps.library_path)))));
m_strLibraryDirectory = GetDirectory(gameClientProps.library_path);
m_strSystemDirectory = gameClientProps.system_directory;
m_strContentDirectory = gameClientProps.content_directory;
m_strSaveDirectory = gameClientProps.save_directory;
// Trailing slash causes some libretro cores to fail
RemoveSlashAtEnd(m_strLibraryDirectory);
RemoveSlashAtEnd(m_strSystemDirectory);
RemoveSlashAtEnd(m_strContentDirectory);
RemoveSlashAtEnd(m_strSaveDirectory);
return true;
}
| [
"garbearucla@gmail.com"
] | garbearucla@gmail.com |
2da56faa0adb547ec4f523fe5b4cf6e0b9353bc6 | c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64 | /Engine/Source/Runtime/SlateCore/Public/Rendering/SlateRenderer.h | e369cb5a8f169227cb0787d9b5faf47ad91c3007 | [
"MIT",
"LicenseRef-scancode-proprietary-license"
] | permissive | windystrife/UnrealEngine_NVIDIAGameWorks | c3c7863083653caf1bc67d3ef104fb4b9f302e2a | b50e6338a7c5b26374d66306ebc7807541ff815e | refs/heads/4.18-GameWorks | 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 | MIT | 2022-12-16T05:36:38 | 2018-03-06T15:44:09 | C++ | UTF-8 | C++ | false | false | 15,384 | h | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "Textures/SlateShaderResource.h"
#include "Brushes/SlateDynamicImageBrush.h"
#include "Rendering/DrawElements.h"
class FRHITexture2D;
class FSlateDrawBuffer;
class FSlateUpdatableTexture;
class ILayoutCache;
class ISlateAtlasProvider;
class ISlateStyle;
class SWindow;
struct Rect;
class FSceneInterface;
struct FSlateBrush;
typedef FRHITexture2D* FTexture2DRHIParamRef;
/**
* Provides access to the game and render thread font caches that Slate should use
*/
class SLATECORE_API FSlateFontServices
{
public:
/**
* Construct the font services from the font caches (we'll create corresponding measure services ourselves)
* These pointers may be the same if your renderer doesn't need a separate render thread font cache
*/
FSlateFontServices(TSharedRef<class FSlateFontCache> InGameThreadFontCache, TSharedRef<class FSlateFontCache> InRenderThreadFontCache);
/**
* Get the font cache to use for the current thread
*/
TSharedRef<class FSlateFontCache> GetFontCache() const;
/**
* Get the font cache to use for the game thread
*/
TSharedRef<class FSlateFontCache> GetGameThreadFontCache() const
{
return GameThreadFontCache;
}
/**
* Get the font cache to use for the render thread
*/
TSharedRef<class FSlateFontCache> GetRenderThreadFontCache() const
{
return RenderThreadFontCache;
}
/**
* Get access to the font measure service for the current thread
*/
TSharedRef<class FSlateFontMeasure> GetFontMeasureService() const;
/**
* Get access to the font measure service for the current thread
*/
TSharedRef<class FSlateFontMeasure> GetGameThreadFontMeasureService() const
{
return GameThreadFontMeasure;
}
/**
* Get access to the font measure service for the current thread
*/
TSharedRef<class FSlateFontMeasure> GetRenderThreadFontMeasureService() const
{
return RenderThreadFontMeasure;
}
/**
* Flushes all cached data from the font cache for the current thread
*/
void FlushFontCache();
/**
* Flushes all cached data from the font cache for the game thread
*/
void FlushGameThreadFontCache();
/**
* Flushes all cached data from the font cache for the render thread
*/
void FlushRenderThreadFontCache();
/**
* Release any rendering resources owned by this font service
*/
void ReleaseResources();
private:
TSharedRef<class FSlateFontCache> GameThreadFontCache;
TSharedRef<class FSlateFontCache> RenderThreadFontCache;
TSharedRef<class FSlateFontMeasure> GameThreadFontMeasure;
TSharedRef<class FSlateFontMeasure> RenderThreadFontMeasure;
};
struct FMappedTextureBuffer
{
void* Data;
int32 Width;
int32 Height;
FMappedTextureBuffer()
: Data(nullptr)
, Width(0)
, Height(0)
{
}
bool IsValid() const
{
return Data && Width > 0 && Height > 0;
}
void Reset()
{
Data = nullptr;
Width = Height = 0;
}
};
/**
* Abstract base class for Slate renderers.
*/
class SLATECORE_API FSlateRenderer
{
public:
/** Constructor. */
explicit FSlateRenderer(const TSharedRef<FSlateFontServices>& InSlateFontServices)
: SlateFontServices(InSlateFontServices)
{
}
/** Virtual destructor. */
virtual ~FSlateRenderer()
{
}
public:
/** Returns a draw buffer that can be used by Slate windows to draw window elements */
virtual FSlateDrawBuffer& GetDrawBuffer() = 0;
virtual bool Initialize() = 0;
virtual void Destroy() = 0;
/**
* Creates a rendering viewport
*
* @param InWindow The window to create the viewport for
*/
virtual void CreateViewport( const TSharedRef<SWindow> InWindow ) = 0;
/**
* Requests that a rendering viewport be resized
*
* @param Window The window to resize
* @param Width The new width of the window
* @param Height The new height of the window
*/
virtual void RequestResize( const TSharedPtr<SWindow>& InWindow, uint32 NewSizeX, uint32 NewSizeY ) = 0;
/**
* Sets fullscreen state on the window's rendering viewport
*
* @param InWindow The window to update fullscreen state on
* @param OverrideResX 0 if no override
* @param OverrideResY 0 if no override
*/
virtual void UpdateFullscreenState( const TSharedRef<SWindow> InWindow, uint32 OverrideResX = 0, uint32 OverrideResY = 0 ) = 0;
/**
* Restore the given window to the resolution settings currently cached by the engine
*
* @param InWindow -> The window to restore to the cached settings
*/
virtual void RestoreSystemResolution(const TSharedRef<SWindow> InWindow) = 0;
/**
* Creates necessary resources to render a window and sends draw commands to the rendering thread
*
* @param WindowDrawBuffer The buffer containing elements to draw
*/
virtual void DrawWindows( FSlateDrawBuffer& InWindowDrawBuffer ) = 0;
/** Callback that fires after Slate has rendered each window, each frame */
DECLARE_MULTICAST_DELEGATE_TwoParams( FOnSlateWindowRendered, SWindow&, void* );
FOnSlateWindowRendered& OnSlateWindowRendered() { return SlateWindowRendered; }
/**
* Called on the game thread right before the slate window handle is destroyed.
* This gives users a chance to release any viewport specific resources they may have active when the window is destroyed
* @param Pointer to the API specific backbuffer type
*/
DECLARE_MULTICAST_DELEGATE_OneParam(FOnSlateWindowDestroyed, void*);
FOnSlateWindowDestroyed& OnSlateWindowDestroyed() { return OnSlateWindowDestroyedDelegate; }
/**
* Called on the game thread right before a window backbuffer is about to be resized
* @param Pointer to the API specific backbuffer type
*/
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPreResizeWindowBackbuffer, void*);
FOnPreResizeWindowBackbuffer& OnPreResizeWindowBackBuffer() { return PreResizeBackBufferDelegate; }
/**
* Called on the game thread right after a window backbuffer has been resized
* @param Pointer to the API specific backbuffer type
*/
DECLARE_MULTICAST_DELEGATE_OneParam(FOnPostResizeWindowBackbuffer, void*);
FOnPostResizeWindowBackbuffer& OnPostResizeWindowBackBuffer() { return PostResizeBackBufferDelegate; }
/**
* Sets which color vision filter to use
*/
virtual void SetColorVisionDeficiencyType( uint32 Type ) {}
/**
* Creates a dynamic image resource and returns its size
*
* @param InTextureName The name of the texture resource
* @return The size of the loaded texture
*/
virtual FIntPoint GenerateDynamicImageResource(const FName InTextureName) {check(0); return FIntPoint( 0, 0 );}
/**
* Creates a dynamic image resource
*
* @param ResourceName The name of the texture resource
* @param Width The width of the resource
* @param Height The height of the image
* @param Bytes The payload for the resource
* @return true if the resource was successfully generated, otherwise false
*/
virtual bool GenerateDynamicImageResource( FName ResourceName, uint32 Width, uint32 Height, const TArray< uint8 >& Bytes ) { return false; }
virtual bool GenerateDynamicImageResource(FName ResourceName, FSlateTextureDataRef TextureData) { return false; }
/**
* Creates a handle to a Slate resource
* A handle is used as fast path for looking up a rendering resource for a given brush when adding Slate draw elements
* This can be cached and stored safely in code. It will become invalid when a resource is destroyed
* It is expensive to create a resource so do not do it in time sensitive areas
*
* @param Brush The brush to get a rendering resource handle
* @return The created resource handle.
*/
virtual FSlateResourceHandle GetResourceHandle( const FSlateBrush& Brush ) = 0;
/**
* Queues a dynamic brush for removal when it is safe. The brush is not immediately released but you should consider the brush destroyed and no longer usable
*
* @param BrushToRemove The brush to queue for removal which is no longer valid to use
*/
virtual void RemoveDynamicBrushResource( TSharedPtr<FSlateDynamicImageBrush> BrushToRemove ) = 0;
/**
* Releases a specific resource.
* It is unlikely that you want to call this directly. Use RemoveDynamicBrushResource instead
*/
virtual void ReleaseDynamicResource( const FSlateBrush& Brush ) = 0;
/** Called when a window is destroyed to give the renderer a chance to free resources */
virtual void OnWindowDestroyed( const TSharedRef<SWindow>& InWindow ) = 0;
/**
* Returns the viewport rendering resource (backbuffer) for the provided window
*
* @param Window The window to get the viewport from
*/
virtual void* GetViewportResource( const SWindow& Window ) { return nullptr; }
/**
* Get access to the font services used by this renderer
*/
TSharedRef<FSlateFontServices> GetFontServices() const
{
return SlateFontServices.ToSharedRef();
}
/**
* Get access to the font measure service (game thread only!)
*/
TSharedRef<class FSlateFontMeasure> GetFontMeasureService() const
{
return SlateFontServices->GetFontMeasureService();
}
/**
* Get the font cache to use for the current thread
*/
TSharedRef<class FSlateFontCache> GetFontCache() const
{
return SlateFontServices->GetFontCache();
}
/**
* Flushes all cached data from the font cache for the current thread
*/
void FlushFontCache()
{
SlateFontServices->FlushFontCache();
}
/**
* Gives the renderer a chance to wait for any render commands to be completed before returning/
*/
virtual void FlushCommands() const {};
/**
* Gives the renderer a chance to synchronize with another thread in the event that the renderer runs
* in a multi-threaded environment. This function does not return until the sync is complete
*/
virtual void Sync() const {};
/**
* Reloads all texture resources from disk
*/
virtual void ReloadTextureResources() {}
/**
* Loads all the resources used by the specified SlateStyle
*/
virtual void LoadStyleResources( const ISlateStyle& Style ) {}
/**
* Returns whether or not a viewport should be in fullscreen
*
* @Window The window to check for fullscreen
* @return true if the window's viewport should be fullscreen
*/
bool IsViewportFullscreen( const SWindow& Window ) const;
/** Returns whether shaders that Slate depends on have been compiled. */
virtual bool AreShadersInitialized() const { return true; }
/**
* Removes references to FViewportRHI's.
* This has to be done explicitly instead of using the FRenderResource mechanism because FViewportRHI's are managed by the game thread.
* This is needed before destroying the RHI device.
*/
virtual void InvalidateAllViewports() {}
/**
* A renderer may need to keep a cache of accessed garbage collectible objects alive for the duration of their
* usage. During some operations like ending a game. It becomes important to immediately release game related
* resources. This should flush any buffer holding onto those referenced objects.
*/
virtual void ReleaseAccessedResources(bool bImmediatelyFlush) {}
/**
* Prepares the renderer to take a screenshot of the UI. The Rect is portion of the rendered output
* that will be stored into the TArray of FColors.
*/
virtual void PrepareToTakeScreenshot(const FIntRect& Rect, TArray<FColor>* OutColorData) {}
/**
* Pushes the rendering of the specified window to the specified render target
*/
virtual void SetWindowRenderTarget(const SWindow& Window, class IViewportRenderTargetProvider* Provider) {}
/**
* Create an updatable texture that can receive new data dynamically
*
* @param Width Initial width of the texture
* @param Height Initial height of the texture
*
* @return Newly created updatable texture
*/
virtual FSlateUpdatableTexture* CreateUpdatableTexture(uint32 Width, uint32 Height) = 0;
/**
* Return an updatable texture to the renderer for release
*
* @param Texture The texture we are releasing (should not use this pointer after calling)
*/
virtual void ReleaseUpdatableTexture(FSlateUpdatableTexture* Texture) = 0;
/**
* Returns the way to access the texture atlas information for this renderer
*/
virtual ISlateAtlasProvider* GetTextureAtlasProvider();
/**
* Returns the way to access the font atlas information for this renderer
*/
virtual ISlateAtlasProvider* GetFontAtlasProvider();
/**
* Converts and caches the elements list data as the final rendered vertex and index buffer data,
* returning a handle to it to allow issuing future draw commands using it.
*/
virtual TSharedRef<FSlateRenderDataHandle, ESPMode::ThreadSafe> CacheElementRenderData(const ILayoutCache* Cacher, FSlateWindowElementList& ElementList);
/**
* Releases the caching resources used on the render thread for the provided ILayoutCache. This is
* should be the kind of operation you perform when the ILayoutCache is being destroyed and will no longer
* be needing to draw anything again.
*/
virtual void ReleaseCachingResourcesFor(const ILayoutCache* Cacher);
/**
* Copies all slate windows out to a buffer at half resolution with debug information
* like the mouse cursor and any keypresses.
*/
virtual void CopyWindowsToVirtualScreenBuffer(const TArray<FString>& KeypressBuffer) {}
/** Allows and disallows access to the crash tracker buffer data on the CPU */
virtual void MapVirtualScreenBuffer(FMappedTextureBuffer* OutImageData) {}
virtual void UnmapVirtualScreenBuffer() {}
/**
* Necessary to grab before flushing the resource pool, as it may be being
* accessed by multiple threads when loading.
*/
FCriticalSection* GetResourceCriticalSection() { return &ResourceCriticalSection; }
/** Register the active scene pointer with the renderer. This will return the scene internal index that will be used for all subsequent elements drawn. */
virtual int32 RegisterCurrentScene(FSceneInterface* Scene) = 0;
/** Get the currently registered scene index (set by RegisterCurrentScene)*/
virtual int32 GetCurrentSceneIndex() const = 0;
/** Reset the internal Scene tracking.*/
virtual void ClearScenes() = 0;
virtual bool HasLostDevice() const { return false; }
private:
// Non-copyable
FSlateRenderer(const FSlateRenderer&);
FSlateRenderer& operator=(const FSlateRenderer&);
protected:
/** The font services used by this renderer when drawing text */
TSharedPtr<FSlateFontServices> SlateFontServices;
/** Callback that fires after Slate has rendered each window, each frame */
FOnSlateWindowRendered SlateWindowRendered;
FOnSlateWindowDestroyed OnSlateWindowDestroyedDelegate;
FOnPreResizeWindowBackbuffer PreResizeBackBufferDelegate;
FOnPostResizeWindowBackbuffer PostResizeBackBufferDelegate;
/**
* Necessary to grab before flushing the resource pool, as it may be being
* accessed by multiple threads when loading.
*/
FCriticalSection ResourceCriticalSection;
friend class FSlateRenderDataHandle;
};
/**
* Is this thread valid for sending out rendering commands?
* If the slate loading thread exists, then yes, it is always safe
* Otherwise, we have to be on the game thread
*/
bool SLATECORE_API IsThreadSafeForSlateRendering();
/**
* If it's the game thread, and there's no loading thread, then it owns slate rendering.
* However if there's a loading thread, it is the exlusive owner of slate rendering.
*/
bool SLATECORE_API DoesThreadOwnSlateRendering();
| [
"tungnt.rec@gmail.com"
] | tungnt.rec@gmail.com |
c490ca0938631cc0a743e593fdb0b014fb19f99f | 39e4886abb46b738986fe047ebdb7141094688de | /cpp/oj/146_lru_cache/main.cc | 36c1007b92bc32c51ef36c341fbb05d87ba6fbf1 | [] | no_license | yuzhuo/playground | 2a1c8c6b3a8ec74ea031027bf2cee30ec8a88b4a | ffc74753f209c8788ab72b51d0efdf11c5212329 | refs/heads/master | 2021-01-01T06:52:15.058083 | 2020-04-16T14:21:20 | 2020-04-16T14:21:20 | 97,536,132 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,241 | cc |
#include <list>
#include <unordered_map>
using namespace std;
class LRUCache {
struct _Item {
_Item(int v, list<int>::iterator it) {
val = v;
it_list = it;
}
int val;
list<int>::iterator it_list;
};
public:
LRUCache(int capacity) {
capacity_ = capacity;
}
int get(int key) {
if (keys_.find(key) == keys_.end())
return -1;
_Item& item = keys_.find(key)->second;
list_.erase(item.it_list);
item.it_list = list_.insert(list_.begin(), key);
return item.val;
}
void put(int key, int value) {
if (capacity_ <= 0)
return;
auto it = keys_.find(key);
if (it != keys_.end()) {
get(key);
it->second.val = value;
return;
}
if (list_.size() >= capacity_) {
int old_key = list_.back();
keys_.erase(old_key);
list_.pop_back();
}
list_.push_front(key);
keys_.insert(make_pair(key, _Item(value, list_.begin())));
}
private:
int capacity_;
list<int> list_;
unordered_map<int, _Item> keys_;
};
int main()
{
return 0;
}
| [
"goodcomrade@hotmail.com"
] | goodcomrade@hotmail.com |
7f1e37dbf6018eef045fc115a5e571d5a28486b8 | bb2b5b7dc50329453f73f387ae8c9497ae886398 | /src/Skybox.cpp | fe6ac7912c6c97bd4ec98e3e4cb0631baf5fb4c9 | [] | no_license | graypilgrim/transporter | a1e5f263b2e1f27b1259998508bdd7f76d30c9b1 | 865668b8a1927ff83a40cddec6ecced192889f79 | refs/heads/master | 2021-04-30T23:01:10.988193 | 2017-01-21T21:01:17 | 2017-01-21T21:01:17 | 76,290,197 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,165 | cpp | #include "../headers/Skybox.hpp"
Skybox::Skybox()
:Object(36, 3)
{
GLfloat skyboxVertices[] = {
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, 1.0f
};
vertices = new GLfloat[verticesNo * verticeCoordNo];
memcpy(vertices, skyboxVertices, GetArraySize());
faces.push_back("skybox/right.jpg");
faces.push_back("skybox/left.jpg");
faces.push_back("skybox/top.jpg");
faces.push_back("skybox/bottom.jpg");
faces.push_back("skybox/back.jpg");
faces.push_back("skybox/front.jpg");
BindVertices();
LoadCubemap();
}
Skybox::~Skybox()
{
delete[] vertices;
}
void Skybox::Draw()
{
glDepthFunc(GL_LEQUAL);
shader->Use();
glm::mat4 view = glm::mat4(glm::mat3(camera->GetViewMatrix()));
glm::mat4 projection = glm::perspective(camera->Zoom, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f);
glUniformMatrix4fv(glGetUniformLocation(shader->Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(shader->Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
glBindVertexArray(GetVAO());
glBindTexture(GL_TEXTURE_CUBE_MAP, GetTexture());
glDrawArrays(GL_TRIANGLES, 0, GetVerticesNo());
glBindVertexArray(0);
glDepthFunc(GL_LESS); // Set depth function back to default
}
void Skybox::LoadCubemap()
{
glActiveTexture(GL_TEXTURE0);
glGenTextures(1, &texture);
int width, height;
unsigned char* image;
glBindTexture(GL_TEXTURE_CUBE_MAP, texture);
for (GLuint i = 0; i < faces.size(); i++)
{
image = SOIL_load_image(faces[i].c_str(), &width, &height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
}
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
}
void Skybox::BindVertices() {
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, GetArraySize(), GetVertices(), GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid *)0);
glBindVertexArray(0);
}
| [
"lukwlazly@gmail.com"
] | lukwlazly@gmail.com |
1999a505d496aaf5e13e11c4afab5fce0b85ea34 | 745d39cad6b9e11506d424f008370b5dcb454c45 | /BOJ/15000/15655.cpp | 015ed3ab28ffdfd871d75c75668f2c2aba307d19 | [] | no_license | nsj6646/PS | 0191a36afa0c04451d704d8120dc25f336988a17 | d53c111a053b159a0fb584ff5aafc18556c54a1c | refs/heads/master | 2020-04-28T09:18:43.333045 | 2019-06-19T07:19:03 | 2019-06-19T07:19:03 | 175,162,727 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 590 | cpp | #include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> ans;
int a[10001];
int visited[10001];
int n, m;
void solve(int l) {
if (l == m) {
for (int x : ans) {
printf("%d ", x);
}
printf("\n");
return;
}
for (int i = 0; i < n; i++) {
int &x = a[i];
if (visited[x] == 0&&(ans.empty()||x>ans.back())) {
visited[x] = 1;
ans.push_back(x);
solve(l + 1);
visited[x] = 0;
ans.pop_back();
}
}
}
int main()
{
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
solve(0);
return 0;
} | [
"nsj6646@gmail.com"
] | nsj6646@gmail.com |
b85523cef086104c92e3a29b4c891059487b3a4e | d0c44dd3da2ef8c0ff835982a437946cbf4d2940 | /cmake-build-debug/programs_tiling/function14041/function14041_schedule_8/function14041_schedule_8_wrapper.cpp | 60886e0b4c28ea4d889622b620f3758ae4bd5331 | [] | no_license | IsraMekki/tiramisu_code_generator | 8b3f1d63cff62ba9f5242c019058d5a3119184a3 | 5a259d8e244af452e5301126683fa4320c2047a3 | refs/heads/master | 2020-04-29T17:27:57.987172 | 2019-04-23T16:50:32 | 2019-04-23T16:50:32 | 176,297,755 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 854 | cpp | #include "Halide.h"
#include "function14041_schedule_8_wrapper.h"
#include "tiramisu/utils.h"
#include <cstdlib>
#include <iostream>
#include <time.h>
#include <fstream>
#include <chrono>
#define MAX_RAND 200
int main(int, char **){Halide::Buffer<int32_t> buf0(256, 512, 512);
init_buffer(buf0, (int32_t)0);
auto t1 = std::chrono::high_resolution_clock::now();
function14041_schedule_8(buf0.raw_buffer());
auto t2 = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> diff = t2 - t1;
std::ofstream exec_times_file;
exec_times_file.open("../data/programs/function14041/function14041_schedule_8/exec_times.txt", std::ios_base::app);
if (exec_times_file.is_open()){
exec_times_file << diff.count() * 1000000 << "us" <<std::endl;
exec_times_file.close();
}
return 0;
} | [
"ei_mekki@esi.dz"
] | ei_mekki@esi.dz |
f6ceed85db93c7a28958b8f839e1a41da3ccbac1 | ce73c8dbc12dc519e81ba456025ab58a4ee2d3d4 | /src/qt/optionsmodel.h | 44b19c92261cda3a3102a7f9e5dbff74d97e0697 | [
"MIT"
] | permissive | mrfultons/tittiecoin-2-0 | f2b0f3aebbf0a28abc5840480367c346e9eb7689 | 657e02eead2510f3f98ae40b03a4cbe5ac5e2710 | refs/heads/master | 2020-05-09T13:41:13.330619 | 2019-04-13T11:52:44 | 2019-04-13T11:52:44 | 181,163,599 | 0 | 0 | MIT | 2019-04-13T11:52:51 | 2019-04-13T11:52:51 | null | UTF-8 | C++ | false | false | 3,249 | h | // Copyright (c) 2011-2013 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_QT_OPTIONSMODEL_H
#define BITCOIN_QT_OPTIONSMODEL_H
#include "amount.h"
#include <QAbstractListModel>
QT_BEGIN_NAMESPACE
class QNetworkProxy;
QT_END_NAMESPACE
/** Interface from Qt to configuration data structure for Bitcoin client.
To Qt, the options are presented as a list with the different options
laid out vertically.
This can be changed to a tree once the settings become sufficiently
complex.
*/
class OptionsModel : public QAbstractListModel
{
Q_OBJECT
public:
explicit OptionsModel(QObject* parent = 0);
enum OptionID {
StartAtStartup, // bool
MinimizeToTray, // bool
MapPortUPnP, // bool
MinimizeOnClose, // bool
ProxyUse, // bool
ProxyIP, // QString
ProxyPort, // int
DisplayUnit, // BitcoinUnits::Unit
ThirdPartyTxUrls, // QString
Digits, // QString
Theme, // QString
Language, // QString
CoinControlFeatures, // bool
ThreadsScriptVerif, // int
DatabaseCache, // int
SpendZeroConfChange, // bool
ObfuscationRounds, // int
AnonymizeTittieCoinAmount, //int
ShowMasternodesTab, // bool
Listen, // bool
OptionIDRowCount,
};
void Init();
void Reset();
int rowCount(const QModelIndex& parent = QModelIndex()) const;
QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
/** Updates current unit in memory, settings and emits displayUnitChanged(newUnit) signal */
void setDisplayUnit(const QVariant& value);
/* Explicit getters */
bool getMinimizeToTray() { return fMinimizeToTray; }
bool getMinimizeOnClose() { return fMinimizeOnClose; }
int getDisplayUnit() { return nDisplayUnit; }
QString getThirdPartyTxUrls() { return strThirdPartyTxUrls; }
bool getProxySettings(QNetworkProxy& proxy) const;
bool getCoinControlFeatures() { return fCoinControlFeatures; }
const QString& getOverriddenByCommandLine() { return strOverriddenByCommandLine; }
/* Restart flag helper */
void setRestartRequired(bool fRequired);
bool isRestartRequired();
bool resetSettings;
private:
/* Qt-only settings */
bool fMinimizeToTray;
bool fMinimizeOnClose;
QString language;
int nDisplayUnit;
QString strThirdPartyTxUrls;
bool fCoinControlFeatures;
/* settings that were overriden by command-line */
QString strOverriddenByCommandLine;
/// Add option to list of GUI options overridden through command line/config file
void addOverriddenOption(const std::string& option);
signals:
void displayUnitChanged(int unit);
void obfuscationRoundsChanged(int);
void anonymizeTittieCoinAmountChanged(int);
void coinControlFeaturesChanged(bool);
};
#endif // BITCOIN_QT_OPTIONSMODEL_H
| [
"info@tittiecoin.com"
] | info@tittiecoin.com |
9855ed900210dd99511922a22b0c99cbb44579dd | 29bda8822baf9a96d22415ff2f125d429badfbbe | /Arduino/UberdustSensors/MemorySensor.h | cfaf7a52960e614d4bdc4a3459abdf845b9106b2 | [] | no_license | yandevelop19/sensorApps | d2b1e1599f62213db49a8a97be03823b3cd2eb2e | f6210ff591835e28e7deed7f2042389d18e4a71e | refs/heads/master | 2021-01-22T14:03:18.259585 | 2014-03-30T08:20:21 | 2014-03-30T08:20:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 482 | h | #include <CoapSensor.h>
class memorySensor :
public CoapSensor
{
public:
memorySensor(char * name):
CoapSensor(name)
{
this->set_notify_time(300);
}
void get_value( uint8_t* output_data, size_t* output_data_len)
{
*output_data_len = sprintf( (char*)output_data, "%d", this->freeRam());
}
int freeRam () {
extern int __heap_start, *__brkval;
int v;
return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}
};
| [
"amaxilat@cti.gr"
] | amaxilat@cti.gr |
158b51b7b7d6b1788e0cdddabb7870d16c0882dd | a5bf5d40e71b7899e8745242762d2ac953835576 | /Generate_Parentheses.cc | 4a7681182fdf78c2a38934907bb204bc32c82b05 | [] | no_license | yefengdanqing/my_leetcode_algorithm | 51ffd76bd14e288e8f1a19c6e0e040fc7dec0b49 | d3bb9bdc9cf6c5ab755d534d02e01242e3187297 | refs/heads/master | 2021-09-12T11:09:04.826231 | 2018-04-16T10:00:16 | 2018-04-16T10:00:16 | 83,684,913 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 907 | cc | class Solution {
public:
void helper(vector<string>& result,int left,int right,string s)
{
if(left>right)
//思考这个条件的限制于整个
return;
if(left==0&&right==0)
{
result.push_back(s);
return;
}
if(left>0)
helper(result,left-1,right,s+'(');
if(right>0)
helper(result,left,right-1,s+')');
/* if(left<right)
return;
if(left==n&&right==n)
{
result.push_back(s);
}
if(left<n)
helper(result,left+1,right,s+'(',n);
if(right>n)
helper(result,left,right+1,s+'(',n);*/
}
vector<string> generateParenthesis(int n) {
vector<string> result;
if(n==0)
return result;
helper(result,0,0,"");
return result;
}
};
| [
"noreply@github.com"
] | yefengdanqing.noreply@github.com |
35d3bba9707de86f3b389aa3fc2c67ccfa80f0df | 60e6109421502f144477d83e57071af8a5477153 | /src/xtopcom/xpbase/src/redis_client.cc | 4631134b506e0aec33f3bf1ef1a90915bad14a1d | [
"MIT"
] | permissive | helenhuang-eng/TOP-chain | 3159ea477b431051c308b89bbf6d3c4f6d7599bf | 6741db2b4cd02a59db9f750791f9de191a644208 | refs/heads/dev/fast_sync_develop | 2023-05-09T20:23:44.138959 | 2021-04-29T06:24:32 | 2021-04-29T06:24:32 | 359,667,673 | 0 | 0 | null | 2021-04-26T03:27:10 | 2021-04-20T03:07:18 | C++ | UTF-8 | C++ | false | false | 1,258 | cc | #include "xpbase/base/redis_client.h"
#include <cassert>
namespace top {
namespace base {
RedisClient* RedisClient::Instance() {
static RedisClient ins;
return &ins;
}
bool RedisClient::Start(const std::string& ip, uint16_t port) {
std::unique_lock<std::mutex> lock(start_mutex_);
assert(!redis_cli_);
if (redis_cli_) {
return false;
}
redis_cli_ = std::make_shared<cpp_redis::client>();
using namespace std::placeholders;
redis_cli_->connect(ip, port, std::bind(&RedisClient::ConnectCallback, this, _1, _2, _3));
redis_cli_->auth("top@com");
std::cout << "redis connect: " << ip << ":" << port << std::endl;
sem.Pend();
if (!redis_cli_->is_connected()) {
redis_cli_.reset();
return false;
}
return true;
}
void RedisClient::Stop() {
std::unique_lock<std::mutex> lock(start_mutex_);
redis_cli_.reset();
}
void RedisClient::ConnectCallback(
const std::string& host,
std::size_t port,
cpp_redis::client::connect_state status) {
std::cout << "redis connect callback: " << host << ":" << port << std::endl;
sem.Post();
}
RedisClient::RedisClient() {}
RedisClient::~RedisClient() {}
} // namespace base
} // namespace top
| [
"zql0114@gmail.com"
] | zql0114@gmail.com |
24f4ffbb7cdd67f166c8c9d580ad27c2b10ffd66 | a6ec81a2855387fdfbbeb29ecd58f0710ef69205 | /src/Miner/Miner.h | 0f111c3603501bc983da7ad6ef3589750e59cb72 | [] | no_license | LithiumBit/LithiumBitWallet | d7d665c0258a73d6ae5c8229019448bf9202b0a0 | 4be7dd1911e52b4be101c325bf5e308b4a89410a | refs/heads/master | 2020-03-14T03:56:27.185127 | 2019-06-05T23:28:00 | 2019-06-05T23:28:00 | 131,430,563 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,154 | h | // Copyright (c) 2015-2017, The Bytecoin developers
//
// This file is part of Bytecoin.
//
// LithiumBit is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// LithiumBit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with LithiumBit. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <QMap>
#include <QMetaObject>
#include <QObject>
#include <QReadWriteLock>
#include <atomic>
#include "IPoolMiner.h"
#include "IMinerWorker.h"
#include "IPoolClient.h"
namespace WalletGui {
class StratumClient;
class Miner : public QObject, public IPoolMiner, public IPoolClientObserver {
Q_OBJECT
Q_DISABLE_COPY(Miner)
public:
Miner(const QString& _host, quint16 _port, quint32 _difficulty, const QString& _login, const QString& _password, QObject* _parent);
~Miner();
// IPoolMiner
virtual void start(quint32 _coreCount) override;
virtual void stop() override;
virtual QString getPoolHost() const override;
virtual quint16 getPoolPort() const override;
virtual State getCurrentState() const override;
virtual quint32 getHashRate() const override;
virtual quint32 getAlternateHashRate() const override;
virtual quint32 getDifficulty() const override;
virtual quint32 getGoodShareCount() const override;
virtual quint32 getGoodAlternateShareCount() const override;
virtual quint32 getBadShareCount() const override;
virtual quint32 getConnectionErrorCount() const override;
virtual QDateTime getLastConnectionErrorTime() const override;
virtual void setAlternateAccount(const QString& _login, quint32 _probability) override;
virtual void unsetAlternateAccount() override;
virtual void addObserver(IPoolMinerObserver* _observer) override;
virtual void removeObserver(IPoolMinerObserver* _observer) override;
// IPoolClientObserver
Q_SLOT virtual void started() override;
Q_SLOT virtual void stopped() override;
Q_SLOT virtual void socketError() override;
Q_SLOT virtual void difficultyChanged(quint32 _difficulty) override;
Q_SLOT virtual void goodShareCountChanged(quint32 _goodShareCount) override;
Q_SLOT virtual void badShareCountChanged(quint32 _badShareCount) override;
Q_SLOT virtual void connectionErrorCountChanged(quint32 _connectionErrorCount) override;
Q_SLOT virtual void lastConnectionErrorTimeChanged(const QDateTime& _lastConnectionErrorTime) override;
protected:
void timerEvent(QTimerEvent* _event) override;
private:
State m_minerState;
Job m_mainJob;
Job m_alternateJob;
QReadWriteLock m_mainJobLock;
QReadWriteLock m_alternateJobLock;
StratumClient* m_mainStratumClient;
StratumClient* m_alternateStratumClient;
std::atomic<quint32> m_mainNonce;
std::atomic<quint32> m_alternateNonce;
std::atomic<quint32> m_hashCounter;
std::atomic<quint32> m_alternameHashCounter;
std::atomic<quint32> m_alternateProbability;
quint32 m_hashCountPerSecond;
quint32 m_alternateHashCountPerSecond;
QList<QPair<QThread*, IMinerWorker*> > m_workerThreadList;
int m_hashRateTimerId;
QMap<IPoolMinerObserver*, QList<QMetaObject::Connection>> m_observerConnections;
void setState(State _newState);
Q_SIGNALS:
void stateChangedSignal(int _newState);
void hashRateChangedSignal(quint32 _hashRate);
void alternateHashRateChangedSignal(quint32 _hashRate);
void difficultyChangedSignal(quint32 _difficulty);
void goodShareCountChangedSignal(quint32 _goodShareCount);
void goodAlternateShareCountChangedSignal(quint32 _goodShareCount);
void badShareCountChangedSignal(quint32 _badShareCount);
void connectionErrorCountChangedSignal(quint32 _connectionErrorCount);
void lastConnectionErrorTimeChangedSignal(const QDateTime& _lastConnectionErrorTime);
};
}
| [
"hansolo@puroinstinto.net"
] | hansolo@puroinstinto.net |
1d14f59f10604ca7f3809f52c6ab1d089563d892 | f2ab63860218ca7927b6ee3a8d3bcb97099072d1 | /query_funcs.cpp | bbdc76f75846db3cfe5bb7a825a891e737392733 | [] | no_license | YuanyuanBlue/Database-Programming-Project | ef7646487746ba297d2b253016a809711eb1511b | eb90a51c70fb0e7be76675c5b632da957028cfc6 | refs/heads/master | 2020-04-17T05:14:53.224279 | 2019-01-17T17:51:31 | 2019-01-17T17:51:31 | 166,270,326 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,933 | cpp | #include "query_funcs.h"
void add_player(connection *C, int team_id, int jersey_num, string first_name, string last_name,
int mpg, int ppg, int rpg, int apg, double spg, double bpg)
{
string seq;
seq = "SELECT setval('player_player_id_seq', max(PLAYER_ID)) FROM PLAYER;";
stringstream nteam_id;
stringstream njersey_num;
stringstream nmpg;
stringstream nppg;
stringstream nrpg;
stringstream napg;
stringstream nspg;
stringstream nbpg;
nteam_id << team_id;
nmpg << mpg;
nppg << ppg;
nrpg << rpg;
napg << apg;
nspg << spg;
nbpg << bpg;
string sql;
sql = "INSERT INTO PLAYER (TEAM_ID, UNIFORM_NUM, FIRST_NAME, LAST_NAME, MPG, PPG, RPG, APG, SPG, BPG) VALUES " \
"(" + string(nteam_id.str()) + "," + njersey_num.str() + "," + "'" + first_name + "'," + "'" + last_name + "'," + nmpg.str() + "," + nppg.str()+ "," + nrpg.str() + "," + napg.str() + "," + nspg.str() + "," + nbpg.str() + ");";
work W(*C);
W.exec( seq );
W.exec( sql );
W.commit();
}
void add_team(connection *C, string name, int state_id, int color_id, int wins, int losses)
{
string seq;
seq = "SELECT setval('team_team_id_seq', max(TEAM_ID)) FROM TEAM;";
stringstream nstate_id;
stringstream ncolor_id;
stringstream nwins;
stringstream nlosses;
nstate_id << state_id;
ncolor_id << color_id;
nwins << wins;
nlosses << losses;
string sql;
sql = "INSERT INTO TEAM (NAME, STATE_ID, COLOR_ID, WINS, LOSSES) VALUES " \
"(" + string(" '") + name + "', " + nstate_id.str() + "," + ncolor_id.str() + "," + nwins.str() + "," + nlosses.str() + ");";
work W(*C);
W.exec( seq );
W.exec( sql );
W.commit();
}
void add_state(connection *C, string name)
{
string seq;
seq = "SELECT setval('state_state_id_seq', max(STATE_ID)) FROM STATE;";
string sql;
sql = "INSERT INTO STATE (NAME) VALUES " \
"(" + string("'") + name + "'" +");";
work W(*C);
W.exec( seq );
W.exec( sql );
W.commit();
/*SELECT setval('state_state_id_seq', max(STATE_ID)) FROM STATE;
INSERT INTO STATE (NAME) VALUES ('SH');*/
}
void add_color(connection *C, string name)
{
string seq;
seq = "SELECT setval('color_color_id_seq', max(COLOR_ID)) FROM COLOR;";
string sql;
sql = "INSERT INTO COLOR (NAME) VALUES " \
"(" + string("'") + name + "'" +");";
work W(*C);
W.exec( seq );
W.exec( sql );
W.commit();
}
void query1Print(result R) {
cout << "PLAYER_ID TEAM_ID UNIFORM_NUM FIRST_NAME LAST_NAME MPG PPG RPG APG SPG BPG" << endl;
for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
cout << c[0].as<int>() << " ";
cout << c[1].as<int>() << " ";
cout << c[2].as<int>() << " ";
cout << c[3].as<string>() << " ";
cout << c[4].as<string>() << " ";
cout << c[5].as<int>() << " ";
cout << c[6].as<int>() << " ";
cout << c[7].as<int>() << " ";
cout << c[8].as<int>() << " ";
cout << c[9].as<double>() << " ";
cout << c[10].as<double>()<<endl;
}
}
/*void query1(connection *C,
int use_mpg, int min_mpg, int max_mpg,
int use_ppg, int min_ppg, int max_ppg,
int use_rpg, int min_rpg, int max_rpg,
int use_apg, int min_apg, int max_apg,
int use_spg, double min_spg, double max_spg,
int use_bpg, double min_bpg, double max_bpg
)
{
nontransaction N(*C);
string sql;
stringstream n1;
stringstream n2;
if(use_mpg) {
n1 << min_mpg;
n2 << max_mpg;
sql = "SELECT * FROM PLAYER WHERE MPG >=" + std::string(n1.str()) + "AND MPG <=" + std::string(n2.str()) + ";";
result R( N.exec( sql ));
query1Print(R);
}
if(use_ppg) {
n1 << min_ppg;
n2 << max_ppg;
sql = "SELECT * FROM PLAYER WHERE PPG >=" + std::string(n1.str()) + "AND PPG <=" + std::string(n2.str()) + ";";
result R( N.exec( sql ));
query1Print(R);
}
if(use_rpg) {
n1 << min_rpg;
n2 << max_rpg;
sql = "SELECT * FROM PLAYER WHERE RPG >=" + std::string(n1.str()) + "AND RPG <=" + std::string(n2.str()) + ";";
result R( N.exec( sql ));
query1Print(R);
}
if(use_apg) {
n1 << min_apg;
n2 << max_apg;
sql = "SELECT * FROM PLAYER WHERE APG >=" + std::string(n1.str()) + "AND APG <=" + std::string(n2.str()) + ";";
result R( N.exec( sql ));
query1Print(R);
}
if(use_spg) {
n1 << min_spg;
n2 << max_spg;
sql = "SELECT * FROM PLAYER WHERE SPG >=" + std::string(n1.str()) + "AND SPG <=" + std::string(n2.str()) + ";";
result R( N.exec( sql ));
query1Print(R);
}
if(use_bpg) {
n1 << min_bpg;
n2 << max_bpg;
sql = "SELECT * FROM PLAYER WHERE BPG >=" + std::string(n1.str()) + "AND BPG <=" + std::string(n2.str()) + ";";
result R( N.exec( sql ));
query1Print(R);
}
}*/
void query1(connection *C,
int use_mpg, int min_mpg, int max_mpg,
int use_ppg, int min_ppg, int max_ppg,
int use_rpg, int min_rpg, int max_rpg,
int use_apg, int min_apg, int max_apg,
int use_spg, double min_spg, double max_spg,
int use_bpg, double min_bpg, double max_bpg
)
{
nontransaction N(*C);
int count = 0;
string sql;
string sql1;
string sql2;
string sql3;
string sql4;
string sql5;
string sql6;
stringstream n1;
stringstream n2;
if(use_mpg) {
count++;
n1 << min_mpg;
n2 << max_mpg;
sql1 = " MPG >= " + std::string(n1.str()) + " AND MPG <=" + std::string(n2.str());
if(count == 1) {
sql = "SELECT * FROM PLAYER WHERE " + sql1;
} else {
sql = sql + " AND " + sql1;
}
n1.str("");
n2.str("");
}
if(use_ppg) {
count++;
n1 << min_ppg;
n2 << max_ppg;
sql2 = " PPG >= " + std::string(n1.str()) + " AND PPG <=" + std::string(n2.str());
if(count == 1) {
sql = "SELECT * FROM PLAYER WHERE " + sql2;
} else {
sql = sql + " AND " + sql2;
}
n1.str("");
n2.str("");
}
if(use_rpg) {
count++;
n1 << min_rpg;
n2 << max_rpg;
sql3 = " RPG >= " + std::string(n1.str()) + " AND RPG <=" + std::string(n2.str());
if(count == 1) {
sql = "SELECT * FROM PLAYER WHERE " + sql3;
} else {
sql = sql + " AND " + sql3;
}
n1.str("");
n2.str("");
}
if(use_apg) {
count++;
n1 << min_apg;
n2 << max_apg;
sql4 = " APG >= " + std::string(n1.str()) + " AND APG <=" + std::string(n2.str());
if(count == 1) {
sql = "SELECT * FROM PLAYER WHERE " + sql4;
} else {
sql = sql + " AND " + sql4;
}
n1.str("");
n2.str("");
}
if(use_spg) {
count++;
n1 << min_spg;
n2 << max_spg;
sql5 = " SPG >= " + std::string(n1.str()) + " AND SPG <=" + std::string(n2.str());
if(count == 1) {
sql = "SELECT * FROM PLAYER WHERE " + sql5;
} else {
sql = sql + " AND " + sql5;
}
n1.str("");
n2.str("");
}
if(use_bpg) {
count++;
n1 << min_bpg;
n2 << max_bpg;
sql6 = " BPG >= " + std::string(n1.str()) + " AND BPG <=" + std::string(n2.str());
if(count == 1) {
sql = "SELECT * FROM PLAYER WHERE " + sql6;
} else {
sql = sql + " AND " + sql6;
}
n1.str("");
n2.str("");
}
sql = sql + ";";
//cout<<sql;
result R( N.exec( sql ));
query1Print(R);
}
void query2Print(result R) {
cout << "NAME" << endl;
for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
cout << c[0].as<string>()<<endl;
}
}
void query2(connection *C, string team_color)
{
nontransaction N(*C);
string sql;
sql = "SELECT TEAM.NAME " \
"FROM TEAM "\
"INNER JOIN COLOR " \
"ON TEAM.COLOR_ID = COLOR.COLOR_ID " \
"WHERE COLOR.NAME = " + string("'") + team_color + "';";
result R( N.exec( sql ));
query2Print(R);
}
void query3Print(result R){
cout << "FIRST_NAME ";
cout << "LAST_NAME" << endl;
for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
cout << c[0].as<string>() << " ";
cout << c[1].as<string>()<<endl;
}
}
void query3(connection *C, string team_name)
{
nontransaction N(*C);
string sql;
sql = "SELECT PLAYER.FIRST_NAME, PLAYER.LAST_NAME " \
"FROM PLAYER " \
"INNER JOIN TEAM " \
"ON PLAYER.TEAM_ID = TEAM.TEAM_ID " \
"WHERE TEAM.NAME = " + string("'") + team_name + "'" + " ORDER BY PLAYER.PPG DESC;";
result R( N.exec( sql ));
query3Print(R);
}
void query4Print(result R) {
cout << "FIRST_NAME ";
cout << "LAST_NAME ";
cout << "UNIFORM_NUM" << endl;
for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
cout << c[0].as<string>() << " ";
cout << c[1].as<string>() << " ";
cout << c[2].as<int>() << endl;
}
}
void query4(connection *C, string team_state, string team_color)
{
nontransaction N(*C);
string sql;
sql = "SELECT PLAYER.FIRST_NAME, PLAYER.LAST_NAME, PLAYER.UNIFORM_NUM " \
"FROM PLAYER " \
"INNER JOIN TEAM " \
"ON PLAYER.TEAM_ID = TEAM.TEAM_ID " \
"INNER JOIN STATE " \
"ON TEAM.STATE_ID = STATE.STATE_ID " \
"INNER JOIN COLOR " \
"ON TEAM.COLOR_ID = COLOR.COLOR_ID " \
"WHERE STATE.NAME = " + string("'") + team_state + "' " + "AND COLOR.NAME = " + string("'") + team_color + "';";
result R( N.exec( sql ));
query4Print(R);
}
void query5Print(result R) {
cout << "FIRST_NAME ";
cout << "LAST_NAME ";
cout << "NAME ";
cout << "WINS" << endl;
for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
cout << c[0].as<string>() << " ";
cout << c[1].as<string>() << " ";
cout << c[2].as<string>() << " ";
cout << c[3].as<int>() << endl;
}
}
void query5(connection *C, int num_wins)
{
nontransaction N(*C);
string sql;
stringstream n;
n << num_wins;
sql = "SELECT PLAYER.FIRST_NAME, PLAYER.LAST_NAME, TEAM.NAME, TEAM.WINS " \
"FROM PLAYER " \
"INNER JOIN TEAM " \
"ON PLAYER.TEAM_ID = TEAM.TEAM_ID " \
"WHERE TEAM.WINS > " + string(n.str()) + ";";
result R( N.exec( sql ));
query5Print(R);
}
| [
"yy194@duke.edu"
] | yy194@duke.edu |
21f895711bccc29156ded761299e3ba087403cb9 | 140163a8e8998382c1b8097187abf6111cecb02d | /T94.cpp | 414c064fa8aaa476c65b6f255da1ddf9171c0fdc | [] | no_license | yebanxinghui/leetcode | 2112510d2bc794b8334ed3c94c8b52c56d4d4cca | e75433a521d798fd8bddd91d43ace94ced274686 | refs/heads/master | 2022-09-08T03:14:40.564157 | 2020-05-26T13:05:17 | 2020-05-26T13:05:17 | 267,042,189 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 960 | cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
stack<TreeNode*> S;
vector<int> v;
TreeNode* rt = root;
while(rt || S.size()){
while(rt){
S.push(rt->right);
v.push_back(rt->val);
rt=rt->left;
}
rt=S.top();S.pop();
}
return v;
//vector<int> v;
//return track(root,v);
}
vector<int> track(TreeNode *root,vector<int> &v)
{
if(root!=nullptr)
{
if(root->left!=nullptr)
track(root->left,v);
v.push_back(root->val);
if(root->right!=nullptr)
track(root->right,v);
}
return v;
}
}; | [
"1225841522@qq.com"
] | 1225841522@qq.com |
dffbd6a8ce3788e65bb299d090c99d29b3e89560 | 3670f46666214ef5e1ce6765e47b24758f3614a9 | /oneflow/user/kernels/slice_util.h | 030365493ff5d62950cda373b520ea7c7b16f83d | [
"Apache-2.0"
] | permissive | ashing-zhang/oneflow | 0b8bb478ccd6cabea2dca0864defddab231919bf | 70db228a4d361c916f8f8d85e908795b479e5d20 | refs/heads/master | 2022-12-14T21:13:46.752535 | 2020-09-07T03:08:52 | 2020-09-07T03:08:52 | 293,535,931 | 1 | 0 | Apache-2.0 | 2020-09-07T13:28:25 | 2020-09-07T13:28:24 | null | UTF-8 | C++ | false | false | 3,654 | h | /*
Copyright 2020 The OneFlow Authors. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#ifndef ONEFLOW_USER_KERNELS_SLICE_UTIL_H_
#define ONEFLOW_USER_KERNELS_SLICE_UTIL_H_
#include "oneflow/core/common/nd_index_offset_helper.h"
#include "oneflow/core/device/device_context.h"
namespace oneflow {
inline int64_t RegulateSliceStart(int64_t start, int64_t size) {
// slice start must be in range [-size, size)
// after changing to positive order it should be in range [0, size)
start = std::min(std::max(start, -size), size - 1);
return (start < 0) ? (start + size) : start;
}
inline int64_t RegulateSliceStop(int64_t stop, int64_t size) {
// slice stop must be in range [-size-1, size]
// after changing to positive order it should be in range [-1, size]
stop = std::min(std::max(stop, -size - 1), size);
return (stop < 0) ? (stop + size) : stop;
}
constexpr size_t kSliceMaxDims = 8;
struct SliceParams {
int64_t ndim;
int64_t dims[kSliceMaxDims];
int64_t start[kSliceMaxDims];
int64_t step[kSliceMaxDims];
int64_t size[kSliceMaxDims];
int64_t elem_cnt() const {
if (ndim == 0) { return 0; }
int64_t elem_cnt = 1;
FOR_RANGE(int, i, 0, ndim) { elem_cnt *= size[i]; }
return elem_cnt;
}
bool IsFullSlice(int dim) const {
CHECK_GE(dim, 0);
CHECK_LT(dim, ndim);
if (step[dim] != 1) { return false; }
if (start[dim] != 0) { return false; }
if (size[dim] != dims[dim]) { return false; }
return true;
}
};
SliceParams FoldContiguousFullSliceDimensions(const SliceParams& params);
template<int NDIM>
using SliceIndexHelper = NdIndexOffsetHelper<int64_t, NDIM>;
template<int NDIM>
OF_DEVICE_FUNC int64_t SliceOffsetToEntireOffset(int64_t offset, const SliceParams& params,
const SliceIndexHelper<NDIM>& entire_idx_cvtr,
const SliceIndexHelper<NDIM>& sliced_idx_cvtr) {
int64_t nd_index[NDIM] = {0};
sliced_idx_cvtr.OffsetToNdIndex(offset, nd_index);
#ifdef __CUDA_ARCH__
#pragma unroll
#endif
for (int64_t i = 0; i < NDIM; ++i) {
nd_index[i] = params.start[i] + params.step[i] * nd_index[i];
assert(nd_index[i] >= 0);
assert(nd_index[i] < params.dims[i]);
}
return entire_idx_cvtr.NdIndexToOffset(nd_index);
}
template<DeviceType device_type, typename T>
struct SliceKernelUtil {
static void Forward(DeviceCtx* ctx, const SliceParams& params, const T* entire, T* sliced);
static void Backward(DeviceCtx* ctx, const SliceParams& params, const T* sliced, T* entire);
};
#define INSTANTIATE_SLICE_KERNEL_UTIL(device, dtype) template struct SliceKernelUtil<device, dtype>;
#define INSTANTIATE_SLICE_KERNEL_UTIL_WITH_DEVICE(device) \
INSTANTIATE_SLICE_KERNEL_UTIL(device, float) \
INSTANTIATE_SLICE_KERNEL_UTIL(device, double) \
INSTANTIATE_SLICE_KERNEL_UTIL(device, int32_t) \
INSTANTIATE_SLICE_KERNEL_UTIL(device, int64_t) \
INSTANTIATE_SLICE_KERNEL_UTIL(device, int8_t) \
INSTANTIATE_SLICE_KERNEL_UTIL(device, uint8_t)
} // namespace oneflow
#endif // ONEFLOW_USER_KERNELS_SLICE_UTIL_H_
| [
"noreply@github.com"
] | ashing-zhang.noreply@github.com |
9ad54a497163c828d1696517be2bcfd07a0103ae | 05ee5944509635baaac0326965304cd3011c5a4b | /CS106B/Chapter03 (Strings) Book Exercises/16. Obenglobish/Obenglobish.cpp | c93a9021259d55db4caf5309cd1f3fdc95809ce3 | [] | no_license | oliverpecha/Stanford-SEE | f170889ad02f6e9c9caeb19ccbfceda5cd64d6ad | 562605a8e0e72fb84bc7c899346d5c2282e6f31c | refs/heads/master | 2023-07-09T02:33:34.291651 | 2023-07-04T15:22:14 | 2023-07-04T15:22:14 | 229,628,585 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,717 | cpp | /*
* File: Obenglobish.cpp
* --------------
* Most people—at least those in English-speaking countries—have played the Pig Latin game
* at some point in their lives. There are, however, other invented “languages” in which words
* are created using some simple transformation of English. One such language is called Obenglobish,
* in which words are created by adding the letters ob before the vowels (a, e, i, o, and u)
* in an English word. For example, under this rule, the word english gets the letters ob added before
* the e and the i to form obenglobish, which is how the language gets its name.
*
* In official Obenglobish, the ob characters are added only before vowels that are pronounced,
* which means that a word like game would become gobame rather than gobamobe because the final e is silent.
* While it is impossible to implement this rule perfectly, you can do a pretty good job by adopting the rule
* that the ob should be added before every vowel in the English word except
*
* • Vowels that follow other vowels
* • An e that occurs at the end of the word
*
* Write a function obenglobish that takes an English word and returns its Obenglobish equivalent, using the translation rule given above. For example, if you used your function with the main program
* int main() {
* while (true) {
* string word = getLine("Enter a word: ");
* if (word == "") break;
* string trans = obenglobish(word);
* cout << word << " -> " << trans << endl;
* }
* return 0;
* }
*/
#include "console.h"
#include "simpio.h"
using namespace std;
string PigLatin(string word);
string lineToPigLatin (string line);
string wordToObenglobish (string word);
int locateVowel(string word, int vp);
bool isVowel (char ch);
string capitalize(string str);
const string SENTINEL = "";
int main() {
string word = " ";
cout << "This program translates English to Obenglish. \nIndicate the end of the input with a blank line.. " << endl;
while (word != SENTINEL) {
word = getLine("\nEnter English text:");
cout << word << " -> " << wordToObenglobish(word) << endl;
}
return 0;
}
string wordToObenglobish (string word) {
string result = word;
int pos = 0;
int ticker = 0;
pos = locateVowel(result, pos);
while (pos != -1) {
if (!isVowel(result[pos-1])) {
if (result[pos] == 'e' && result.length() - 1 == pos) pos = -1;
else {
result.insert(pos,"ob");
if (pos + 3 * ticker < result.length() ) pos += 3;
else pos = -1;
ticker++;
}
}
else {
if (pos + 1 < result.length() ) pos++;
else pos = -1;
}
pos = locateVowel(result, pos);
}
return capitalize(result);
}
int locateVowel(string word, int vp) {
for (int i = vp; i < word.length(); i++) {
if (isVowel(word[i])) return i;
}
return -1; }
bool isVowel (char ch) {
switch (ch) {
case 'A': case 'E': case 'I': case 'O': case 'U':
case 'a': case 'e': case 'i': case 'o': case 'u':
return true;
default:
return false;
}
}
string capitalize(string str) {
int index = 0;
for (int i = 0; i < str.length(); i++){
if (index == 0) {
str[i] = toupper(str[i]);
index++;
}
else {
str[i] = tolower(str[i]);
index++;
}
if (isspace(str[i+1])) {
index = -1;
}
}
return str;
}
| [
"oliverpecha@gmail.com"
] | oliverpecha@gmail.com |
78fb5ccfee1b3226faa0e5637ffd8b6af984377b | 74c9596045b75fc13d1944e4edd0505a120055be | /Chapter2/2.1.cpp | 16b57fdfa6f8b50b0872520935f5aa4dc74f6dc7 | [] | no_license | licesma/CCI | 67691921fcd487593b58b3916cd635cbf00a8a27 | c28312b5fedbfbde174188314237c5b34848cd9a | refs/heads/master | 2020-06-22T02:44:54.574853 | 2019-09-10T01:24:25 | 2019-09-10T01:24:25 | 197,613,996 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 471 | cpp |
#include <iostream>
#include "LinkedList.h"
using namespace std;
template <class T>
void deleteReps(ListNode* ln) {
ListNode* ptr; ptr = ln; ListNode* del;
while (ptr != nullptr) {
del = ptr->next;
if (del != nullptr) {
while (del->next != nullptr) {
if (del->next->val == ptr->val) del->next = del->next->next;
del = del->next;
}
if (ptr->next->val == ptr->val)ptr->next = ptr->next->next;
}
ptr=ptr->next;
}
}
int main()
{
return 0;
}
| [
"36255528+licesma@users.noreply.github.com"
] | 36255528+licesma@users.noreply.github.com |
b55fbbb4d4afa47f25576a2f391b22d54e949885 | 3ca6a6b52b525571da622100a57c8020cbdc185e | /examples/gaussianfilter/xf_gaussian_filter_tb.cpp | e394174f4197536e25a50552536c93c6ae276b61 | [
"BSD-3-Clause"
] | permissive | sudohello/xfopencv | 7dffe6d736ac24522fc5e128c2d89e366ba088a3 | e1d5e0015ea1980901703e989bf201962c8f3a4d | refs/heads/master | 2021-07-12T21:58:38.830318 | 2017-10-17T09:08:36 | 2017-10-17T09:08:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,983 | cpp | /***************************************************************************
Copyright (c) 2016, Xilinx, Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
***************************************************************************/
#include "xf_headers.h"
#include "xf_gaussian_filter_config.h"
using namespace std;
int main(int argc, char **argv) {
if (argc != 2)
{
printf("Usage: <executable> <input image path> \n");
return -1;
}
cv::Mat in_img, out_img, ocv_ref, in_img_gau;
cv::Mat in_gray, in_gray1, diff;
in_img = cv::imread(argv[1], 1); // reading in the color image
if (!in_img.data) {
printf("Failed to load the image ... !!!");
return -1;
}
extractChannel(in_img, in_gray, 1);
ocv_ref.create(in_gray.rows, in_gray.cols, in_gray.depth()); // create memory for output image
#if FILTER_WIDTH==3
float sigma = 0.5f;
#endif
#if FILTER_WIDTH==7
float sigma=1.16666f;
#endif
#if FILTER_WIDTH==5
float sigma = 0.8333f;
#endif
// OpenCV Gaussian filter function
cv::GaussianBlur(in_gray, ocv_ref, cvSize(FILTER_WIDTH, FILTER_WIDTH),FILTER_WIDTH / 6.0, FILTER_WIDTH / 6.0, cv::BORDER_CONSTANT);
imwrite("output_ocv.png", ocv_ref);
out_img.create(in_gray.rows, in_gray.cols, in_gray.depth()); // create memory for output image
xf::Mat<XF_8UC1, HEIGHT, WIDTH, NPC1> imgInput(in_gray.rows,in_gray.cols);
xf::Mat<XF_8UC1, HEIGHT, WIDTH, NPC1> imgOutput(in_gray.rows,in_gray.cols);
imgInput.copyTo(in_gray.data);
#if __SDSCC__
perf_counter hw_ctr;
hw_ctr.start();
#endif
gaussian_filter_accel(imgInput,imgOutput,sigma);
#if __SDSCC__
hw_ctr.stop();
uint64_t hw_cycles = hw_ctr.avg_cpu_cycles();
#endif
out_img.data = imgOutput.copyFrom();
imwrite("output_hls.png", out_img);
absdiff(ocv_ref, out_img, diff); // Compute absolute difference image
imwrite("error.png", diff); // Save the difference image for debugging purpose
// Find minimum and maximum differences.
double minval = 256, maxval = 0;
int cnt = 0;
for (int i = 0; i < in_img.rows; i++) {
for (int j = 0; j < in_img.cols; j++) {
uchar v = diff.at<uchar>(i, j);
if (v > 0)
cnt++;
if (minval > v)
minval = v;
if (maxval < v)
maxval = v;
}
}
float err_per = 100.0 * (float) cnt / (in_img.rows * in_img.cols);
printf(
"Minimum error in intensity = %f\n\
Maximum error in intensity = %f\n\
Percentage of pixels above error threshold = %f\n",
minval, maxval, err_per);
if(err_per > 1){
printf("\nTest failed\n");
return -1;
}
else{
printf("\nTest Pass\n");
return 0;
}
}
| [
"gouthamb@xilinx.com"
] | gouthamb@xilinx.com |
06b7f3459418cc74d6cda2f20682ef13056eda65 | 85893cb85812e4c0d4003f9f9652b057bab295c4 | /src/gdimgui.h | 55b9a89c4887645d26cdfa737c029a57eac12525 | [
"MIT"
] | permissive | chaosddp/imgui-gdscript | d01c66814e171b7fe61acdd3e02844dcd928b766 | 9c2094bd8cb91842adbb0f024f4330daf9192fae | refs/heads/master | 2023-02-06T11:43:18.688694 | 2020-12-27T07:25:37 | 2020-12-27T07:25:37 | 324,135,677 | 0 | 0 | null | 2020-12-25T13:08:50 | 2020-12-24T11:01:43 | C++ | UTF-8 | C++ | false | false | 11,644 | h | #ifndef GDIMGUI_H
#define GDIMGUI_H
#include <Godot.hpp>
#include <CanvasItem.hpp>
#include <Image.hpp>
#include <ImageTexture.hpp>
#include <ArrayMesh.hpp>
#include <MeshInstance2D.hpp>
#include <VisualServer.hpp>
#include <Resource.hpp>
#include <Node2D.hpp>
#include <Input.hpp>
#include <InputEvent.hpp>
#include <SceneTree.hpp>
#include <InputEventMouseMotion.hpp>
#include <InputEventMouseButton.hpp>
#include <InputEventKey.hpp>
#include <Viewport.hpp>
#include <GlobalConstants.hpp>
#include <Texture.hpp>
#include <GodotGlobal.hpp>
#include <unordered_map>
#include "imgui.h"
using namespace godot;
class GDImGui : public Node2D
{
GODOT_CLASS(GDImGui, Node2D);
// imgui context for current instance
ImGuiContext *_imgui_ctx;
// global texture id for new added images
static int texture_id;
// current avaiable customized images
std::unordered_map<int, Texture *> _textures;
// used to hold value from checkbox
bool _checkbox_v;
bool _combo_is_last_selected;
void gen_font_tex();
void init_imgui();
// custom image management
int add_texture(Texture *tex);
Texture *get_texture(int id);
void remove_texture(int id);
// make sure the root exist
void ensure_root();
public:
static void _register_methods();
GDImGui();
~GDImGui();
void _init(); // our initializer called by Godot
void _input(Ref<InputEvent> event);
void _process(float delta);
void render();
// helpers
// add image and get an id for following usage, like imgui.image, imgui.image_button
int add_image(Ref<Texture> tex);
// Set context of this instance as current context for imgui
void set_as_current_context();
// show demo window
bool show_demo_window(bool opened);
bool show_metrics_window(bool opened);
bool show_about_window(bool opened);
// styles
void style_color_dark();
void style_color_light();
void style_color_classic();
void new_frame();
String get_version();
// widgets
void text_unformatted(String text);
void text(String text);
void text_colored(Color color, String text);
void text_disabled(String text);
void text_wrapped(String text);
void label_text(String label, String text);
void bullet_text(String text);
bool button(String label, Vector2 size);
bool small_button(String label);
bool arrow_button(String id, int dir); // dir: ImGuiContants.dir
void image(int tex_id, Vector2 size, Vector2 uv0, Vector2 uv1, Color tint_color, Color border_color);
void image_button(int tex_id, Vector2 size, Vector2 uv0, Vector2 uv1, Color bg_color, Color tint_color, int frame_padding);
bool checkbox(String label, bool checked);
int checkbox_flags(String label, int flags, int flag_value);
bool radio_button(String label, bool activated);
void progressbar(float fraction, Vector2 size, String overlay);
void bullet();
// layouts
void spacing();
void dummy(Vector2 size);
void newline();
void align_text_to_frame_padding();
void separator();
bool begin_combo(String label, String preview_value, int flag);
void end_combo();
bool selectable(String label, bool is_selected, int flags, Vector2 size);
void set_item_default_focus();
// drag
float drag_float(String label, float default_value, float speed, float v_min, float v_max, String format, int flags);
Vector2 drag_float2(String label, Vector2 default_value, float speed, float v_min, float v_max, String format, int flags);
Vector3 drag_float3(String label, Vector3 default_value, float speed, float v_min, float v_max, String format, int flags);
int drag_int(String label, int default_value, float speed, int v_min, int v_max, String format, int flags);
PoolIntArray drag_int2(String label, PoolIntArray default_value, float speed, int v_min, int v_max, String format, int flags);
PoolIntArray drag_int3(String label, PoolIntArray default_value, float speed, int v_min, int v_max, String format, int flags);
// slider
float slider_float(String label, float default_value, float v_min, float v_max, String format, int flags);
Vector2 slider_float2(String label, Vector2 default_value, float v_min, float v_max, String format, int flags);
Vector3 slider_float3(String label, Vector3 default_value, float v_min, float v_max, String format, int flags);
float slider_angle(String label, float default_value, float v_min, float v_max, String format, int flags);
int slider_int(String label, int default_value, int v_min, int v_max, String format, int flags);
PoolIntArray slider_int2(String label, PoolIntArray default_value, int v_min, int v_max, String format, int flags);
PoolIntArray slider_int3(String label, PoolIntArray default_value, int v_min, int v_max, String format, int flags);
float v_slider_float(String label, Vector2 size, float default_value, float v_min, float v_max, String format, int flags);
int v_slider_int(String label, Vector2 size, int default_value, int v_min, int v_max, String format, int flags);
// input
float input_float(String label, float default_value, float step, float step_fast, String format, int flags);
Vector2 input_float2(String label, Vector2 default_value, String format, int flags);
Vector3 input_float3(String label, Vector3 default_value, String format, int flags);
int input_int(String label, int default_value, int step, int step_fast, int flags);
PoolIntArray input_int2(String label, PoolIntArray default_value, int flags);
PoolIntArray input_int3(String label, PoolIntArray default_value, int flags);
String input_text(String label, String value, int max_length, int flags);
String input_text_multipleline(String label, String value, int max_length, Vector2 size, int flags);
String input_text_with_hint(String label, String hint, String value, int max_length, int flags);
// color edit
Color color_edit4(String label, Color color, int flags);
Color color_picker4(String label, Color color, int flags);
bool color_button(String desc_id, Color color, int flags, Vector2 size);
void set_color_edit_options(int flags);
// tree
bool tree_node(String label);
bool tree_node_ex(int id, int flags, String label);
void tree_pop();
float get_tree_node_to_label_spacing();
void set_next_item_open(bool is_open, int condition);
bool collapsing_header(String label, int flags);
// listbox
bool listbox_header(String label, Vector2 size);
void listbox_footer();
// plot
void plot_lines(String label, PoolRealArray values, int value_offset, String overlay, float scale_min, float scale_max, Vector2 size, int stride);
void plot_histogram(String label, PoolRealArray values, int value_offset, String overlay, float scale_min, float scale_max, Vector2 size, int stride);
// menubar
bool begin_menu_bar();
void end_menu_bar();
bool begin_main_menu_bar();
void end_main_menu_bar();
bool begin_menu(String label, bool enabled);
void end_menu();
bool menu_item(String label, String shortcut, bool selected, bool enabled);
// tabbar
bool begin_tab_bar(String id, int flags);
void end_tab_bar();
bool begin_tab_item(String label, bool open, int flags);
void end_tab_item();
bool tab_item_button(String label, int flags);
void set_tab_item_closed(String label);
// table
bool begin_table(String id, int columns_count, int flags, Vector2 outer_size, float inner_width);
void end_table();
void table_setup_column(String label, int flags, float init_width_or_weight, unsigned int user_id);
void table_setup_scroll_freeze(int columns, int rows);
void table_set_bg_color(int target, Color color, int column_n);
int table_get_row_index();
void table_next_row(int row_flags, float row_min_height);
bool table_set_column_index(int column_n);
bool table_next_column();
void table_headers_row();
void table_header(String label);
int get_column_index();
int get_columns_count();
float get_column_offset(int column_index);
float get_column_width(int column_index);
void set_column_width(int column_index, float width);
void set_column_offset(int column_index, float offset);
Vector2 get_content_region_avail();
void next_column();
void columns(int columns_count, String id, bool border);
void set_clipboard_text(String text);
void push_clip_rect(Vector2 rect_min, Vector2 rect_max, bool intersect_with_current_clip_rect);
void pop_clip_rect();
Vector2 calc_text_size(String text, String text_end, bool hide_text_after_double_has, float wrap_width);
bool is_mouse_hovering_rect(Vector2 r_min, Vector2 r_max, bool clip);
bool begin_child(String id, Vector2 size, bool border, int flags); // window flags
void end_child();
bool begin_child_frame(unsigned int id, Vector2 size, int flags); // window flags
void end_child_frame();
void push_button_repeat(bool repeat);
void pop_button_repeat();
void push_allow_keyboard_focus(bool allow_keyboard_focus);
void pop_allow_keyboard_focus();
void set_next_window_pos(Vector2 pos, int condition, Vector2 pivot);
void set_next_window_size(Vector2 size, int condition);
void set_window_size(String name, Vector2 size, int condition);
void set_window_collapsed(String name, bool collapsed, int condition);
void set_window_focus(String name);
void set_next_window_bg_alpha(float alpha);
void set_window_font_scale(float scale);
void push_id(int id);
void pop_id();
void same_line(float offset_from_start_x, float spacing_w);
void indent(float indent_w);
void unindent(float indent_w);
void set_next_item_width(float item_width);
void push_item_width(float item_width);
void pop_item_width();
float calc_item_width();
float get_text_line_height();
float get_text_line_height_with_spacing();
float get_frame_height();
float get_frame_height_with_spacing();
void begin_group();
void end_group();
bool is_popup_open(String id, int flags);
void open_popup(String id, int flags);
void close_current_popup();
bool begin_popup(String id, int flags); // window flags
bool begin_popup_modal(String name, bool open, int flags); // window flags
void end_popup();
void open_popup_on_item_click(String id, int flags);
bool begin_popup_context_item(String id, int flags);
bool begin_popup_context_window(String id, int flags);
bool begin_popup_context_void(String id, int flags);
void log_text(String text);
void log_to_tty(int auto_open_depth);
void log_to_file(int auto_open_depth, String file_name);
void log_to_clipboard(int auto_open_depth);
void log_finish();
void log_buttons();
bool begin(String name, bool open, int flags);
void end();
void begin_tooltip();
void end_tooltip();
void push_text_wrap_pos(float pos_x);
void pop_text_wrap_pos();
float get_font_size();
bool is_item_hovered();
bool is_item_clicked(int mouse_button);
bool is_item_activated();
bool is_item_active();
bool is_item_edited();
bool is_item_focused();
bool is_item_visible();
void push_style_color(int idx, Color color);
void pop_style_color(int count);
void set_tooltip(String text);
Vector2 get_cursor_screen_pos();
bool is_mouse_double_clicked(int mouse_button);
bool is_mouse_clicked(int mouse_button, bool repeat);
};
#endif | [
"chaos.you@gmail.com"
] | chaos.you@gmail.com |
36ae491694a38f7c4e44a7c5fd023b2bcb417cea | a7ab64ae89d14ca8a64e8f52235188a2613f7ea0 | /PC/SDK/Entity/LocalPlayer/local_player.cpp | 46c2eec3b65101329fa2f91559351cf7229a20da | [
"BSD-3-Clause"
] | permissive | khizzioui97/SQ-Project-CSGO-Arduino | 556509746768291d99d17d6f51f75db6801aea48 | 50515e44b55d9e867c8eb60fa79e4737244b3990 | refs/heads/master | 2023-06-28T10:22:16.913785 | 2021-08-01T22:41:42 | 2021-08-01T22:41:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,255 | cpp | #include "local_player.h"
LocalPlayer::LocalPlayer(const Module& client, const DWORD client_state)
: AbstractLocalPlayer(
Memory::Read<DWORD>(client.base + Signatures::dwLocalPlayer)),
client_address_(client.base),
client_state_(client_state) {}
int LocalPlayer::GetCrosshairId() const {
return Memory::Read<int>(this->GetAddress() + NetVars::m_iCrosshairId);
}
Vector LocalPlayer::GetLocalViewAngle() const {
return Memory::Read<Vector>(
client_state_ + Signatures::dwClientState_ViewAngles);
}
std::pair<Vector, float> LocalPlayer::GetAimAngleDiffAndDistance(
const EntityList& entity_list, int bone, float max_fov) const {
float best_fov = 360.f;
Vector angle_diff(0, 0, 0);
float dist = 0.f;
Vector view_angle = this->GetLocalViewAngle();
NormalizeAngles(&view_angle);
const Team local_player_team = this->GetTeam();
for (int target_id = 1; target_id <= 64; ++target_id) {
Entity target = entity_list.GetEntity(target_id);
if (!target.GetAddress()) {
continue;
}
if (!target.IsAlive()) {
continue;
}
if (target.GetTeam() == Team::kNone
|| target.GetTeam() == Team::kSpectator
|| target.GetTeam() == local_player_team) {
continue;
}
if (target.IsDormant()) {
continue;
}
Vector angle_to_target = this->GetAngleToTarget(target, bone);
float fov = GetFov(view_angle.ToQAngle(), angle_to_target.ToQAngle());
if (fov < best_fov && fov <= max_fov) {
best_fov = fov;
angle_diff = angle_to_target - view_angle;
NormalizeAngles(&angle_diff);
dist = this->GetPos().DistTo(target.GetPos());
}
}
return std::make_pair(angle_diff, dist);
}
Vector LocalPlayer::GetAngleToTarget(const Entity& target, int bone) const {
const Vector cur_view = this->GetView();
const Vector aim_view = target.GetBonePos(bone);
Vector dst = CalcAngle(cur_view, aim_view).ToVector();
NormalizeAngles(&dst);
return dst;
}
float LocalPlayer::GetSensitivity() const {
DWORD ptr = client_address_ + Signatures::dwSensitivityPtr;
auto sensitivity =
Memory::Read<DWORD>(client_address_ + Signatures::dwSensitivity);
sensitivity ^= ptr;
return *reinterpret_cast<float*>(&sensitivity);
}
| [
"noreply@github.com"
] | khizzioui97.noreply@github.com |
6f870585cfcb8aa34f6ba883c4187efd7bb23f42 | b416199ce8e69cebd7645b7e69dd3ad1521f86ae | /zajecia5/zad2.cpp | 39f5a724d8a670fb144939a3b847727b0dddccff | [] | no_license | pstorozenko/YP2018L-cpp | a8645bc17a4e73101d01cb2697b819913553f360 | abadc203571825df969ecb5d7e6aa781c78c67e5 | refs/heads/master | 2021-04-03T06:05:34.042545 | 2018-04-24T08:32:22 | 2018-04-24T08:32:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 140 | cpp | #include <iostream>
using namespace std;
int main()
{
for (int i = 0; i < 10; i++) {
cout << "Piotr" << endl;
}
return 0;
}
| [
"pitrosk@gmail.com"
] | pitrosk@gmail.com |
619f7dfdad40ca21806cf2fcb6fbd593171e3daa | 29a7e4f39530427c7a8c50239c3980249f72eabd | /No.1-2/EmptyProject/DieEffect.h | eeb48b6eddc7838022256f3235e17c5c720be9a3 | [] | no_license | sojunyoup/No.1-2 | 6cae00cca567391d574ddd8b41c1a9b01847f497 | 4052580eee6e358231f2f428b2193a6f02366f60 | refs/heads/master | 2023-04-09T01:18:21.646509 | 2021-04-14T13:21:19 | 2021-04-14T13:21:19 | 357,912,478 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 345 | h | #pragma once
#include "Object.h"
class DieEffect : public Object
{
private:
int num;
float size = 1;
Vector2 Dir;
Timer* asd;
public:
DieEffect(Vector2 dir,int number);
// Object을(를) 통해 상속됨
virtual void Init() override;
virtual void Update() override;
virtual void Render() override;
virtual void Release() override;
};
| [
"thwnsuq46@naver.com"
] | thwnsuq46@naver.com |
a08056f14afbfc6829f2cebd74123f1abe8d5aa1 | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_6404600001200128_0/C++/LilacLu/a.cpp | 8e580561fc172dc0807edf74a5ccaf66947f5949 | [] | no_license | alexandraback/datacollection | 0bc67a9ace00abbc843f4912562f3a064992e0e9 | 076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf | refs/heads/master | 2021-01-24T18:27:24.417992 | 2017-05-23T09:23:38 | 2017-05-23T09:23:38 | 84,313,442 | 2 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 884 | cpp | #include <cstdio>
#define small
int T, n, x[1005];
int eatOne() {
int ret = 0;
for (int i = 1; i < n; ++i)
if (x[i] < x[i - 1])
ret += x[i - 1] - x[i];
return ret;
}
int eatTwo() {
int ret = 0, eatPerTenSec = 0;
for (int i = 1; i < n; ++i)
if (x[i - 1] - x[i] > eatPerTenSec)
eatPerTenSec = x[i - 1] - x[i];
for (int i = 0; i < n - 1; ++i)
ret += (x[i] >= eatPerTenSec ? eatPerTenSec : x[i]);
return ret;
}
int main()
{
#ifdef small
freopen("A-small.in", "r", stdin);
freopen("A-small.out", "w", stdout);
#endif
#ifdef large
freopen("A-large.in", "r", stdin);
freopen("A-large.out", "w", stdout);
#endif
scanf("%d", &T);
for (int Case = 1; Case <= T; ++Case) {
scanf("%d", &n);
for (int i = 0; i < n; ++i)
scanf("%d", &x[i]);
printf("Case #%d: %d %d\n", Case, eatOne(), eatTwo());
}
return 0;
}
| [
"eewestman@gmail.com"
] | eewestman@gmail.com |
77288941ec92a5f99d28a1176c8ee0a853893f48 | b77349e25b6154dae08820d92ac01601d4e761ee | /List/rebuild_clist/FileInfoList.cpp | d1ae3563241b6ffa052c6679fd8991d84e7f058b | [] | no_license | ShiverZm/MFC | e084c3460fe78f820ff1fec46fe1fc575c3e3538 | 3d05380d2e02b67269d2f0eb136a3ac3de0dbbab | refs/heads/master | 2023-02-21T08:57:39.316634 | 2021-01-26T10:18:38 | 2021-01-26T10:18:38 | 332,725,087 | 0 | 0 | null | 2021-01-25T11:35:20 | 2021-01-25T11:29:59 | null | GB18030 | C++ | false | false | 21,485 | cpp | #include "StdAfx.h"
#include "FileInfoList.h"
#include "PublicFunc.h"
#include "ImgBaseFunc.h"
FileInfoList::FileInfoList(void)
{
m_filUpItem=NULL; //链表中上一项的值
m_filNextItem=NULL; //链表中下一项的值
m_imgSmallPhotoImage=NULL; //存放缩略图文件
}
FileInfoList::~FileInfoList(void)
{
//if(m_imgSmallPhotoImage!=NULL)
// {delete m_imgSmallPhotoImage;} //存放缩略图文件
}
//=====================================================================
// 函 数 名：FileInfoList
// 功能描述：根据输入的文件完整路径与是否文件夹初始化相关信息
// 输入参数：string fileFullPath:文件全路径
// bool isDirectory:是否文件夹
// bool isPhoto:是否图象
// LONG fileLength:文件长度
// 输出参数：
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
FileInfoList::FileInfoList(string fileFullPath,UINT fileType,LONG fileLength)
{
int mark_1; //文件完整路径中最后一个'/'或'\'位置
int fileNameLen; //文件扩展名长度
mark_1=(int)fileFullPath.find_last_of("\\/");
m_uiFileType=fileType;
m_sFileFullPath=fileFullPath;
m_sFileName=string(fileFullPath,mark_1+1);
m_sFilePath=string(fileFullPath,0,mark_1+1);
if(!CheckFileType(FILE_FLODER))
{
//当不是文件夹时，获取扩展名等
fileNameLen=(int)m_sFileName.find_last_of(".");
if(fileNameLen>=0)
{
m_sFileExtName=string(m_sFileName,fileNameLen+1);
PublicFunc::LowStr(m_sFileExtName);
}
else
{
fileNameLen=(int)(m_sFileName.length());
m_sFileExtName="";
}
}
else
{
m_sFileExtName="";
}
m_iFloderCode=0;
m_sFileSize=""; //文件大小
m_sFileType=""; //文件类型
m_sFileCreateTime=""; //文件创建时间
m_sFileEditTime=""; //文件修改时间
m_sFileOpenTime=""; //文件访问时间
//图象大小
if(fileLength==0)
{
m_sFileSize="";
}
else
{
m_sFileSize=PublicFunc::Long2Str(fileLength/1024,0)+"KB";
}
m_sTakePhotoTime=""; //拍摄时间
//其余变量的初始化
m_bNeedGetInfo=true; //是否需要获取文件信息
m_bNeedGetBaseInfo=true; //是否需要获取文件基本信息
m_bNeedGetSmallPhoto=true; //是否需要获取缩略图
m_bSmallPhotoEnable=false; //缩略图是否有效
m_bFileEnable=true; //文件是否有效，文件在链表中是否有效
m_uiState=0; //item状态
m_filUpItem=NULL; //链表中上一项的值
m_filNextItem=NULL; //链表中下一项的值
m_imgSmallPhotoImage=NULL; //存放缩略图文件
m_iPhotoWidth=0; //图象宽度
m_iPhotoHeight=0; //图象高度
m_iRealPhotoWidth=0; //图象实际宽度
m_iRealPhotoHeight=0; //图象实际高度
m_iNIcon=-1; //在系统图标中的位置编号
m_iGroupId=-1; //所属分组ID
m_iPhotoLevel=0; //图片所属等级编号
m_iPhotoTypeCode=0; //图片所属分类编号
//设置显示项的初始化
m_iiItemInfo.nItem=-1;
m_iiItemInfo.photoHeight=0;
m_iiItemInfo.photoWidth=0;
m_iiItemInfo.printPos=CPoint(0,0);
m_iiItemInfo.reDrawEnable=true;
m_iiItemInfo.state=0;
m_iiItemInfo.style=-1;
}
//=====================================================================
// 函 数 名：GetFileName
// 功能描述：返回文件名
// 输入参数：void
// 输出参数：string
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
string FileInfoList::GetFileName()
{
return m_sFileName;
}
//=====================================================================
// 函 数 名：GetFilePath
// 功能描述：返回文件路径
// 输入参数：void
// 输出参数：string
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
string FileInfoList::GetFilePath()
{
return m_sFilePath;
}
//=====================================================================
// 函 数 名：GetFileExtName
// 功能描述：返回文件扩展名
// 输入参数：void
// 输出参数：string
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
string FileInfoList::GetFileExtName()
{
return m_sFileExtName;
}
//=====================================================================
// 函 数 名：GetFileFullPath
// 功能描述：返回文件完整路径
// 输入参数：void
// 输出参数：string
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
string FileInfoList::GetFileFullPath()
{
return m_sFileFullPath;
}
//=====================================================================
// 函 数 名：GetFileBaseInfo
// 功能描述：获取文件基本信息中的某一项
// 输入参数：int INFO_TYPE:在本文件开头以宏定义
// 输出参数：string
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
string FileInfoList::GetFileBaseInfo(int INFO_TYPE)
{
switch(INFO_TYPE)
{
case FILE_NAME:
return m_sFileName;
case FILE_SIZE:
return m_sFileSize;
case FILE_TYPE:
return m_sFileType;
case FILE_CREATE_TIME:
return m_sFileCreateTime;
case FILE_EDIT_TIME:
return m_sFileEditTime;
case FILE_CHANGE_TIME:
return m_sFileEditTime;
case FILE_PHOTO_SIZE:
return m_sPhotoSize;
case FILE_TAKE_PHOTO_TIME:
return m_sTakePhotoTime;
default:
return "";
}
}
//=====================================================================
// 函 数 名：SetFileType
// 功能描述：设置文件种类
// 输入参数：UINT
// 输出参数：void
// 创建日期：08.10.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
void FileInfoList::SetFileType(UINT type)
{
m_uiFileType=type;
}
//=====================================================================
// 函 数 名：CheckFileType
// 功能描述：判断文件种类
// 输入参数：UINT
// 输出参数：BOOL
// 创建日期：08.10.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
BOOL FileInfoList::CheckFileType(UINT type)
{
return m_uiFileType & type;
}
//=====================================================================
// 函 数 名：SetFileName
// 功能描述：设置文件名
// 输入参数：string
// 输出参数：void
// 创建日期：08.10.07
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
void FileInfoList::SetFileName(string fileName)
{
m_sFileName=fileName;
}
//=====================================================================
// 函 数 名：GetSmallPhotoImage
// 功能描述：获取缩略图文件
// 输入参数：void
// 输出参数：Image *
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
Gdiplus::Image * FileInfoList::GetSmallPhotoImage()
{
return m_imgSmallPhotoImage;
}
//=====================================================================
// 函 数 名：GetFileBaseInfo
// 功能描述：获取文件基本信息
// 输入参数：void
// 输出参数：BOOL:返回读取是否成功
// 创建日期：08.09.11
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
BOOL FileInfoList::GetFileBaseInfo()
{
try
{
/**
* 读取文件基本信息
*/
//获取文件大小
//获取文件创建，修改，最后访问时间
WIN32_FILE_ATTRIBUTE_DATA fileTimeData;
SYSTEMTIME ftCreationTime;
SYSTEMTIME ftLastWriteTime;
SYSTEMTIME ftLastAccessTime;
GetFileAttributesEx(m_sFileFullPath.c_str(),GetFileExInfoStandard,&fileTimeData); //获取三个时间
FileTimeToSystemTime(&fileTimeData.ftCreationTime,&ftCreationTime); //转换创建时间
FileTimeToSystemTime(&fileTimeData.ftLastWriteTime,&ftLastWriteTime); //转换修改时间
FileTimeToSystemTime(&fileTimeData.ftLastAccessTime,&ftLastAccessTime); //转换最后访问时间
//将三个时间存入基本属性MAP中
m_sFileCreateTime=PublicFunc::Time2Str(&ftCreationTime);
m_sFileEditTime=PublicFunc::Time2Str(&ftLastWriteTime);
m_sFileEditTime=PublicFunc::Time2Str(&ftLastAccessTime);
if(m_iNIcon==-1)
{
SHFILEINFO shfi;
SHGetFileInfo((m_sFileFullPath.c_str()),
0,
&shfi,
sizeof(SHFILEINFO),
SHGFI_DISPLAYNAME | SHGFI_TYPENAME | SHGFI_LARGEICON | SHGFI_ICON);
m_iNIcon=shfi.iIcon;
}
m_bNeedGetBaseInfo=false;
return TRUE;
}
catch(Error e)
{
AfxMessageBox(e.what());
return FALSE;
}
}
//=====================================================================
// 函 数 名：LoadExifInfo
// 功能描述：载入Exif信息
// 输入参数：void
// 输出参数：void
// 创建日期：08.09.16
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
void FileInfoList::LoadExifInfo()
{
Magick::Image image(m_sFileFullPath);
CImgBaseFunc cimgbasefunc;
m_mssInfoMap=cimgbasefunc.GetImgExifDatas(image);
m_bNeedGetInfo=false;
}
//=====================================================================
// 函 数 名：CreateSmallImage
// 功能描述：将image文件进行缩放
// 输入参数：int width,int height
// 输出参数：BOOL:返回是否成功
// 创建日期：08.09.11
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
BOOL FileInfoList::CreateSmallImage(int width,int height)
{
try
{
//搜索数据库，查询是否存在同路径，同文件名的缩略图
USES_CONVERSION;
Gdiplus::Image * image=new Gdiplus::Image(A2W(m_sFileFullPath.c_str()));
if(image==NULL)
{
delete image;
return FALSE;
}
m_iRealPhotoWidth=image->GetWidth(); //图象实际宽度
m_iRealPhotoHeight=image->GetHeight(); //图象实际高度
double scaleW=(double)(m_iRealPhotoWidth)/width;
double scaleH=(double)(m_iRealPhotoHeight)/height;
double scale=scaleW>scaleH?scaleW:scaleH;
if(scale>1)
{
m_iPhotoWidth=(LONG)(m_iRealPhotoWidth/scale);
m_iPhotoHeight=(LONG)(m_iRealPhotoHeight/scale);
}
else
{
m_iPhotoWidth=m_iRealPhotoWidth;
m_iPhotoHeight=m_iRealPhotoHeight;
}
Gdiplus::Image * tmpImg=image->GetThumbnailImage(m_iPhotoWidth,m_iPhotoHeight);
//Gdiplus::Image * tmpImg=PublicFunc::ReadImage(this,200,160);
if(tmpImg==NULL)
{
delete image;
return FALSE;
}
m_imgSmallPhotoImage=tmpImg;
delete image;
return TRUE;
}
catch(Exception ex)
{
AfxMessageBox(_T(ex.what()));
return FALSE;
}
catch (Magick::Error & e)
{
AfxMessageBox(_T(e.what()));
return FALSE;
}
}
//=====================================================================
// 函 数 名：ISetFileName
// 功能描述：设置文件名
// 输入参数：string fileNewName:新的文件名，不包含路径
// 输出参数：BOOL:返回是否设置成功
// 创建日期：08.09.10
// 修改日期：alzq 08.10.09
// 作 者：alzq
// 附加说明：
//=====================================================================
BOOL FileInfoList::ISetFileName(string fileNewName)
{
//实现函数
//获取原文件路径
string newFullPath=m_sFilePath;
//生成新文件绝对路径
newFullPath.append(fileNewName);
//重命名文件
int i=rename(m_sFileFullPath.c_str(),newFullPath.c_str());
//设置新的文件信息
m_sFileFullPath=newFullPath;
m_sFileName=fileNewName;
//重新设置扩展名
if(!CheckFileType(FILE_FLODER))
{
//当不是文件夹时，获取扩展名等
int fileNameLen=(int)m_sFileName.find_last_of(".");
if(fileNameLen>=0)
{
m_sFileExtName=string(m_sFileName,fileNameLen+1);
PublicFunc::LowStr(m_sFileExtName);
}
else
{
m_sFileExtName="";
}
}
else
{
m_sFileExtName="";
}
return TRUE;
}
//=====================================================================
// 函 数 名：ISetFileNameAndExtName
// 功能描述：设置文件名与扩展名
// 输入参数：string fileNewName:新的文件名，不包含路径
// 输出参数：BOOL:返回是否设置成功
// 创建日期：08.09.10
// 修改日期：alzq 08.10.09
// 作 者：alzq
// 附加说明：
//=====================================================================
BOOL FileInfoList::ISetFileNameAndExtName(string fileNewName)
{
if(ISetFileName(fileNewName))
{
//修改成功时重新设置扩展名
if(!CheckFileType(FILE_FLODER))
{
//当不是文件夹时，获取扩展名等
int fileNameLen=(int)m_sFileName.find_last_of(".");
if(fileNameLen>=0)
{
m_sFileExtName=string(m_sFileName,fileNameLen+1);
PublicFunc::LowStr(m_sFileExtName);
}
else
{
m_sFileExtName="";
}
}
else
{
m_sFileExtName="";
}
return TRUE;
}
else
{
return FALSE;
}
}
//=====================================================================
// 函 数 名：ICopyFile
// 功能描述：拷贝文件到路径
// 输入参数：string fileNewPath:拷贝到的文件的路径，包含"/"
// 输出参数：BOOL:返回是否设置成功
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
BOOL FileInfoList::ICopyFile(string fileNewPath,UINT dealType)
{
//实现函数
string newFullPath=fileNewPath+m_sFileName;
if(access(newFullPath.c_str(),0)==0)
{
//当文件存在时，根据操作方式对文件进行操作
if(dealType==DEAL_ASK)
{
int res=AfxMessageBox(("文件："+newFullPath+" 已经存在，请问是否覆盖？").c_str(),MB_ICONQUESTION|MB_YESNO);
if(res==IDNO)
{
//当选择否时
return FALSE;
}
}
else if(dealType==DEAL_RENAME)
{
int n=0;
do
{
n++;
string s="91拷贝"+n;
newFullPath=fileNewPath+s+m_sFileName;
}while(access(newFullPath.c_str(),0)==0);
}
else if(dealType==DEAL_PASS)
{
//当忽略时，直接返回
return FALSE;
}
//当覆盖时不需要执行任何操作
}
//对文件进行操作，将文件从原文件夹剪切到当前文件夹
CopyFile(m_sFileFullPath.c_str(),newFullPath.c_str(),FALSE);
return TRUE;
}
//=====================================================================
// 函 数 名：ICutFile
// 功能描述：剪切文件到某文件夹
// 输入参数：string fileNewPath:剪切到的文件的路径，包含"/"
// 输出参数：BOOL:返回是否设置成功
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
BOOL FileInfoList::ICutFile(string fileNewPath,UINT dealType)
{
//实现函数
string newFullPath=fileNewPath+m_sFileName;
if(access(newFullPath.c_str(),0)==0)
{
//当文件存在时，根据操作方式对文件进行操作
if(dealType==DEAL_ASK)
{
int res=AfxMessageBox(("文件："+newFullPath+" 已经存在，请问是否覆盖？").c_str(),MB_ICONQUESTION|MB_YESNO);
if(res!=IDYES)
{
//当选择否时
return FALSE;
}
}
else if(dealType==DEAL_RENAME)
{
int n=0;
do
{
n++;
string s="91剪切"+n;
newFullPath=fileNewPath+s+m_sFileName;
}while(access(newFullPath.c_str(),0)==0);
}
else if(dealType==DEAL_PASS)
{
//当忽略时，直接返回
return FALSE;
}
//当覆盖时不需要执行任何操作
}
//对文件进行操作，将文件从原文件夹剪切到当前文件夹
MoveFileEx(m_sFileFullPath.c_str(),newFullPath.c_str(),MOVEFILE_REPLACE_EXISTING);
return TRUE;
}
//=====================================================================
// 函 数 名：Dispose
// 功能描述：释放本对象的资源
// 输入参数：void
// 输出参数：void
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
void FileInfoList::Dispose()
{
try
{
m_mssInfoMap.clear(); //文件信息保存MAP
m_filUpItem=NULL; //链表中上一项的值
m_filNextItem=NULL; //链表中下一项的值
m_sFileSize.~basic_string(); //文件大小
m_sFileType.~basic_string(); //文件类型
m_sFileCreateTime.~basic_string(); //文件创建时间
m_sFileEditTime.~basic_string(); //文件修改时间
m_sFileOpenTime.~basic_string(); //文件访问时间
m_sPhotoSize.~basic_string(); //图象大小
m_sTakePhotoTime.~basic_string(); //拍摄时间
m_sFileName.~basic_string(); //不包含扩展名的文件名
m_sFilePath.~basic_string(); //文件路径，包含"/"
m_sFileExtName.~basic_string(); //文件扩展名
m_sFileFullPath.~basic_string(); //文件完整路径，包括文件名什么的
if(m_imgSmallPhotoImage!=NULL){delete m_imgSmallPhotoImage;} //存放缩略图文件
}
catch(Exception e)
{
AfxMessageBox(e.what());
}
}
//=====================================================================
// 函 数 名：InsertNext
// 功能描述：在本ITEM之后插入一个ITEM
// 输入参数：FileInfoList * nextItem:需要插入的ITEM指针
// 输出参数：BOOL
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
BOOL FileInfoList::InsertNext(FileInfoList * nextItem)
{
if(this->m_filNextItem!=NULL)
{
//当下一项不为空是需要设置下一项的回调指针
this->m_filNextItem->m_filUpItem=nextItem;
}
nextItem->m_filNextItem=this->m_filNextItem;
nextItem->m_filUpItem=this;
this->m_filNextItem=nextItem;
return TRUE;
}
//=====================================================================
// 函 数 名：InsertFront
// 功能描述：在本ITEM之前插入一个ITEM
// 输入参数：FileInfoList * nextItem:需要插入的ITEM指针
// 输出参数：BOOL
// 创建日期：08.09.10
// 修改日期：
// 作 者：alzq
// 附加说明：返回TRUE表示成功在该项前添加ITEM并不影响链表头
// 返回FALSE表示成功添加ITEM但是链表头已经改变
//=====================================================================
BOOL FileInfoList::InsertFront(FileInfoList * nextItem)
{
if(this->m_filUpItem==NULL)
{
//上一项为空时，只设置三项，此时头指针改变为nextItem
nextItem->m_filUpItem=NULL;
nextItem->m_filNextItem=this;
this->m_filUpItem=nextItem;
return FALSE;
}
else
{
//上一项不为空时，需要设置四项
this->m_filUpItem->m_filNextItem=nextItem;
nextItem->m_filUpItem=this->m_filUpItem;
nextItem->m_filNextItem=this;
this->m_filUpItem=nextItem;
return TRUE;
}
}
//=====================================================================
// 函 数 名：DeleteSelf
// 功能描述：删除本项
// 输入参数：bool disposeEnable
// 输出参数：FileInfoList * 返回删除自身后，下一项地址
// 创建日期：08.09.12
// 修改日期：
// 作 者：alzq
// 附加说明：返回TRUE表示成功
// 返回FALSE表示成功添加ITEM但是链表头已经改变
//=====================================================================
FileInfoList * FileInfoList::DeleteSelf(bool disposeEnable)
{
FileInfoList * res=m_filNextItem;
if(m_filUpItem==NULL)
{
if(m_filNextItem!=NULL)
{
m_filNextItem->m_filUpItem=NULL;
}
}
else
{
m_filUpItem->m_filNextItem=m_filNextItem;
if(m_filNextItem!=NULL)
{
m_filNextItem->m_filUpItem=m_filUpItem;
}
}
if(disposeEnable)
{
Dispose();
}
else
{
SetState(0,true,0); //将状态归0
m_bFileEnable=false; //设置文件为无效文件
}
return res;
}
//=====================================================================
// 函 数 名：SetState
// 功能描述：删除本项
// 输入参数：UINT newState:新的状态值
// bool changeAll:是否完全替换状态值
// UINT mask:遮罩
// 输出参数：UINT 返回新的状态
// 创建日期：08.10.07
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
UINT FileInfoList::SetState(UINT newState,bool changeAll,UINT mask)
{
if(changeAll)
{
m_uiState=newState;
}
else
{
//将位置遮罩变量的位置设为0
m_uiState&=~mask;
m_uiState|=(newState & mask);
}
return m_uiState;
}
//=====================================================================
// 函 数 名：GetState
// 功能描述：删除本项
// 输入参数：UINT stateMask:获取状态的遮罩变量
// 输出参数：UINT 返回状态
// 创建日期：08.10.07
// 修改日期：
// 作 者：alzq
// 附加说明：
//=====================================================================
UINT FileInfoList::GetState(UINT stateMask)
{
UINT tmpState=m_uiState & stateMask;
return tmpState;
}
| [
"w.z.y2006@163.com"
] | w.z.y2006@163.com |
966d1200b5cb66a31dc7249132882ad8bb9f7351 | e488b0a72378f25c7c5a1520220ee00aac588c67 | /7/7.2-protos.cpp | fe9e2f18582d4dca6df9bc1d7a10036c2d76f065 | [] | no_license | freedomhust/C-plus-plus-learning | cb7d464030edefb97fa4ab4054716b89936233f5 | 4bca0c6a31fa09a61b48f6d7153da6cce9ee22a5 | refs/heads/master | 2020-03-25T06:06:27.964129 | 2018-08-11T14:12:20 | 2018-08-11T14:12:20 | 143,483,348 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 505 | cpp | #include<iostream>
void cheers(int);
double cube(double x);
int main(void){
using namespace std;
cheers(5);
cout << "Give me a number.\n";
double side;
cin >> side;
double volume = cube(side);
cout << "A " << side << "-foot cube has a volume of ";
cout << volume << " cubic feet.\n";
cheers(cube(2));
return 0;
}
void cheers(int n){
using namespace std;
for(int i = 0; i < n; i++)
cout << "Cheers! ";
cout << endl;
}
double cube(double x){
return x*x*x;
}
| [
"u201614891@hust.edu.cn"
] | u201614891@hust.edu.cn |
d3b769a379929844a1a9822faaab030aa927329d | 6b9aa0d16db111b8c8022bfa60a61d46f87eb559 | /python/payloads/DmaBackdoorHv/backdoor_client/driver_loader_sk/runtime/runtime.cpp | 7fac850855c5be7b060619243c0fecc244d6352e | [] | no_license | EgeBalci/s6_pcie_microblaze | a927f311b422f8052390cb17488018dd0b86cb8a | e05e197623422fe56426a46b4f1727891cf234a1 | refs/heads/master | 2023-04-22T13:54:44.635441 | 2021-05-03T02:07:42 | 2021-05-03T02:07:42 | 364,640,681 | 1 | 0 | null | 2021-05-05T16:30:35 | 2021-05-05T16:30:35 | null | UTF-8 | C++ | false | false | 7,449 | cpp | #include "stdafx.h"
// make crt functions inline
#pragma intrinsic(memcpy, strcpy, strcmp)
#define RtDbgMsg
//--------------------------------------------------------------------------------------
PVOID RuntimeGetModuleBase(char *ModuleName)
{
if (!std_strcmp(ModuleName, "securekernel.exe"))
{
// secure kernel import
return GetKernelBase();
}
// image is not supported
return NULL;
}
//--------------------------------------------------------------------------------------
PVOID RuntimeGetProcAddress(PVOID Image, char *lpszFunctionName)
{
PVOID Ret = NULL;
PIMAGE_NT_HEADERS pHeaders = (PIMAGE_NT_HEADERS)RVATOVA(
Image, ((PIMAGE_DOS_HEADER)Image)->e_lfanew);
ULONG ExportsAddr = pHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
ULONG ExportsSize = pHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;
ULONG FunctionAddr = 0;
ULONG_PTR Ordinal = (ULONG_PTR)lpszFunctionName;
if (ExportsAddr == 0)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__"() ERROR: Export directory is not found\n");
return NULL;
}
PIMAGE_EXPORT_DIRECTORY pImageExportDirectory = (PIMAGE_EXPORT_DIRECTORY)RVATOVA(Image, ExportsAddr);
if (pImageExportDirectory->AddressOfFunctions == 0)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__"() ERROR: Exports not found\n");
return NULL;
}
PULONG AddrOfFunctions = (PULONG)RVATOVA(Image, pImageExportDirectory->AddressOfFunctions);
// check for the export by ordinal
if (Ordinal < RUNTIME_MAX_ORDINAL)
{
if (pImageExportDirectory->Base > Ordinal)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__"() ERROR: Invalid ordinal number\n");
return NULL;
}
Ordinal -= pImageExportDirectory->Base;
if (Ordinal > pImageExportDirectory->NumberOfFunctions - 1)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__"() ERROR: Invalid ordinal number\n");
return NULL;
}
// get export address by ordinal
FunctionAddr = AddrOfFunctions[Ordinal];
}
else if (pImageExportDirectory->AddressOfNames != 0 && pImageExportDirectory->AddressOfNameOrdinals != 0)
{
PSHORT AddrOfOrdinals = (PSHORT)RVATOVA(Image, pImageExportDirectory->AddressOfNameOrdinals);
PULONG AddrOfNames = (PULONG)RVATOVA(Image, pImageExportDirectory->AddressOfNames);
// enumerate export names
for (ULONG i = 0; i < pImageExportDirectory->NumberOfNames; i += 1)
{
char *lpszName = (char *)RVATOVA(Image, AddrOfNames[i]);
if (!strcmp(lpszName, lpszFunctionName))
{
// return export address
FunctionAddr = AddrOfFunctions[AddrOfOrdinals[i]];
break;
}
}
}
if (FunctionAddr == 0)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__"() ERROR: Export is not found\n");
return NULL;
}
Ret = RVATOVA(Image, FunctionAddr);
// check for the forwarded export
if (FunctionAddr > ExportsAddr &&
FunctionAddr < ExportsAddr + ExportsSize)
{
char szModule[IMPORT_MAX_STRING_SIZE], *lpszFunction = NULL;
memset(szModule, 0, sizeof(szModule));
strcpy(szModule, (char *)Ret);
// parse forwarded export string
for (ULONG i = 0; i < IMPORT_MAX_STRING_SIZE; i += 1)
{
if (szModule[i] == '.')
{
// get module and function name
lpszFunction = szModule + i + 1;
szModule[i] = '\0';
break;
}
else if (szModule[i] == '\0')
{
break;
}
}
if (lpszFunction == NULL)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__"() ERROR: Invalid forwarded export\n");
return NULL;
}
PVOID Module = RuntimeGetModuleBase(szModule);
if (Module == NULL)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__"() ERROR: Unknown forwarded export module %s\n", szModule);
return NULL;
}
return RuntimeGetProcAddress(Module, lpszFunction);
}
return Ret;
}
//--------------------------------------------------------------------------------------
BOOLEAN RuntimeProcessImports(PVOID Image)
{
PIMAGE_NT_HEADERS pHeaders = (PIMAGE_NT_HEADERS)RVATOVA(
Image, ((PIMAGE_DOS_HEADER)Image)->e_lfanew);
ULONG ImportAddr = pHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
ULONG ImportSize = pHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size;
if (ImportAddr != 0)
{
PIMAGE_IMPORT_DESCRIPTOR pImport = (PIMAGE_IMPORT_DESCRIPTOR)RVATOVA(Image, ImportAddr);
RtDbgMsg(
__FILE__, __LINE__,
"IMAGE_DIRECTORY_ENTRY_IMPORT: "IFMT"; Size: %d\n", pImport, ImportSize
);
while (pImport->Name != 0)
{
// load import library
char *lpszLibName = (char *)RVATOVA(Image, pImport->Name);
PVOID LibAddr = RuntimeGetModuleBase(lpszLibName);
if (LibAddr == NULL)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__"(): Error while loading \"%s\"\n", lpszLibName);
return FALSE;
}
RtDbgMsg(__FILE__, __LINE__, "LIB "IFMT": \"%s\"\n", LibAddr, lpszLibName);
// process thunks data
PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)RVATOVA(Image, pImport->FirstThunk);
while (pThunk->u1.Ordinal != 0)
{
if (pThunk->u1.Ordinal & 0xf0000000)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__ "() ERROR: Imports by ordianl are not supported\n");
return FALSE;
}
PIMAGE_IMPORT_BY_NAME pName = (PIMAGE_IMPORT_BY_NAME)RVATOVA(Image, pThunk->u1.AddressOfData);
char *lpszFuncName = (char *)&pName->Name;
// lookup function address by name
PVOID FuncAddr = RuntimeGetProcAddress(LibAddr, lpszFuncName);
if (FuncAddr == NULL)
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__"(): Error while importing \"%s\"\n", lpszFuncName);
return FALSE;
}
RtDbgMsg(__FILE__, __LINE__, "PROC "IFMT": \"%s\"\n", FuncAddr, lpszFuncName);
*(PVOID *)pThunk = FuncAddr;
pThunk += 1;
}
pImport += 1;
}
}
else
{
RtDbgMsg(__FILE__, __LINE__, __FUNCTION__ "() WARNING: Import directory not found\n");
}
return TRUE;
}
//--------------------------------------------------------------------------------------
// EoF
| [
"cr4sh0@gmail.com"
] | cr4sh0@gmail.com |
9848def83d055502091e8bace5ce35f459577719 | 5fb9b06a4bf002fc851502717a020362b7d9d042 | /developertools/GumpEditor/entity/GumpPicturePropertyPage.cpp | 742dbd5e665b71b33a20eadbe2c4ac2c1de5ca7d | [] | no_license | bravesoftdz/iris-svn | 8f30b28773cf55ecf8951b982370854536d78870 | c03438fcf59d9c788f6cb66b6cb9cf7235fbcbd4 | refs/heads/master | 2021-12-05T18:32:54.525624 | 2006-08-21T13:10:54 | 2006-08-21T13:10:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,623 | cpp | #include "stdafx.h"
#include "GumpEditor.h"
#include "GumpPicturePropertyPage.h"
#include "GumpPicture.h"
#include "GumpEditorDoc.h"
IMPLEMENT_DYNAMIC(CGumpPicturePropertyPage, CDiagramPropertyPage)
CGumpPicturePropertyPage::CGumpPicturePropertyPage()
: CDiagramPropertyPage(CGumpPicturePropertyPage::IDD)
, m_strGumpID("0")
, m_iType(0)
{
}
CGumpPicturePropertyPage::~CGumpPicturePropertyPage()
{
}
void CGumpPicturePropertyPage::DoDataExchange(CDataExchange* pDX)
{
CDiagramPropertyPage::DoDataExchange(pDX);
DDX_Control(pDX, IDC_COLOR, m_btnColor);
DDX_Text(pDX, IDC_GUMP_ID, m_strGumpID);
DDX_Control(pDX, IDC_GUMP_SPIN, m_spinGump);
DDX_CBIndex(pDX, IDC_TYPE_COMBO, m_iType);
}
BEGIN_MESSAGE_MAP(CGumpPicturePropertyPage, CDiagramPropertyPage)
ON_CBN_SELCHANGE(IDC_TYPE_COMBO, OnCbnSelchangeTypeCombo)
END_MESSAGE_MAP()
BOOL CGumpPicturePropertyPage::OnInitDialog()
{
CDiagramPropertyPage::OnInitDialog();
m_spinGump.SetRange32(0,0xffff);
return TRUE;
}
void CGumpPicturePropertyPage::SetValues()
{
if( GetSafeHwnd() && GetEntity())
{
CGumpPicture* pPicture = dynamic_cast<CGumpPicture*>(GetEntity());
if (!pPicture) return;
m_strGumpID = GfxXtoA(pPicture->GetGumpID());
m_iType = pPicture->GetPictureType();
m_btnColor.SetHueId(pPicture->GetHueId());
UpdateData(FALSE);
}
}
void CGumpPicturePropertyPage::ApplyValues()
{
if (GetSafeHwnd() && GetEntity())
{
UpdateData();
CGumpPicture* pPicture = dynamic_cast<CGumpPicture*>(GetEntity());
if (!pPicture) return;
bool bRedraw = false;
int iGumpID = GfxAtoX(m_strGumpID);
DWORD hueId = m_btnColor.GetHueId();
if (pPicture->GetGumpID() != iGumpID)
{
ASSERT(GfxGetGumpDocument());
CGumpPtr pGump = GfxGetGumpDocument()->GetGump(iGumpID);
if (!pGump) return;
pPicture->SetGump(pGump);
bRedraw = CGumpPicture::GUMP == m_iType;
}
if (pPicture->GetPictureType() != m_iType)
{
pPicture->SetPictureType((CGumpPicture::TYPE)m_iType);
bRedraw = CGumpPicture::GUMP != m_iType;
}
if (pPicture->GetHueId() != hueId && m_iType)
{
pPicture->SetHueId(hueId);
bRedraw = CGumpPicture::GUMP != m_iType;
}
if (bRedraw) Redraw();
}
}
void CGumpPicturePropertyPage::ResetValues()
{
if (GetSafeHwnd() && GetEntity())
{
UpdateData();
CGumpPicture* pPicture = dynamic_cast<CGumpPicture*>(GetEntity());
if (!pPicture) return;
pPicture->SetGump(pPicture->GetGump());
Redraw();
}
}
void CGumpPicturePropertyPage::OnCbnSelchangeTypeCombo()
{
}
| [
"sience@a725d9c3-d2eb-0310-b856-fa980ef11a19"
] | sience@a725d9c3-d2eb-0310-b856-fa980ef11a19 |
14a7e5dad9f7f25d3fa9633f5de0345da27674da | 8f92eb73fc84d1477e00fe9c7fb811410c77ddc3 | /Code/WriteBack.cpp | 7a59072a1d8f8df705f40786e9892760d931c6f6 | [] | no_license | MerinS/PipelinedMIPS | b8f6a4cb62d7883830da10ac4aed49af96d07d7c | 89f6d1103ed1fcdda008914d0900f5b663eaeea0 | refs/heads/master | 2021-08-15T01:35:17.114275 | 2017-11-17T04:37:39 | 2017-11-17T04:37:39 | 111,055,861 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 920 | cpp | /*
* WriteBack.cpp
*
* Created on: Nov 14, 2017
* Author: merinsan
*/
#include "WriteBack.h"
void WriteBack::eval(IssueUnit::Operation_details var){
if( var.type == 12){
this -> setRegistersBack(var);
}
else{
RegisterController::R[var.rdes].value = var.val;
this -> setRegistersBack(var);
}
return;
}
void WriteBack::setRegistersBack(IssueUnit::Operation_details buff){
if(buff.rdes != -1){
RegisterController::R[buff.rdes].writestatus = false;
}
if(buff.rs1 != -1){
RegisterController::R[buff.rs1].readstatus = false;
}
if(buff.rs2 != -1){
RegisterController::R[buff.rs2].readstatus = false;
}
return;
}
void WriteBack::WriteBackMem(){
var1 = MemUnit::postMEMbuffer.front();
this -> eval(var1);
MemUnit::postMEMbuffer.pop();
return;
}
void WriteBack::WriteBackALU2(){
var1 = ALU2Unit::postALU2buffer.front();
this -> eval(var1);
ALU2Unit::postALU2buffer.pop();
return;
}
| [
"merinsan@Merins-MacBook-Pro.local"
] | merinsan@Merins-MacBook-Pro.local |
4ce290b1073ba7e4b96900239e552b6623d7f01d | 091ca8b505b277c9cb3cc228eb25836438b6b4bf | /aesxx/include/aesxx/aes.hpp | efac790aa01638b645e39fff309038ec81d66d51 | [
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | egor-tensin/aes-tools | cc8dc6e0a0ab879c319c55d8413b4fddf2d90325 | 4bcbf7dbadb234657c6853c26e113184c74eb0a2 | refs/heads/master | 2023-07-07T18:25:29.395994 | 2023-07-04T07:00:37 | 2023-07-04T07:00:37 | 36,039,229 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,532 | hpp | // Copyright (c) 2015 Egor Tensin <Egor.Tensin@gmail.com>
// This file is part of the "AES tools" project.
// For details, see https://github.com/egor-tensin/aes-tools.
// Distributed under the MIT License.
#pragma once
#include "algorithm.hpp"
#include "api.hpp"
#include "error.hpp"
#include "mode.hpp"
#include <aes/all.h>
#include <cstddef>
#include <string>
namespace aes
{
namespace aes128
{
typedef AES_AES128_Block Block;
typedef AES_AES128_RoundKeys RoundKeys;
typedef AES_AES128_Key Key;
}
template <>
struct Types<AES_AES128>
{
typedef aes128::Block Block;
typedef aes128::RoundKeys RoundKeys;
typedef aes128::Key Key;
};
template <>
inline std::size_t get_number_of_rounds<AES_AES128>()
{
return 11;
}
template <>
inline void from_string<AES_AES128>(aes128::Block& dest, const char* src)
{
aes_AES128_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{});
}
template <>
inline std::string to_string<AES_AES128>(const aes128::Block& src)
{
AES_AES128_BlockString str;
aes_AES128_format_block(&str, &src, ErrorDetailsThrowsInDestructor{});
return {str.str};
}
template <>
inline std::string to_matrix_string<AES_AES128>(const aes128::Block& src)
{
AES_AES128_BlockMatrixString str;
aes_AES128_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{});
return {str.str};
}
template <>
inline void from_string<AES_AES128>(aes128::Key& dest, const char* src)
{
aes_AES128_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{});
}
template <>
inline std::string to_string<AES_AES128>(const aes128::Key& src)
{
AES_AES128_KeyString str;
aes_AES128_format_key(&str, &src, ErrorDetailsThrowsInDestructor{});
return {str.str};
}
template <>
inline void expand_key<AES_AES128>(
const aes128::Key& key,
aes128::RoundKeys& encryption_keys)
{
aes_AES128_expand_key(&key, &encryption_keys);
}
template <>
inline void derive_decryption_keys<AES_AES128>(
const aes128::RoundKeys& encryption_keys,
aes128::RoundKeys& decryption_keys)
{
aes_AES128_derive_decryption_keys(
&encryption_keys, &decryption_keys);
}
AESXX_ENCRYPT_BLOCK_ECB(AES128);
AESXX_DECRYPT_BLOCK_ECB(AES128);
AESXX_ENCRYPT_BLOCK_CBC(AES128);
AESXX_DECRYPT_BLOCK_CBC(AES128);
AESXX_ENCRYPT_BLOCK_CFB(AES128);
AESXX_DECRYPT_BLOCK_CFB(AES128);
AESXX_ENCRYPT_BLOCK_OFB(AES128);
AESXX_DECRYPT_BLOCK_OFB(AES128);
AESXX_ENCRYPT_BLOCK_CTR(AES128);
AESXX_DECRYPT_BLOCK_CTR(AES128);
namespace aes192
{
typedef AES_AES192_Block Block;
typedef AES_AES192_RoundKeys RoundKeys;
typedef AES_AES192_Key Key;
}
template <>
struct Types<AES_AES192>
{
typedef aes192::Block Block;
typedef aes192::RoundKeys RoundKeys;
typedef aes192::Key Key;
};
template <>
inline std::size_t get_number_of_rounds<AES_AES192>()
{
return 13;
}
template <>
inline void from_string<AES_AES192>(aes192::Block& dest, const char* src)
{
aes_AES192_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{});
}
template <>
inline std::string to_string<AES_AES192>(const aes192::Block& src)
{
AES_AES192_BlockString str;
aes_AES192_format_block(&str, &src, ErrorDetailsThrowsInDestructor{});
return {str.str};
}
template <>
inline std::string to_matrix_string<AES_AES192>(const aes192::Block& src)
{
AES_AES192_BlockMatrixString str;
aes_AES192_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{});
return {str.str};
}
template <>
inline void from_string<AES_AES192>(aes192::Key& dest, const char* src)
{
aes_AES192_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{});
}
template <>
inline std::string to_string<AES_AES192>(const aes192::Key& src)
{
AES_AES192_KeyString str;
aes_AES192_format_key(&str, &src, ErrorDetailsThrowsInDestructor{});
return {str.str};
}
template <>
inline void expand_key<AES_AES192>(
const aes192::Key& key,
aes192::RoundKeys& encryption_keys)
{
aes_AES192_expand_key(&key, &encryption_keys);
}
template <>
inline void derive_decryption_keys<AES_AES192>(
const aes192::RoundKeys& encryption_keys,
aes192::RoundKeys& decryption_keys)
{
aes_AES192_derive_decryption_keys(
&encryption_keys, &decryption_keys);
}
AESXX_ENCRYPT_BLOCK_ECB(AES192);
AESXX_DECRYPT_BLOCK_ECB(AES192);
AESXX_ENCRYPT_BLOCK_CBC(AES192);
AESXX_DECRYPT_BLOCK_CBC(AES192);
AESXX_ENCRYPT_BLOCK_CFB(AES192);
AESXX_DECRYPT_BLOCK_CFB(AES192);
AESXX_ENCRYPT_BLOCK_OFB(AES192);
AESXX_DECRYPT_BLOCK_OFB(AES192);
AESXX_ENCRYPT_BLOCK_CTR(AES192);
AESXX_DECRYPT_BLOCK_CTR(AES192);
namespace aes256
{
typedef AES_AES256_Block Block;
typedef AES_AES256_RoundKeys RoundKeys;
typedef AES_AES256_Key Key;
}
template <>
struct Types<AES_AES256>
{
typedef aes256::Block Block;
typedef aes256::RoundKeys RoundKeys;
typedef aes256::Key Key;
};
template <>
inline std::size_t get_number_of_rounds<AES_AES256>()
{
return 15;
}
template <>
inline void from_string<AES_AES256>(aes256::Block& dest, const char* src)
{
aes_AES256_parse_block(&dest, src, ErrorDetailsThrowsInDestructor{});
}
template <>
inline std::string to_string<AES_AES256>(const aes256::Block& src)
{
AES_AES256_BlockString str;
aes_AES256_format_block(&str, &src, ErrorDetailsThrowsInDestructor{});
return {str.str};
}
template <>
inline std::string to_matrix_string<AES_AES256>(const aes256::Block& src)
{
AES_AES256_BlockMatrixString str;
aes_AES256_format_block_as_matrix(&str, &src, ErrorDetailsThrowsInDestructor{});
return {str.str};
}
template <>
inline void from_string<AES_AES256>(aes256::Key& dest, const char* src)
{
aes_AES256_parse_key(&dest, src, ErrorDetailsThrowsInDestructor{});
}
template <>
inline std::string to_string<AES_AES256>(const aes256::Key& src)
{
AES_AES256_KeyString str;
aes_AES256_format_key(&str, &src, ErrorDetailsThrowsInDestructor{});
return {str.str};
}
template <>
inline void expand_key<AES_AES256>(
const aes256::Key& key,
aes256::RoundKeys& encryption_keys)
{
aes_AES256_expand_key(&key, &encryption_keys);
}
template <>
inline void derive_decryption_keys<AES_AES256>(
const aes256::RoundKeys& encryption_keys,
aes256::RoundKeys& decryption_keys)
{
aes_AES256_derive_decryption_keys(
&encryption_keys, &decryption_keys);
}
AESXX_ENCRYPT_BLOCK_ECB(AES256);
AESXX_DECRYPT_BLOCK_ECB(AES256);
AESXX_ENCRYPT_BLOCK_CBC(AES256);
AESXX_DECRYPT_BLOCK_CBC(AES256);
AESXX_ENCRYPT_BLOCK_CFB(AES256);
AESXX_DECRYPT_BLOCK_CFB(AES256);
AESXX_ENCRYPT_BLOCK_OFB(AES256);
AESXX_DECRYPT_BLOCK_OFB(AES256);
AESXX_ENCRYPT_BLOCK_CTR(AES256);
AESXX_DECRYPT_BLOCK_CTR(AES256);
}
| [
"Egor.Tensin@gmail.com"
] | Egor.Tensin@gmail.com |
75f95519c75e4b95f30b30dfe1349f213ec5f17b | d3c00fc00ed3d4311ee4bb8714acddd14675ad6c | /LoginDlg.h | 8462b2d6626bcd87306c86d3c611476d49a2c4e0 | [] | no_license | lijinfeng0713/chart | defcbc6141bf25fa938b73be557c887b0754811a | 81df7b7aca492f014b2da6ff5730c42d612dc4f1 | refs/heads/master | 2021-05-30T01:42:31.223163 | 2015-11-23T05:17:32 | 2015-11-23T05:17:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,343 | h | #if !defined(AFX_LOGINDLG_H__3A314ED2_A09D_413A_B695_35D12C498C96__INCLUDED_)
#define AFX_LOGINDLG_H__3A314ED2_A09D_413A_B695_35D12C498C96__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// LoginDlg.h : header file
//
/////////////////////////////////////////////////////////////////////////////
// CLoginDlg dialog
struct User{
CString username;
CString password;
};
class CLoginDlg : public CDialog
{
// Construction
public:
CLoginDlg(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CLoginDlg)
enum { IDD = IDD_DIALOG1 };
CButton m_login;
CButton m_register;
CEdit m_username1;
CEdit m_password;
//}}AFX_DATA
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CLoginDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CLoginDlg)
virtual BOOL OnInitDialog();
afx_msg void OnRegister();
afx_msg void OnLogin();
afx_msg BOOL PreTranslateMessage(MSG* pMsg);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_LOGINDLG_H__3A314ED2_A09D_413A_B695_35D12C498C96__INCLUDED_)
| [
"1063810293@qq.com"
] | 1063810293@qq.com |
e3eeef2d785cada70ce0ee8edf1518623506f91c | 65be1edccb24fb3fdd5fae8856ed71b4051ed51c | /Sorting Algorithms/!DS Lab - Sorting Techniques.cpp | 45a9101ac4c42351d379ddcde5cec5347079e2b9 | [] | no_license | Akash-Macha/C-Programs | 1b0b4106b60c1ecc1f48691be57cbd4911ec1e92 | 73105d9f05f4bd7b5eeb1dc160934e1fa920b8ef | refs/heads/master | 2020-03-18T21:39:50.096442 | 2018-08-07T16:41:10 | 2018-08-07T16:41:10 | 135,293,528 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,045 | cpp | /*
Linear Search Using function template
Binary Search
Insertion Sort in ascending
Selection Sort template in decending
Quick Sort template in ascending
Merge Sort ascending
*/
#include<iostream>
#include<algorithm>
using namespace std;
template<class t>
void print(t *A,int n)
{
cout << "After sorting:" << endl;
for(int i=0;i<n;i++)
cout << A[i] << " ";
}
void Merge(int *A,int low,int mid,int high)
{
int nL = mid - low + 1;
int nR = high - mid;
int Left[nL] , Right[nR];
for(int i=0;i<nL;i++)
Left[i] = A[low + i];
for(int j=0;j<nR;j++)
Right[j] = A[j + mid + 1];
int i=0;
int j=0;
int k=low;
while(i < nL && j < nR)
{
if(Left[i] < Right[j])
{
A[k] = Left[i];
++i;
}else{
A[k] = Right[j];
++j;
}
++k;
}
while(i < nL)
{
A[k] = Left[i];
++i;
++k;
}
while(j < nR)
{
A[k] = Right[j];
++j;
++k;
}
}
void Merge_Sort(int *A,int low, int high)
{
if(low < high)
{
int mid = (low+high)/2;
Merge_Sort(A,low,mid);
Merge_Sort(A,mid+1,high);
Merge(A,low,mid,high);
}
}
void MergeSort()
{
//Ascending order
cout << "--MergeSort--" << endl;
cout << "Enter how many elements : ";
int n;
cin >> n;
cout << "Enter " << n << " elements :\n";
int a[n];
for(int i=0;i<n;i++)
cin >> a[i];
Merge_Sort(a,0,n-1);
print<int>(a,n);
}
template<class t>
int partition(t *A,int low, int high)
{
t pivote = A[high];
int i = low-1; // index of smaller element
int j;
for(j=low;j<=high-1;j++)
{
if( A[j] <= pivote )
{
++i;
swap(A[i],A[j]);
}
}
swap( A[i+1] , A[high] );
return (i+1);
}
template<class t>
int Quick_Sort(t *A,int low, int high)
{
if(low < high)
{
int pivote = partition<int>(A,low,high);
Quick_Sort<int>(A,low,pivote-1);
Quick_Sort<int>(A,pivote+1,high);
}
}
void QuickSort()
{
cout << "--QuickSort--" << endl;
cout << "Enter how many elements : ";
int n;
cin >> n;
//the type of data matters HERE!
int a[n];
cout << "Enter " << n << " elements:\n";
for(int i=0;i<n;i++)
cin >> a[i];
//QuickSort pivote - a[high] = pivote
Quick_Sort<int>(a,0,n-1);
print(a,n);
}
template<class t>
void SelectionSort()
{
cout << "--SelectionSort using template class--" << endl;
cout << "Enter how many elements : ";
int n;
cin >> n;
t a[n];
cout << "Enter " << n << " elements :\n";
for(int i=0;i<n;i++)
cin >> a[i];
//updating the current minimum
for(int i=0;i<n-1;i++)
{
int min = i;
for(int j=i+1; j < n ; j++)
{
if(a[j] < a[min]){
min = j;
}
}
swap(a[i],a[min]);
}
print<float>(a,n);
}
void InsertionSort()
{
cout << "--InsertionSort--" << endl;
cout << "Enter how many elements : ";
int n;
cin >> n;
int a[n];
cout << "Enter " << n << " elemtns :\n";
for(int i=0;i<n;i++)
cin >> a[i];
//Insertion sort -- ascending
int temp,position;
for(int i=1;i<n;i++)
{
position = i;
temp = a[i];
while(position > 0 && a[position-1] > temp){
a[position] = a[position-1];
--position;
}
a[position] = temp;
}
print<int>(a,n);
}
void BinarySearch()
{
cout << "-- BinarySearch --" << endl;
cout << "Enter how many elements : ";
int n;
cin >> n;
int a[n];
cout << "Enter " << n << " elements :\n";
for(int i=0;i<n;i++)
cin >> a[i];
cout << "Enter key element : ";
int key;
cin >> key;
int low=0,high=n-1, mid;
int flag=0;
while(low <= high)
{
mid = (low+high)/2;
if(key == a[mid]){
flag=1;
break;
}
else if(key < a[mid])
{
high = mid - 1;
}else if(key > a[mid]){
low = mid + 1;
}
}
if(flag == 1)
cout << "Key element found at " << mid << " index" << endl;
else
cout << "Key element not found" << endl;
}
void LinearSearch()
{
cout << "-- LinearSearch --" << endl;
cout << "Enter how many numbers : ";
int n;
cin >> n;
int a[n];
cout << "Enter " << n << " elements :\n";
for(int i =0;i<n;i++)
cin >> a[i];
int key;
cout << "Enter key element : ";
cin >> key;
int i,pos;
for(i=0;i<n;i++){
if(key == a[i]){
break;
}
}
cout << "Element found at " << i << " index";
}
int main(){
cout << "---All searching Technics!---\n" << endl;
cout << "1. Linear Search using template function" << endl;
cout << "2. Binary Search using template function" << endl;
cout << "3. Insertion Sort in ascending order" << endl;
cout << "4. Selection Sort using template function" << endl;
cout << "5. Quick Sort using template function" << endl;
cout << "6. Merge Sort in ascending order" << endl;
int choice;
cin >> choice;
switch(choice){
case 1 : LinearSearch();
break;
case 2 : BinarySearch();
break;
case 3 : InsertionSort();
break;
case 4 : SelectionSort<float>();
break;
case 5 : QuickSort();
break;
case 6 : MergeSort();
break;
default: cout << "Wrong choice!" << endl;
}
} | [
"noreply@github.com"
] | Akash-Macha.noreply@github.com |
c28241954888036407cb356acaed5282437acb89 | 61d346406ff1f1cbf60e67f9d868dabdf901e574 | /Code/BehaviorBase.cpp | 3c24e7f06873a0140d7e4d4ecef607224190116e | [] | no_license | kentones/KtLibWin32 | 46ced841e32b03e972ea8e7d37b5e23adc4a0174 | 8247dc4d0f89fb88f155f3f365f7d9cfaae19ed5 | refs/heads/master | 2021-08-22T19:47:37.182532 | 2017-12-01T04:07:42 | 2017-12-01T04:07:42 | 109,515,006 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 58 | cpp | #include "pch.h"
namespace KtLib
{
} //namespace KtLib | [
"kentones@fastmail.com"
] | kentones@fastmail.com |
32da3a2c4f931611e4cc5bdb620883c874abcb30 | b3c4c6b496721fe0cd674f3b01b4dbc8c27ab9b6 | /video3/App/Il2CppOutputProject/Source/il2cppOutput/Il2CppCompilerCalculateTypeValues_7Table.cpp | d8ade1eb8ca08c6288b34b7d53ffc2399eefdc01 | [] | no_license | Anhtuan1/stream_hololens | 399080a7a3d6fa8e34f2809eb0087a703d3a547a | 240622602aa423d4cdd0e8bac6f6b2f2d260ac3c | refs/heads/master | 2020-03-10T04:53:17.871539 | 2018-04-12T06:56:04 | 2018-04-12T06:56:04 | 129,203,825 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 235,434 | 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"
// System.Collections.Generic.List`1<System.Reflection.MethodInfo>
struct List_1_t3349700990;
// System.String
struct String_t;
// System.Collections.Generic.IList`1<System.Object>
struct IList_1_t600458651;
// System.Runtime.Serialization.SerializationInfo
struct SerializationInfo_t950877179;
// System.RuntimeType
struct RuntimeType_t3636489352;
// System.EventHandler`1<System.Runtime.Serialization.SafeSerializationEventArgs>
struct EventHandler_1_t2246946069;
// System.Collections.Hashtable
struct Hashtable_t1853889766;
// System.Security.Cryptography.KeySizes[]
struct KeySizesU5BU5D_t722666473;
// System.Runtime.Serialization.ObjectHolderList
struct ObjectHolderList_t2007846727;
// System.Security.Cryptography.X509Certificates.INativeCertificateHelper
struct INativeCertificateHelper_t1667236488;
// System.Runtime.Serialization.ISerializationSurrogate
struct ISerializationSurrogate_t2624761601;
// System.Runtime.Serialization.FixupHolderList
struct FixupHolderList_t3799028159;
// System.Runtime.Serialization.LongList
struct LongList_t2258305620;
// System.Runtime.Serialization.ValueTypeFixupInfo
struct ValueTypeFixupInfo_t1444618334;
// System.Runtime.Serialization.TypeLoadExceptionHolder
struct TypeLoadExceptionHolder_t2983813904;
// System.Int64[]
struct Int64U5BU5D_t2559172825;
// System.Object[]
struct ObjectU5BU5D_t2843939325;
// System.Int32[]
struct Int32U5BU5D_t385246372;
// System.Byte[]
struct ByteU5BU5D_t4116647657;
// System.Runtime.Serialization.ObjectHolder[]
struct ObjectHolderU5BU5D_t663564126;
// System.Runtime.Serialization.FixupHolder[]
struct FixupHolderU5BU5D_t415823611;
// System.Security.Cryptography.X509Certificates.X509CertificateImpl
struct X509CertificateImpl_t2851385038;
// System.Security.Cryptography.RNGCryptoServiceProvider
struct RNGCryptoServiceProvider_t3397414743;
// System.Runtime.Remoting.ServerIdentity
struct ServerIdentity_t2342208608;
// System.Func`1<System.Security.Cryptography.HashAlgorithm>
struct Func_1_t862063866;
// System.Security.Cryptography.DSA
struct DSA_t2386879874;
// System.Void
struct Void_t1185182177;
// Mono.Security.X509.X509Certificate
struct X509Certificate_t489243024;
// System.Char[]
struct CharU5BU5D_t3528271667;
// System.IO.Stream/ReadWriteTask
struct ReadWriteTask_t156472862;
// System.Threading.SemaphoreSlim
struct SemaphoreSlim_t2974092902;
// System.Collections.Generic.Dictionary`2<System.Runtime.Serialization.MemberHolder,System.Reflection.MemberInfo[]>
struct Dictionary_2_t3564581838;
// System.Type[]
struct TypeU5BU5D_t3940880105;
// System.Reflection.Binder
struct Binder_t2999457153;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// System.DelegateData
struct DelegateData_t1677132599;
// System.UInt32[]
struct UInt32U5BU5D_t2770800703;
// System.UInt64[]
struct UInt64U5BU5D_t1659327989;
// System.Security.Cryptography.ICryptoTransform
struct ICryptoTransform_t2733259762;
// System.Security.Cryptography.CryptoStream
struct CryptoStream_t2702504504;
// System.Security.Cryptography.TailStream
struct TailStream_t1447577651;
// System.Security.Cryptography.TripleDES
struct TripleDES_t92303514;
// System.Security.Cryptography.RSA
struct RSA_t2385438082;
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t386037858;
// System.Security.Cryptography.HashAlgorithm
struct HashAlgorithm_t1432317219;
// System.Delegate[]
struct DelegateU5BU5D_t1703627840;
// System.Collections.Generic.List`1<System.Object>
struct List_1_t257213610;
// System.Runtime.Serialization.DeserializationEventHandler
struct DeserializationEventHandler_t1473997819;
// System.Runtime.Serialization.SerializationEventHandler
struct SerializationEventHandler_t2446424469;
// System.Runtime.Serialization.ISurrogateSelector
struct ISurrogateSelector_t3040401154;
// System.IAsyncResult
struct IAsyncResult_t767004451;
// System.AsyncCallback
struct AsyncCallback_t3962456242;
// System.Type
struct Type_t;
#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 SERIALIZATIONBINDER_T274213469_H
#define SERIALIZATIONBINDER_T274213469_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.SerializationBinder
struct SerializationBinder_t274213469 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SERIALIZATIONBINDER_T274213469_H
#ifndef SERIALIZATIONEVENTS_T3591775508_H
#define SERIALIZATIONEVENTS_T3591775508_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.SerializationEvents
struct SerializationEvents_t3591775508 : public RuntimeObject
{
public:
// System.Collections.Generic.List`1<System.Reflection.MethodInfo> System.Runtime.Serialization.SerializationEvents::m_OnSerializingMethods
List_1_t3349700990 * ___m_OnSerializingMethods_0;
// System.Collections.Generic.List`1<System.Reflection.MethodInfo> System.Runtime.Serialization.SerializationEvents::m_OnSerializedMethods
List_1_t3349700990 * ___m_OnSerializedMethods_1;
// System.Collections.Generic.List`1<System.Reflection.MethodInfo> System.Runtime.Serialization.SerializationEvents::m_OnDeserializingMethods
List_1_t3349700990 * ___m_OnDeserializingMethods_2;
// System.Collections.Generic.List`1<System.Reflection.MethodInfo> System.Runtime.Serialization.SerializationEvents::m_OnDeserializedMethods
List_1_t3349700990 * ___m_OnDeserializedMethods_3;
public:
inline static int32_t get_offset_of_m_OnSerializingMethods_0() { return static_cast<int32_t>(offsetof(SerializationEvents_t3591775508, ___m_OnSerializingMethods_0)); }
inline List_1_t3349700990 * get_m_OnSerializingMethods_0() const { return ___m_OnSerializingMethods_0; }
inline List_1_t3349700990 ** get_address_of_m_OnSerializingMethods_0() { return &___m_OnSerializingMethods_0; }
inline void set_m_OnSerializingMethods_0(List_1_t3349700990 * value)
{
___m_OnSerializingMethods_0 = value;
Il2CppCodeGenWriteBarrier((&___m_OnSerializingMethods_0), value);
}
inline static int32_t get_offset_of_m_OnSerializedMethods_1() { return static_cast<int32_t>(offsetof(SerializationEvents_t3591775508, ___m_OnSerializedMethods_1)); }
inline List_1_t3349700990 * get_m_OnSerializedMethods_1() const { return ___m_OnSerializedMethods_1; }
inline List_1_t3349700990 ** get_address_of_m_OnSerializedMethods_1() { return &___m_OnSerializedMethods_1; }
inline void set_m_OnSerializedMethods_1(List_1_t3349700990 * value)
{
___m_OnSerializedMethods_1 = value;
Il2CppCodeGenWriteBarrier((&___m_OnSerializedMethods_1), value);
}
inline static int32_t get_offset_of_m_OnDeserializingMethods_2() { return static_cast<int32_t>(offsetof(SerializationEvents_t3591775508, ___m_OnDeserializingMethods_2)); }
inline List_1_t3349700990 * get_m_OnDeserializingMethods_2() const { return ___m_OnDeserializingMethods_2; }
inline List_1_t3349700990 ** get_address_of_m_OnDeserializingMethods_2() { return &___m_OnDeserializingMethods_2; }
inline void set_m_OnDeserializingMethods_2(List_1_t3349700990 * value)
{
___m_OnDeserializingMethods_2 = value;
Il2CppCodeGenWriteBarrier((&___m_OnDeserializingMethods_2), value);
}
inline static int32_t get_offset_of_m_OnDeserializedMethods_3() { return static_cast<int32_t>(offsetof(SerializationEvents_t3591775508, ___m_OnDeserializedMethods_3)); }
inline List_1_t3349700990 * get_m_OnDeserializedMethods_3() const { return ___m_OnDeserializedMethods_3; }
inline List_1_t3349700990 ** get_address_of_m_OnDeserializedMethods_3() { return &___m_OnDeserializedMethods_3; }
inline void set_m_OnDeserializedMethods_3(List_1_t3349700990 * value)
{
___m_OnDeserializedMethods_3 = value;
Il2CppCodeGenWriteBarrier((&___m_OnDeserializedMethods_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SERIALIZATIONEVENTS_T3591775508_H
#ifndef SIGNATUREDESCRIPTION_T1971889425_H
#define SIGNATUREDESCRIPTION_T1971889425_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SignatureDescription
struct SignatureDescription_t1971889425 : public RuntimeObject
{
public:
// System.String System.Security.Cryptography.SignatureDescription::_strKey
String_t* ____strKey_0;
// System.String System.Security.Cryptography.SignatureDescription::_strDigest
String_t* ____strDigest_1;
// System.String System.Security.Cryptography.SignatureDescription::_strFormatter
String_t* ____strFormatter_2;
// System.String System.Security.Cryptography.SignatureDescription::_strDeformatter
String_t* ____strDeformatter_3;
public:
inline static int32_t get_offset_of__strKey_0() { return static_cast<int32_t>(offsetof(SignatureDescription_t1971889425, ____strKey_0)); }
inline String_t* get__strKey_0() const { return ____strKey_0; }
inline String_t** get_address_of__strKey_0() { return &____strKey_0; }
inline void set__strKey_0(String_t* value)
{
____strKey_0 = value;
Il2CppCodeGenWriteBarrier((&____strKey_0), value);
}
inline static int32_t get_offset_of__strDigest_1() { return static_cast<int32_t>(offsetof(SignatureDescription_t1971889425, ____strDigest_1)); }
inline String_t* get__strDigest_1() const { return ____strDigest_1; }
inline String_t** get_address_of__strDigest_1() { return &____strDigest_1; }
inline void set__strDigest_1(String_t* value)
{
____strDigest_1 = value;
Il2CppCodeGenWriteBarrier((&____strDigest_1), value);
}
inline static int32_t get_offset_of__strFormatter_2() { return static_cast<int32_t>(offsetof(SignatureDescription_t1971889425, ____strFormatter_2)); }
inline String_t* get__strFormatter_2() const { return ____strFormatter_2; }
inline String_t** get_address_of__strFormatter_2() { return &____strFormatter_2; }
inline void set__strFormatter_2(String_t* value)
{
____strFormatter_2 = value;
Il2CppCodeGenWriteBarrier((&____strFormatter_2), value);
}
inline static int32_t get_offset_of__strDeformatter_3() { return static_cast<int32_t>(offsetof(SignatureDescription_t1971889425, ____strDeformatter_3)); }
inline String_t* get__strDeformatter_3() const { return ____strDeformatter_3; }
inline String_t** get_address_of__strDeformatter_3() { return &____strDeformatter_3; }
inline void set__strDeformatter_3(String_t* value)
{
____strDeformatter_3 = value;
Il2CppCodeGenWriteBarrier((&____strDeformatter_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SIGNATUREDESCRIPTION_T1971889425_H
#ifndef TYPELOADEXCEPTIONHOLDER_T2983813904_H
#define TYPELOADEXCEPTIONHOLDER_T2983813904_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.TypeLoadExceptionHolder
struct TypeLoadExceptionHolder_t2983813904 : public RuntimeObject
{
public:
// System.String System.Runtime.Serialization.TypeLoadExceptionHolder::m_typeName
String_t* ___m_typeName_0;
public:
inline static int32_t get_offset_of_m_typeName_0() { return static_cast<int32_t>(offsetof(TypeLoadExceptionHolder_t2983813904, ___m_typeName_0)); }
inline String_t* get_m_typeName_0() const { return ___m_typeName_0; }
inline String_t** get_address_of_m_typeName_0() { return &___m_typeName_0; }
inline void set_m_typeName_0(String_t* value)
{
___m_typeName_0 = value;
Il2CppCodeGenWriteBarrier((&___m_typeName_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TYPELOADEXCEPTIONHOLDER_T2983813904_H
#ifndef SAFESERIALIZATIONMANAGER_T2481557153_H
#define SAFESERIALIZATIONMANAGER_T2481557153_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.SafeSerializationManager
struct SafeSerializationManager_t2481557153 : public RuntimeObject
{
public:
// System.Collections.Generic.IList`1<System.Object> System.Runtime.Serialization.SafeSerializationManager::m_serializedStates
RuntimeObject* ___m_serializedStates_0;
// System.Runtime.Serialization.SerializationInfo System.Runtime.Serialization.SafeSerializationManager::m_savedSerializationInfo
SerializationInfo_t950877179 * ___m_savedSerializationInfo_1;
// System.Object System.Runtime.Serialization.SafeSerializationManager::m_realObject
RuntimeObject * ___m_realObject_2;
// System.RuntimeType System.Runtime.Serialization.SafeSerializationManager::m_realType
RuntimeType_t3636489352 * ___m_realType_3;
// System.EventHandler`1<System.Runtime.Serialization.SafeSerializationEventArgs> System.Runtime.Serialization.SafeSerializationManager::SerializeObjectState
EventHandler_1_t2246946069 * ___SerializeObjectState_4;
public:
inline static int32_t get_offset_of_m_serializedStates_0() { return static_cast<int32_t>(offsetof(SafeSerializationManager_t2481557153, ___m_serializedStates_0)); }
inline RuntimeObject* get_m_serializedStates_0() const { return ___m_serializedStates_0; }
inline RuntimeObject** get_address_of_m_serializedStates_0() { return &___m_serializedStates_0; }
inline void set_m_serializedStates_0(RuntimeObject* value)
{
___m_serializedStates_0 = value;
Il2CppCodeGenWriteBarrier((&___m_serializedStates_0), value);
}
inline static int32_t get_offset_of_m_savedSerializationInfo_1() { return static_cast<int32_t>(offsetof(SafeSerializationManager_t2481557153, ___m_savedSerializationInfo_1)); }
inline SerializationInfo_t950877179 * get_m_savedSerializationInfo_1() const { return ___m_savedSerializationInfo_1; }
inline SerializationInfo_t950877179 ** get_address_of_m_savedSerializationInfo_1() { return &___m_savedSerializationInfo_1; }
inline void set_m_savedSerializationInfo_1(SerializationInfo_t950877179 * value)
{
___m_savedSerializationInfo_1 = value;
Il2CppCodeGenWriteBarrier((&___m_savedSerializationInfo_1), value);
}
inline static int32_t get_offset_of_m_realObject_2() { return static_cast<int32_t>(offsetof(SafeSerializationManager_t2481557153, ___m_realObject_2)); }
inline RuntimeObject * get_m_realObject_2() const { return ___m_realObject_2; }
inline RuntimeObject ** get_address_of_m_realObject_2() { return &___m_realObject_2; }
inline void set_m_realObject_2(RuntimeObject * value)
{
___m_realObject_2 = value;
Il2CppCodeGenWriteBarrier((&___m_realObject_2), value);
}
inline static int32_t get_offset_of_m_realType_3() { return static_cast<int32_t>(offsetof(SafeSerializationManager_t2481557153, ___m_realType_3)); }
inline RuntimeType_t3636489352 * get_m_realType_3() const { return ___m_realType_3; }
inline RuntimeType_t3636489352 ** get_address_of_m_realType_3() { return &___m_realType_3; }
inline void set_m_realType_3(RuntimeType_t3636489352 * value)
{
___m_realType_3 = value;
Il2CppCodeGenWriteBarrier((&___m_realType_3), value);
}
inline static int32_t get_offset_of_SerializeObjectState_4() { return static_cast<int32_t>(offsetof(SafeSerializationManager_t2481557153, ___SerializeObjectState_4)); }
inline EventHandler_1_t2246946069 * get_SerializeObjectState_4() const { return ___SerializeObjectState_4; }
inline EventHandler_1_t2246946069 ** get_address_of_SerializeObjectState_4() { return &___SerializeObjectState_4; }
inline void set_SerializeObjectState_4(EventHandler_1_t2246946069 * value)
{
___SerializeObjectState_4 = value;
Il2CppCodeGenWriteBarrier((&___SerializeObjectState_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SAFESERIALIZATIONMANAGER_T2481557153_H
#ifndef ASYMMETRICSIGNATUREFORMATTER_T3486936014_H
#define ASYMMETRICSIGNATUREFORMATTER_T3486936014_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.AsymmetricSignatureFormatter
struct AsymmetricSignatureFormatter_t3486936014 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASYMMETRICSIGNATUREFORMATTER_T3486936014_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 FORMATTERCONVERTER_T2760117746_H
#define FORMATTERCONVERTER_T2760117746_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.FormatterConverter
struct FormatterConverter_t2760117746 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FORMATTERCONVERTER_T2760117746_H
#ifndef SERIALIZATIONEVENTSCACHE_T2327969880_H
#define SERIALIZATIONEVENTSCACHE_T2327969880_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.SerializationEventsCache
struct SerializationEventsCache_t2327969880 : public RuntimeObject
{
public:
public:
};
struct SerializationEventsCache_t2327969880_StaticFields
{
public:
// System.Collections.Hashtable System.Runtime.Serialization.SerializationEventsCache::cache
Hashtable_t1853889766 * ___cache_0;
public:
inline static int32_t get_offset_of_cache_0() { return static_cast<int32_t>(offsetof(SerializationEventsCache_t2327969880_StaticFields, ___cache_0)); }
inline Hashtable_t1853889766 * get_cache_0() const { return ___cache_0; }
inline Hashtable_t1853889766 ** get_address_of_cache_0() { return &___cache_0; }
inline void set_cache_0(Hashtable_t1853889766 * value)
{
___cache_0 = value;
Il2CppCodeGenWriteBarrier((&___cache_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SERIALIZATIONEVENTSCACHE_T2327969880_H
#ifndef ASYMMETRICALGORITHM_T932037087_H
#define ASYMMETRICALGORITHM_T932037087_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.AsymmetricAlgorithm
struct AsymmetricAlgorithm_t932037087 : public RuntimeObject
{
public:
// System.Int32 System.Security.Cryptography.AsymmetricAlgorithm::KeySizeValue
int32_t ___KeySizeValue_0;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.AsymmetricAlgorithm::LegalKeySizesValue
KeySizesU5BU5D_t722666473* ___LegalKeySizesValue_1;
public:
inline static int32_t get_offset_of_KeySizeValue_0() { return static_cast<int32_t>(offsetof(AsymmetricAlgorithm_t932037087, ___KeySizeValue_0)); }
inline int32_t get_KeySizeValue_0() const { return ___KeySizeValue_0; }
inline int32_t* get_address_of_KeySizeValue_0() { return &___KeySizeValue_0; }
inline void set_KeySizeValue_0(int32_t value)
{
___KeySizeValue_0 = value;
}
inline static int32_t get_offset_of_LegalKeySizesValue_1() { return static_cast<int32_t>(offsetof(AsymmetricAlgorithm_t932037087, ___LegalKeySizesValue_1)); }
inline KeySizesU5BU5D_t722666473* get_LegalKeySizesValue_1() const { return ___LegalKeySizesValue_1; }
inline KeySizesU5BU5D_t722666473** get_address_of_LegalKeySizesValue_1() { return &___LegalKeySizesValue_1; }
inline void set_LegalKeySizesValue_1(KeySizesU5BU5D_t722666473* value)
{
___LegalKeySizesValue_1 = value;
Il2CppCodeGenWriteBarrier((&___LegalKeySizesValue_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASYMMETRICALGORITHM_T932037087_H
#ifndef OBJECTHOLDERLISTENUMERATOR_T501693956_H
#define OBJECTHOLDERLISTENUMERATOR_T501693956_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.ObjectHolderListEnumerator
struct ObjectHolderListEnumerator_t501693956 : public RuntimeObject
{
public:
// System.Boolean System.Runtime.Serialization.ObjectHolderListEnumerator::m_isFixupEnumerator
bool ___m_isFixupEnumerator_0;
// System.Runtime.Serialization.ObjectHolderList System.Runtime.Serialization.ObjectHolderListEnumerator::m_list
ObjectHolderList_t2007846727 * ___m_list_1;
// System.Int32 System.Runtime.Serialization.ObjectHolderListEnumerator::m_startingVersion
int32_t ___m_startingVersion_2;
// System.Int32 System.Runtime.Serialization.ObjectHolderListEnumerator::m_currPos
int32_t ___m_currPos_3;
public:
inline static int32_t get_offset_of_m_isFixupEnumerator_0() { return static_cast<int32_t>(offsetof(ObjectHolderListEnumerator_t501693956, ___m_isFixupEnumerator_0)); }
inline bool get_m_isFixupEnumerator_0() const { return ___m_isFixupEnumerator_0; }
inline bool* get_address_of_m_isFixupEnumerator_0() { return &___m_isFixupEnumerator_0; }
inline void set_m_isFixupEnumerator_0(bool value)
{
___m_isFixupEnumerator_0 = value;
}
inline static int32_t get_offset_of_m_list_1() { return static_cast<int32_t>(offsetof(ObjectHolderListEnumerator_t501693956, ___m_list_1)); }
inline ObjectHolderList_t2007846727 * get_m_list_1() const { return ___m_list_1; }
inline ObjectHolderList_t2007846727 ** get_address_of_m_list_1() { return &___m_list_1; }
inline void set_m_list_1(ObjectHolderList_t2007846727 * value)
{
___m_list_1 = value;
Il2CppCodeGenWriteBarrier((&___m_list_1), value);
}
inline static int32_t get_offset_of_m_startingVersion_2() { return static_cast<int32_t>(offsetof(ObjectHolderListEnumerator_t501693956, ___m_startingVersion_2)); }
inline int32_t get_m_startingVersion_2() const { return ___m_startingVersion_2; }
inline int32_t* get_address_of_m_startingVersion_2() { return &___m_startingVersion_2; }
inline void set_m_startingVersion_2(int32_t value)
{
___m_startingVersion_2 = value;
}
inline static int32_t get_offset_of_m_currPos_3() { return static_cast<int32_t>(offsetof(ObjectHolderListEnumerator_t501693956, ___m_currPos_3)); }
inline int32_t get_m_currPos_3() const { return ___m_currPos_3; }
inline int32_t* get_address_of_m_currPos_3() { return &___m_currPos_3; }
inline void set_m_currPos_3(int32_t value)
{
___m_currPos_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OBJECTHOLDERLISTENUMERATOR_T501693956_H
#ifndef FIXUPHOLDER_T3112688910_H
#define FIXUPHOLDER_T3112688910_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.FixupHolder
struct FixupHolder_t3112688910 : public RuntimeObject
{
public:
// System.Int64 System.Runtime.Serialization.FixupHolder::m_id
int64_t ___m_id_0;
// System.Object System.Runtime.Serialization.FixupHolder::m_fixupInfo
RuntimeObject * ___m_fixupInfo_1;
// System.Int32 System.Runtime.Serialization.FixupHolder::m_fixupType
int32_t ___m_fixupType_2;
public:
inline static int32_t get_offset_of_m_id_0() { return static_cast<int32_t>(offsetof(FixupHolder_t3112688910, ___m_id_0)); }
inline int64_t get_m_id_0() const { return ___m_id_0; }
inline int64_t* get_address_of_m_id_0() { return &___m_id_0; }
inline void set_m_id_0(int64_t value)
{
___m_id_0 = value;
}
inline static int32_t get_offset_of_m_fixupInfo_1() { return static_cast<int32_t>(offsetof(FixupHolder_t3112688910, ___m_fixupInfo_1)); }
inline RuntimeObject * get_m_fixupInfo_1() const { return ___m_fixupInfo_1; }
inline RuntimeObject ** get_address_of_m_fixupInfo_1() { return &___m_fixupInfo_1; }
inline void set_m_fixupInfo_1(RuntimeObject * value)
{
___m_fixupInfo_1 = value;
Il2CppCodeGenWriteBarrier((&___m_fixupInfo_1), value);
}
inline static int32_t get_offset_of_m_fixupType_2() { return static_cast<int32_t>(offsetof(FixupHolder_t3112688910, ___m_fixupType_2)); }
inline int32_t get_m_fixupType_2() const { return ___m_fixupType_2; }
inline int32_t* get_address_of_m_fixupType_2() { return &___m_fixupType_2; }
inline void set_m_fixupType_2(int32_t value)
{
___m_fixupType_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FIXUPHOLDER_T3112688910_H
#ifndef X509HELPER_T1273321433_H
#define X509HELPER_T1273321433_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509Helper
struct X509Helper_t1273321433 : public RuntimeObject
{
public:
public:
};
struct X509Helper_t1273321433_StaticFields
{
public:
// System.Security.Cryptography.X509Certificates.INativeCertificateHelper System.Security.Cryptography.X509Certificates.X509Helper::nativeHelper
RuntimeObject* ___nativeHelper_0;
public:
inline static int32_t get_offset_of_nativeHelper_0() { return static_cast<int32_t>(offsetof(X509Helper_t1273321433_StaticFields, ___nativeHelper_0)); }
inline RuntimeObject* get_nativeHelper_0() const { return ___nativeHelper_0; }
inline RuntimeObject** get_address_of_nativeHelper_0() { return &___nativeHelper_0; }
inline void set_nativeHelper_0(RuntimeObject* value)
{
___nativeHelper_0 = value;
Il2CppCodeGenWriteBarrier((&___nativeHelper_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509HELPER_T1273321433_H
#ifndef OBJECTHOLDER_T2801344551_H
#define OBJECTHOLDER_T2801344551_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.ObjectHolder
struct ObjectHolder_t2801344551 : public RuntimeObject
{
public:
// System.Object System.Runtime.Serialization.ObjectHolder::m_object
RuntimeObject * ___m_object_0;
// System.Int64 System.Runtime.Serialization.ObjectHolder::m_id
int64_t ___m_id_1;
// System.Int32 System.Runtime.Serialization.ObjectHolder::m_missingElementsRemaining
int32_t ___m_missingElementsRemaining_2;
// System.Int32 System.Runtime.Serialization.ObjectHolder::m_missingDecendents
int32_t ___m_missingDecendents_3;
// System.Runtime.Serialization.SerializationInfo System.Runtime.Serialization.ObjectHolder::m_serInfo
SerializationInfo_t950877179 * ___m_serInfo_4;
// System.Runtime.Serialization.ISerializationSurrogate System.Runtime.Serialization.ObjectHolder::m_surrogate
RuntimeObject* ___m_surrogate_5;
// System.Runtime.Serialization.FixupHolderList System.Runtime.Serialization.ObjectHolder::m_missingElements
FixupHolderList_t3799028159 * ___m_missingElements_6;
// System.Runtime.Serialization.LongList System.Runtime.Serialization.ObjectHolder::m_dependentObjects
LongList_t2258305620 * ___m_dependentObjects_7;
// System.Runtime.Serialization.ObjectHolder System.Runtime.Serialization.ObjectHolder::m_next
ObjectHolder_t2801344551 * ___m_next_8;
// System.Int32 System.Runtime.Serialization.ObjectHolder::m_flags
int32_t ___m_flags_9;
// System.Boolean System.Runtime.Serialization.ObjectHolder::m_markForFixupWhenAvailable
bool ___m_markForFixupWhenAvailable_10;
// System.Runtime.Serialization.ValueTypeFixupInfo System.Runtime.Serialization.ObjectHolder::m_valueFixup
ValueTypeFixupInfo_t1444618334 * ___m_valueFixup_11;
// System.Runtime.Serialization.TypeLoadExceptionHolder System.Runtime.Serialization.ObjectHolder::m_typeLoad
TypeLoadExceptionHolder_t2983813904 * ___m_typeLoad_12;
// System.Boolean System.Runtime.Serialization.ObjectHolder::m_reachable
bool ___m_reachable_13;
public:
inline static int32_t get_offset_of_m_object_0() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_object_0)); }
inline RuntimeObject * get_m_object_0() const { return ___m_object_0; }
inline RuntimeObject ** get_address_of_m_object_0() { return &___m_object_0; }
inline void set_m_object_0(RuntimeObject * value)
{
___m_object_0 = value;
Il2CppCodeGenWriteBarrier((&___m_object_0), value);
}
inline static int32_t get_offset_of_m_id_1() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_id_1)); }
inline int64_t get_m_id_1() const { return ___m_id_1; }
inline int64_t* get_address_of_m_id_1() { return &___m_id_1; }
inline void set_m_id_1(int64_t value)
{
___m_id_1 = value;
}
inline static int32_t get_offset_of_m_missingElementsRemaining_2() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_missingElementsRemaining_2)); }
inline int32_t get_m_missingElementsRemaining_2() const { return ___m_missingElementsRemaining_2; }
inline int32_t* get_address_of_m_missingElementsRemaining_2() { return &___m_missingElementsRemaining_2; }
inline void set_m_missingElementsRemaining_2(int32_t value)
{
___m_missingElementsRemaining_2 = value;
}
inline static int32_t get_offset_of_m_missingDecendents_3() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_missingDecendents_3)); }
inline int32_t get_m_missingDecendents_3() const { return ___m_missingDecendents_3; }
inline int32_t* get_address_of_m_missingDecendents_3() { return &___m_missingDecendents_3; }
inline void set_m_missingDecendents_3(int32_t value)
{
___m_missingDecendents_3 = value;
}
inline static int32_t get_offset_of_m_serInfo_4() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_serInfo_4)); }
inline SerializationInfo_t950877179 * get_m_serInfo_4() const { return ___m_serInfo_4; }
inline SerializationInfo_t950877179 ** get_address_of_m_serInfo_4() { return &___m_serInfo_4; }
inline void set_m_serInfo_4(SerializationInfo_t950877179 * value)
{
___m_serInfo_4 = value;
Il2CppCodeGenWriteBarrier((&___m_serInfo_4), value);
}
inline static int32_t get_offset_of_m_surrogate_5() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_surrogate_5)); }
inline RuntimeObject* get_m_surrogate_5() const { return ___m_surrogate_5; }
inline RuntimeObject** get_address_of_m_surrogate_5() { return &___m_surrogate_5; }
inline void set_m_surrogate_5(RuntimeObject* value)
{
___m_surrogate_5 = value;
Il2CppCodeGenWriteBarrier((&___m_surrogate_5), value);
}
inline static int32_t get_offset_of_m_missingElements_6() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_missingElements_6)); }
inline FixupHolderList_t3799028159 * get_m_missingElements_6() const { return ___m_missingElements_6; }
inline FixupHolderList_t3799028159 ** get_address_of_m_missingElements_6() { return &___m_missingElements_6; }
inline void set_m_missingElements_6(FixupHolderList_t3799028159 * value)
{
___m_missingElements_6 = value;
Il2CppCodeGenWriteBarrier((&___m_missingElements_6), value);
}
inline static int32_t get_offset_of_m_dependentObjects_7() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_dependentObjects_7)); }
inline LongList_t2258305620 * get_m_dependentObjects_7() const { return ___m_dependentObjects_7; }
inline LongList_t2258305620 ** get_address_of_m_dependentObjects_7() { return &___m_dependentObjects_7; }
inline void set_m_dependentObjects_7(LongList_t2258305620 * value)
{
___m_dependentObjects_7 = value;
Il2CppCodeGenWriteBarrier((&___m_dependentObjects_7), value);
}
inline static int32_t get_offset_of_m_next_8() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_next_8)); }
inline ObjectHolder_t2801344551 * get_m_next_8() const { return ___m_next_8; }
inline ObjectHolder_t2801344551 ** get_address_of_m_next_8() { return &___m_next_8; }
inline void set_m_next_8(ObjectHolder_t2801344551 * value)
{
___m_next_8 = value;
Il2CppCodeGenWriteBarrier((&___m_next_8), value);
}
inline static int32_t get_offset_of_m_flags_9() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_flags_9)); }
inline int32_t get_m_flags_9() const { return ___m_flags_9; }
inline int32_t* get_address_of_m_flags_9() { return &___m_flags_9; }
inline void set_m_flags_9(int32_t value)
{
___m_flags_9 = value;
}
inline static int32_t get_offset_of_m_markForFixupWhenAvailable_10() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_markForFixupWhenAvailable_10)); }
inline bool get_m_markForFixupWhenAvailable_10() const { return ___m_markForFixupWhenAvailable_10; }
inline bool* get_address_of_m_markForFixupWhenAvailable_10() { return &___m_markForFixupWhenAvailable_10; }
inline void set_m_markForFixupWhenAvailable_10(bool value)
{
___m_markForFixupWhenAvailable_10 = value;
}
inline static int32_t get_offset_of_m_valueFixup_11() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_valueFixup_11)); }
inline ValueTypeFixupInfo_t1444618334 * get_m_valueFixup_11() const { return ___m_valueFixup_11; }
inline ValueTypeFixupInfo_t1444618334 ** get_address_of_m_valueFixup_11() { return &___m_valueFixup_11; }
inline void set_m_valueFixup_11(ValueTypeFixupInfo_t1444618334 * value)
{
___m_valueFixup_11 = value;
Il2CppCodeGenWriteBarrier((&___m_valueFixup_11), value);
}
inline static int32_t get_offset_of_m_typeLoad_12() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_typeLoad_12)); }
inline TypeLoadExceptionHolder_t2983813904 * get_m_typeLoad_12() const { return ___m_typeLoad_12; }
inline TypeLoadExceptionHolder_t2983813904 ** get_address_of_m_typeLoad_12() { return &___m_typeLoad_12; }
inline void set_m_typeLoad_12(TypeLoadExceptionHolder_t2983813904 * value)
{
___m_typeLoad_12 = value;
Il2CppCodeGenWriteBarrier((&___m_typeLoad_12), value);
}
inline static int32_t get_offset_of_m_reachable_13() { return static_cast<int32_t>(offsetof(ObjectHolder_t2801344551, ___m_reachable_13)); }
inline bool get_m_reachable_13() const { return ___m_reachable_13; }
inline bool* get_address_of_m_reachable_13() { return &___m_reachable_13; }
inline void set_m_reachable_13(bool value)
{
___m_reachable_13 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OBJECTHOLDER_T2801344551_H
#ifndef SURROGATEFORCYCLICALREFERENCE_T3309482836_H
#define SURROGATEFORCYCLICALREFERENCE_T3309482836_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.SurrogateForCyclicalReference
struct SurrogateForCyclicalReference_t3309482836 : public RuntimeObject
{
public:
// System.Runtime.Serialization.ISerializationSurrogate System.Runtime.Serialization.SurrogateForCyclicalReference::innerSurrogate
RuntimeObject* ___innerSurrogate_0;
public:
inline static int32_t get_offset_of_innerSurrogate_0() { return static_cast<int32_t>(offsetof(SurrogateForCyclicalReference_t3309482836, ___innerSurrogate_0)); }
inline RuntimeObject* get_innerSurrogate_0() const { return ___innerSurrogate_0; }
inline RuntimeObject** get_address_of_innerSurrogate_0() { return &___innerSurrogate_0; }
inline void set_innerSurrogate_0(RuntimeObject* value)
{
___innerSurrogate_0 = value;
Il2CppCodeGenWriteBarrier((&___innerSurrogate_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SURROGATEFORCYCLICALREFERENCE_T3309482836_H
#ifndef OBJECTIDGENERATOR_T1260826161_H
#define OBJECTIDGENERATOR_T1260826161_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.ObjectIDGenerator
struct ObjectIDGenerator_t1260826161 : public RuntimeObject
{
public:
// System.Int32 System.Runtime.Serialization.ObjectIDGenerator::m_currentCount
int32_t ___m_currentCount_0;
// System.Int32 System.Runtime.Serialization.ObjectIDGenerator::m_currentSize
int32_t ___m_currentSize_1;
// System.Int64[] System.Runtime.Serialization.ObjectIDGenerator::m_ids
Int64U5BU5D_t2559172825* ___m_ids_2;
// System.Object[] System.Runtime.Serialization.ObjectIDGenerator::m_objs
ObjectU5BU5D_t2843939325* ___m_objs_3;
public:
inline static int32_t get_offset_of_m_currentCount_0() { return static_cast<int32_t>(offsetof(ObjectIDGenerator_t1260826161, ___m_currentCount_0)); }
inline int32_t get_m_currentCount_0() const { return ___m_currentCount_0; }
inline int32_t* get_address_of_m_currentCount_0() { return &___m_currentCount_0; }
inline void set_m_currentCount_0(int32_t value)
{
___m_currentCount_0 = value;
}
inline static int32_t get_offset_of_m_currentSize_1() { return static_cast<int32_t>(offsetof(ObjectIDGenerator_t1260826161, ___m_currentSize_1)); }
inline int32_t get_m_currentSize_1() const { return ___m_currentSize_1; }
inline int32_t* get_address_of_m_currentSize_1() { return &___m_currentSize_1; }
inline void set_m_currentSize_1(int32_t value)
{
___m_currentSize_1 = value;
}
inline static int32_t get_offset_of_m_ids_2() { return static_cast<int32_t>(offsetof(ObjectIDGenerator_t1260826161, ___m_ids_2)); }
inline Int64U5BU5D_t2559172825* get_m_ids_2() const { return ___m_ids_2; }
inline Int64U5BU5D_t2559172825** get_address_of_m_ids_2() { return &___m_ids_2; }
inline void set_m_ids_2(Int64U5BU5D_t2559172825* value)
{
___m_ids_2 = value;
Il2CppCodeGenWriteBarrier((&___m_ids_2), value);
}
inline static int32_t get_offset_of_m_objs_3() { return static_cast<int32_t>(offsetof(ObjectIDGenerator_t1260826161, ___m_objs_3)); }
inline ObjectU5BU5D_t2843939325* get_m_objs_3() const { return ___m_objs_3; }
inline ObjectU5BU5D_t2843939325** get_address_of_m_objs_3() { return &___m_objs_3; }
inline void set_m_objs_3(ObjectU5BU5D_t2843939325* value)
{
___m_objs_3 = value;
Il2CppCodeGenWriteBarrier((&___m_objs_3), value);
}
};
struct ObjectIDGenerator_t1260826161_StaticFields
{
public:
// System.Int32[] System.Runtime.Serialization.ObjectIDGenerator::sizes
Int32U5BU5D_t385246372* ___sizes_4;
public:
inline static int32_t get_offset_of_sizes_4() { return static_cast<int32_t>(offsetof(ObjectIDGenerator_t1260826161_StaticFields, ___sizes_4)); }
inline Int32U5BU5D_t385246372* get_sizes_4() const { return ___sizes_4; }
inline Int32U5BU5D_t385246372** get_address_of_sizes_4() { return &___sizes_4; }
inline void set_sizes_4(Int32U5BU5D_t385246372* value)
{
___sizes_4 = value;
Il2CppCodeGenWriteBarrier((&___sizes_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OBJECTIDGENERATOR_T1260826161_H
#ifndef X509CERTIFICATEIMPL_T2851385038_H
#define X509CERTIFICATEIMPL_T2851385038_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509CertificateImpl
struct X509CertificateImpl_t2851385038 : public RuntimeObject
{
public:
// System.Byte[] System.Security.Cryptography.X509Certificates.X509CertificateImpl::cachedCertificateHash
ByteU5BU5D_t4116647657* ___cachedCertificateHash_0;
public:
inline static int32_t get_offset_of_cachedCertificateHash_0() { return static_cast<int32_t>(offsetof(X509CertificateImpl_t2851385038, ___cachedCertificateHash_0)); }
inline ByteU5BU5D_t4116647657* get_cachedCertificateHash_0() const { return ___cachedCertificateHash_0; }
inline ByteU5BU5D_t4116647657** get_address_of_cachedCertificateHash_0() { return &___cachedCertificateHash_0; }
inline void set_cachedCertificateHash_0(ByteU5BU5D_t4116647657* value)
{
___cachedCertificateHash_0 = value;
Il2CppCodeGenWriteBarrier((&___cachedCertificateHash_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATEIMPL_T2851385038_H
#ifndef LONGLIST_T2258305620_H
#define LONGLIST_T2258305620_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.LongList
struct LongList_t2258305620 : public RuntimeObject
{
public:
// System.Int64[] System.Runtime.Serialization.LongList::m_values
Int64U5BU5D_t2559172825* ___m_values_0;
// System.Int32 System.Runtime.Serialization.LongList::m_count
int32_t ___m_count_1;
// System.Int32 System.Runtime.Serialization.LongList::m_totalItems
int32_t ___m_totalItems_2;
// System.Int32 System.Runtime.Serialization.LongList::m_currentItem
int32_t ___m_currentItem_3;
public:
inline static int32_t get_offset_of_m_values_0() { return static_cast<int32_t>(offsetof(LongList_t2258305620, ___m_values_0)); }
inline Int64U5BU5D_t2559172825* get_m_values_0() const { return ___m_values_0; }
inline Int64U5BU5D_t2559172825** get_address_of_m_values_0() { return &___m_values_0; }
inline void set_m_values_0(Int64U5BU5D_t2559172825* value)
{
___m_values_0 = value;
Il2CppCodeGenWriteBarrier((&___m_values_0), value);
}
inline static int32_t get_offset_of_m_count_1() { return static_cast<int32_t>(offsetof(LongList_t2258305620, ___m_count_1)); }
inline int32_t get_m_count_1() const { return ___m_count_1; }
inline int32_t* get_address_of_m_count_1() { return &___m_count_1; }
inline void set_m_count_1(int32_t value)
{
___m_count_1 = value;
}
inline static int32_t get_offset_of_m_totalItems_2() { return static_cast<int32_t>(offsetof(LongList_t2258305620, ___m_totalItems_2)); }
inline int32_t get_m_totalItems_2() const { return ___m_totalItems_2; }
inline int32_t* get_address_of_m_totalItems_2() { return &___m_totalItems_2; }
inline void set_m_totalItems_2(int32_t value)
{
___m_totalItems_2 = value;
}
inline static int32_t get_offset_of_m_currentItem_3() { return static_cast<int32_t>(offsetof(LongList_t2258305620, ___m_currentItem_3)); }
inline int32_t get_m_currentItem_3() const { return ___m_currentItem_3; }
inline int32_t* get_address_of_m_currentItem_3() { return &___m_currentItem_3; }
inline void set_m_currentItem_3(int32_t value)
{
___m_currentItem_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // LONGLIST_T2258305620_H
#ifndef OBJECTHOLDERLIST_T2007846727_H
#define OBJECTHOLDERLIST_T2007846727_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.ObjectHolderList
struct ObjectHolderList_t2007846727 : public RuntimeObject
{
public:
// System.Runtime.Serialization.ObjectHolder[] System.Runtime.Serialization.ObjectHolderList::m_values
ObjectHolderU5BU5D_t663564126* ___m_values_0;
// System.Int32 System.Runtime.Serialization.ObjectHolderList::m_count
int32_t ___m_count_1;
public:
inline static int32_t get_offset_of_m_values_0() { return static_cast<int32_t>(offsetof(ObjectHolderList_t2007846727, ___m_values_0)); }
inline ObjectHolderU5BU5D_t663564126* get_m_values_0() const { return ___m_values_0; }
inline ObjectHolderU5BU5D_t663564126** get_address_of_m_values_0() { return &___m_values_0; }
inline void set_m_values_0(ObjectHolderU5BU5D_t663564126* value)
{
___m_values_0 = value;
Il2CppCodeGenWriteBarrier((&___m_values_0), value);
}
inline static int32_t get_offset_of_m_count_1() { return static_cast<int32_t>(offsetof(ObjectHolderList_t2007846727, ___m_count_1)); }
inline int32_t get_m_count_1() const { return ___m_count_1; }
inline int32_t* get_address_of_m_count_1() { return &___m_count_1; }
inline void set_m_count_1(int32_t value)
{
___m_count_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OBJECTHOLDERLIST_T2007846727_H
#ifndef FIXUPHOLDERLIST_T3799028159_H
#define FIXUPHOLDERLIST_T3799028159_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.FixupHolderList
struct FixupHolderList_t3799028159 : public RuntimeObject
{
public:
// System.Runtime.Serialization.FixupHolder[] System.Runtime.Serialization.FixupHolderList::m_values
FixupHolderU5BU5D_t415823611* ___m_values_0;
// System.Int32 System.Runtime.Serialization.FixupHolderList::m_count
int32_t ___m_count_1;
public:
inline static int32_t get_offset_of_m_values_0() { return static_cast<int32_t>(offsetof(FixupHolderList_t3799028159, ___m_values_0)); }
inline FixupHolderU5BU5D_t415823611* get_m_values_0() const { return ___m_values_0; }
inline FixupHolderU5BU5D_t415823611** get_address_of_m_values_0() { return &___m_values_0; }
inline void set_m_values_0(FixupHolderU5BU5D_t415823611* value)
{
___m_values_0 = value;
Il2CppCodeGenWriteBarrier((&___m_values_0), value);
}
inline static int32_t get_offset_of_m_count_1() { return static_cast<int32_t>(offsetof(FixupHolderList_t3799028159, ___m_count_1)); }
inline int32_t get_m_count_1() const { return ___m_count_1; }
inline int32_t* get_address_of_m_count_1() { return &___m_count_1; }
inline void set_m_count_1(int32_t value)
{
___m_count_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FIXUPHOLDERLIST_T3799028159_H
#ifndef X509CERTIFICATE_T713131622_H
#define X509CERTIFICATE_T713131622_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509Certificate
struct X509Certificate_t713131622 : public RuntimeObject
{
public:
// System.Security.Cryptography.X509Certificates.X509CertificateImpl System.Security.Cryptography.X509Certificates.X509Certificate::impl
X509CertificateImpl_t2851385038 * ___impl_0;
// System.Boolean System.Security.Cryptography.X509Certificates.X509Certificate::hideDates
bool ___hideDates_1;
// System.String System.Security.Cryptography.X509Certificates.X509Certificate::issuer_name
String_t* ___issuer_name_2;
// System.String System.Security.Cryptography.X509Certificates.X509Certificate::subject_name
String_t* ___subject_name_3;
public:
inline static int32_t get_offset_of_impl_0() { return static_cast<int32_t>(offsetof(X509Certificate_t713131622, ___impl_0)); }
inline X509CertificateImpl_t2851385038 * get_impl_0() const { return ___impl_0; }
inline X509CertificateImpl_t2851385038 ** get_address_of_impl_0() { return &___impl_0; }
inline void set_impl_0(X509CertificateImpl_t2851385038 * value)
{
___impl_0 = value;
Il2CppCodeGenWriteBarrier((&___impl_0), value);
}
inline static int32_t get_offset_of_hideDates_1() { return static_cast<int32_t>(offsetof(X509Certificate_t713131622, ___hideDates_1)); }
inline bool get_hideDates_1() const { return ___hideDates_1; }
inline bool* get_address_of_hideDates_1() { return &___hideDates_1; }
inline void set_hideDates_1(bool value)
{
___hideDates_1 = value;
}
inline static int32_t get_offset_of_issuer_name_2() { return static_cast<int32_t>(offsetof(X509Certificate_t713131622, ___issuer_name_2)); }
inline String_t* get_issuer_name_2() const { return ___issuer_name_2; }
inline String_t** get_address_of_issuer_name_2() { return &___issuer_name_2; }
inline void set_issuer_name_2(String_t* value)
{
___issuer_name_2 = value;
Il2CppCodeGenWriteBarrier((&___issuer_name_2), value);
}
inline static int32_t get_offset_of_subject_name_3() { return static_cast<int32_t>(offsetof(X509Certificate_t713131622, ___subject_name_3)); }
inline String_t* get_subject_name_3() const { return ___subject_name_3; }
inline String_t** get_address_of_subject_name_3() { return &___subject_name_3; }
inline void set_subject_name_3(String_t* value)
{
___subject_name_3 = value;
Il2CppCodeGenWriteBarrier((&___subject_name_3), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATE_T713131622_H
#ifndef UTILS_T1416439708_H
#define UTILS_T1416439708_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.Utils
struct Utils_t1416439708 : public RuntimeObject
{
public:
public:
};
struct Utils_t1416439708_StaticFields
{
public:
// System.Security.Cryptography.RNGCryptoServiceProvider modreq(System.Runtime.CompilerServices.IsVolatile) System.Security.Cryptography.Utils::_rng
RNGCryptoServiceProvider_t3397414743 * ____rng_0;
public:
inline static int32_t get_offset_of__rng_0() { return static_cast<int32_t>(offsetof(Utils_t1416439708_StaticFields, ____rng_0)); }
inline RNGCryptoServiceProvider_t3397414743 * get__rng_0() const { return ____rng_0; }
inline RNGCryptoServiceProvider_t3397414743 ** get_address_of__rng_0() { return &____rng_0; }
inline void set__rng_0(RNGCryptoServiceProvider_t3397414743 * value)
{
____rng_0 = value;
Il2CppCodeGenWriteBarrier((&____rng_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // UTILS_T1416439708_H
#ifndef EVENTARGS_T3591816995_H
#define EVENTARGS_T3591816995_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.EventArgs
struct EventArgs_t3591816995 : public RuntimeObject
{
public:
public:
};
struct EventArgs_t3591816995_StaticFields
{
public:
// System.EventArgs System.EventArgs::Empty
EventArgs_t3591816995 * ___Empty_0;
public:
inline static int32_t get_offset_of_Empty_0() { return static_cast<int32_t>(offsetof(EventArgs_t3591816995_StaticFields, ___Empty_0)); }
inline EventArgs_t3591816995 * get_Empty_0() const { return ___Empty_0; }
inline EventArgs_t3591816995 ** get_address_of_Empty_0() { return &___Empty_0; }
inline void set_Empty_0(EventArgs_t3591816995 * value)
{
___Empty_0 = value;
Il2CppCodeGenWriteBarrier((&___Empty_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // EVENTARGS_T3591816995_H
#ifndef MASKGENERATIONMETHOD_T2116484826_H
#define MASKGENERATIONMETHOD_T2116484826_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.MaskGenerationMethod
struct MaskGenerationMethod_t2116484826 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MASKGENERATIONMETHOD_T2116484826_H
#ifndef MARSHALBYREFOBJECT_T2760389100_H
#define MARSHALBYREFOBJECT_T2760389100_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MarshalByRefObject
struct MarshalByRefObject_t2760389100 : public RuntimeObject
{
public:
// System.Runtime.Remoting.ServerIdentity System.MarshalByRefObject::_identity
ServerIdentity_t2342208608 * ____identity_0;
public:
inline static int32_t get_offset_of__identity_0() { return static_cast<int32_t>(offsetof(MarshalByRefObject_t2760389100, ____identity_0)); }
inline ServerIdentity_t2342208608 * get__identity_0() const { return ____identity_0; }
inline ServerIdentity_t2342208608 ** get_address_of__identity_0() { return &____identity_0; }
inline void set__identity_0(ServerIdentity_t2342208608 * value)
{
____identity_0 = value;
Il2CppCodeGenWriteBarrier((&____identity_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.MarshalByRefObject
struct MarshalByRefObject_t2760389100_marshaled_pinvoke
{
ServerIdentity_t2342208608 * ____identity_0;
};
// Native definition for COM marshalling of System.MarshalByRefObject
struct MarshalByRefObject_t2760389100_marshaled_com
{
ServerIdentity_t2342208608 * ____identity_0;
};
#endif // MARSHALBYREFOBJECT_T2760389100_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 U3CU3EC_T3166561961_H
#define U3CU3EC_T3166561961_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMACSHA384/<>c
struct U3CU3Ec_t3166561961 : public RuntimeObject
{
public:
public:
};
struct U3CU3Ec_t3166561961_StaticFields
{
public:
// System.Security.Cryptography.HMACSHA384/<>c System.Security.Cryptography.HMACSHA384/<>c::<>9
U3CU3Ec_t3166561961 * ___U3CU3E9_0;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA384/<>c::<>9__2_0
Func_1_t862063866 * ___U3CU3E9__2_0_1;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA384/<>c::<>9__2_1
Func_1_t862063866 * ___U3CU3E9__2_1_2;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA384/<>c::<>9__2_2
Func_1_t862063866 * ___U3CU3E9__2_2_3;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA384/<>c::<>9__2_3
Func_1_t862063866 * ___U3CU3E9__2_3_4;
public:
inline static int32_t get_offset_of_U3CU3E9_0() { return static_cast<int32_t>(offsetof(U3CU3Ec_t3166561961_StaticFields, ___U3CU3E9_0)); }
inline U3CU3Ec_t3166561961 * get_U3CU3E9_0() const { return ___U3CU3E9_0; }
inline U3CU3Ec_t3166561961 ** get_address_of_U3CU3E9_0() { return &___U3CU3E9_0; }
inline void set_U3CU3E9_0(U3CU3Ec_t3166561961 * value)
{
___U3CU3E9_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9_0), value);
}
inline static int32_t get_offset_of_U3CU3E9__2_0_1() { return static_cast<int32_t>(offsetof(U3CU3Ec_t3166561961_StaticFields, ___U3CU3E9__2_0_1)); }
inline Func_1_t862063866 * get_U3CU3E9__2_0_1() const { return ___U3CU3E9__2_0_1; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__2_0_1() { return &___U3CU3E9__2_0_1; }
inline void set_U3CU3E9__2_0_1(Func_1_t862063866 * value)
{
___U3CU3E9__2_0_1 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__2_0_1), value);
}
inline static int32_t get_offset_of_U3CU3E9__2_1_2() { return static_cast<int32_t>(offsetof(U3CU3Ec_t3166561961_StaticFields, ___U3CU3E9__2_1_2)); }
inline Func_1_t862063866 * get_U3CU3E9__2_1_2() const { return ___U3CU3E9__2_1_2; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__2_1_2() { return &___U3CU3E9__2_1_2; }
inline void set_U3CU3E9__2_1_2(Func_1_t862063866 * value)
{
___U3CU3E9__2_1_2 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__2_1_2), value);
}
inline static int32_t get_offset_of_U3CU3E9__2_2_3() { return static_cast<int32_t>(offsetof(U3CU3Ec_t3166561961_StaticFields, ___U3CU3E9__2_2_3)); }
inline Func_1_t862063866 * get_U3CU3E9__2_2_3() const { return ___U3CU3E9__2_2_3; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__2_2_3() { return &___U3CU3E9__2_2_3; }
inline void set_U3CU3E9__2_2_3(Func_1_t862063866 * value)
{
___U3CU3E9__2_2_3 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__2_2_3), value);
}
inline static int32_t get_offset_of_U3CU3E9__2_3_4() { return static_cast<int32_t>(offsetof(U3CU3Ec_t3166561961_StaticFields, ___U3CU3E9__2_3_4)); }
inline Func_1_t862063866 * get_U3CU3E9__2_3_4() const { return ___U3CU3E9__2_3_4; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__2_3_4() { return &___U3CU3E9__2_3_4; }
inline void set_U3CU3E9__2_3_4(Func_1_t862063866 * value)
{
___U3CU3E9__2_3_4 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__2_3_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CU3EC_T3166561961_H
#ifndef U3CU3EC_T616840057_H
#define U3CU3EC_T616840057_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMACSHA512/<>c
struct U3CU3Ec_t616840057 : public RuntimeObject
{
public:
public:
};
struct U3CU3Ec_t616840057_StaticFields
{
public:
// System.Security.Cryptography.HMACSHA512/<>c System.Security.Cryptography.HMACSHA512/<>c::<>9
U3CU3Ec_t616840057 * ___U3CU3E9_0;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA512/<>c::<>9__2_0
Func_1_t862063866 * ___U3CU3E9__2_0_1;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA512/<>c::<>9__2_1
Func_1_t862063866 * ___U3CU3E9__2_1_2;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA512/<>c::<>9__2_2
Func_1_t862063866 * ___U3CU3E9__2_2_3;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA512/<>c::<>9__2_3
Func_1_t862063866 * ___U3CU3E9__2_3_4;
public:
inline static int32_t get_offset_of_U3CU3E9_0() { return static_cast<int32_t>(offsetof(U3CU3Ec_t616840057_StaticFields, ___U3CU3E9_0)); }
inline U3CU3Ec_t616840057 * get_U3CU3E9_0() const { return ___U3CU3E9_0; }
inline U3CU3Ec_t616840057 ** get_address_of_U3CU3E9_0() { return &___U3CU3E9_0; }
inline void set_U3CU3E9_0(U3CU3Ec_t616840057 * value)
{
___U3CU3E9_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9_0), value);
}
inline static int32_t get_offset_of_U3CU3E9__2_0_1() { return static_cast<int32_t>(offsetof(U3CU3Ec_t616840057_StaticFields, ___U3CU3E9__2_0_1)); }
inline Func_1_t862063866 * get_U3CU3E9__2_0_1() const { return ___U3CU3E9__2_0_1; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__2_0_1() { return &___U3CU3E9__2_0_1; }
inline void set_U3CU3E9__2_0_1(Func_1_t862063866 * value)
{
___U3CU3E9__2_0_1 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__2_0_1), value);
}
inline static int32_t get_offset_of_U3CU3E9__2_1_2() { return static_cast<int32_t>(offsetof(U3CU3Ec_t616840057_StaticFields, ___U3CU3E9__2_1_2)); }
inline Func_1_t862063866 * get_U3CU3E9__2_1_2() const { return ___U3CU3E9__2_1_2; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__2_1_2() { return &___U3CU3E9__2_1_2; }
inline void set_U3CU3E9__2_1_2(Func_1_t862063866 * value)
{
___U3CU3E9__2_1_2 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__2_1_2), value);
}
inline static int32_t get_offset_of_U3CU3E9__2_2_3() { return static_cast<int32_t>(offsetof(U3CU3Ec_t616840057_StaticFields, ___U3CU3E9__2_2_3)); }
inline Func_1_t862063866 * get_U3CU3E9__2_2_3() const { return ___U3CU3E9__2_2_3; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__2_2_3() { return &___U3CU3E9__2_2_3; }
inline void set_U3CU3E9__2_2_3(Func_1_t862063866 * value)
{
___U3CU3E9__2_2_3 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__2_2_3), value);
}
inline static int32_t get_offset_of_U3CU3E9__2_3_4() { return static_cast<int32_t>(offsetof(U3CU3Ec_t616840057_StaticFields, ___U3CU3E9__2_3_4)); }
inline Func_1_t862063866 * get_U3CU3E9__2_3_4() const { return ___U3CU3E9__2_3_4; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__2_3_4() { return &___U3CU3E9__2_3_4; }
inline void set_U3CU3E9__2_3_4(Func_1_t862063866 * value)
{
___U3CU3E9__2_3_4 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__2_3_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CU3EC_T616840057_H
#ifndef ASYMMETRICKEYEXCHANGEFORMATTER_T937192061_H
#define ASYMMETRICKEYEXCHANGEFORMATTER_T937192061_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.AsymmetricKeyExchangeFormatter
struct AsymmetricKeyExchangeFormatter_t937192061 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASYMMETRICKEYEXCHANGEFORMATTER_T937192061_H
#ifndef U3CU3EC_T44063686_H
#define U3CU3EC_T44063686_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMACSHA256/<>c
struct U3CU3Ec_t44063686 : public RuntimeObject
{
public:
public:
};
struct U3CU3Ec_t44063686_StaticFields
{
public:
// System.Security.Cryptography.HMACSHA256/<>c System.Security.Cryptography.HMACSHA256/<>c::<>9
U3CU3Ec_t44063686 * ___U3CU3E9_0;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA256/<>c::<>9__1_0
Func_1_t862063866 * ___U3CU3E9__1_0_1;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA256/<>c::<>9__1_1
Func_1_t862063866 * ___U3CU3E9__1_1_2;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA256/<>c::<>9__1_2
Func_1_t862063866 * ___U3CU3E9__1_2_3;
// System.Func`1<System.Security.Cryptography.HashAlgorithm> System.Security.Cryptography.HMACSHA256/<>c::<>9__1_3
Func_1_t862063866 * ___U3CU3E9__1_3_4;
public:
inline static int32_t get_offset_of_U3CU3E9_0() { return static_cast<int32_t>(offsetof(U3CU3Ec_t44063686_StaticFields, ___U3CU3E9_0)); }
inline U3CU3Ec_t44063686 * get_U3CU3E9_0() const { return ___U3CU3E9_0; }
inline U3CU3Ec_t44063686 ** get_address_of_U3CU3E9_0() { return &___U3CU3E9_0; }
inline void set_U3CU3E9_0(U3CU3Ec_t44063686 * value)
{
___U3CU3E9_0 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9_0), value);
}
inline static int32_t get_offset_of_U3CU3E9__1_0_1() { return static_cast<int32_t>(offsetof(U3CU3Ec_t44063686_StaticFields, ___U3CU3E9__1_0_1)); }
inline Func_1_t862063866 * get_U3CU3E9__1_0_1() const { return ___U3CU3E9__1_0_1; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__1_0_1() { return &___U3CU3E9__1_0_1; }
inline void set_U3CU3E9__1_0_1(Func_1_t862063866 * value)
{
___U3CU3E9__1_0_1 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__1_0_1), value);
}
inline static int32_t get_offset_of_U3CU3E9__1_1_2() { return static_cast<int32_t>(offsetof(U3CU3Ec_t44063686_StaticFields, ___U3CU3E9__1_1_2)); }
inline Func_1_t862063866 * get_U3CU3E9__1_1_2() const { return ___U3CU3E9__1_1_2; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__1_1_2() { return &___U3CU3E9__1_1_2; }
inline void set_U3CU3E9__1_1_2(Func_1_t862063866 * value)
{
___U3CU3E9__1_1_2 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__1_1_2), value);
}
inline static int32_t get_offset_of_U3CU3E9__1_2_3() { return static_cast<int32_t>(offsetof(U3CU3Ec_t44063686_StaticFields, ___U3CU3E9__1_2_3)); }
inline Func_1_t862063866 * get_U3CU3E9__1_2_3() const { return ___U3CU3E9__1_2_3; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__1_2_3() { return &___U3CU3E9__1_2_3; }
inline void set_U3CU3E9__1_2_3(Func_1_t862063866 * value)
{
___U3CU3E9__1_2_3 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__1_2_3), value);
}
inline static int32_t get_offset_of_U3CU3E9__1_3_4() { return static_cast<int32_t>(offsetof(U3CU3Ec_t44063686_StaticFields, ___U3CU3E9__1_3_4)); }
inline Func_1_t862063866 * get_U3CU3E9__1_3_4() const { return ___U3CU3E9__1_3_4; }
inline Func_1_t862063866 ** get_address_of_U3CU3E9__1_3_4() { return &___U3CU3E9__1_3_4; }
inline void set_U3CU3E9__1_3_4(Func_1_t862063866 * value)
{
___U3CU3E9__1_3_4 = value;
Il2CppCodeGenWriteBarrier((&___U3CU3E9__1_3_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // U3CU3EC_T44063686_H
#ifndef HASHALGORITHM_T1432317219_H
#define HASHALGORITHM_T1432317219_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HashAlgorithm
struct HashAlgorithm_t1432317219 : public RuntimeObject
{
public:
// System.Int32 System.Security.Cryptography.HashAlgorithm::HashSizeValue
int32_t ___HashSizeValue_0;
// System.Byte[] System.Security.Cryptography.HashAlgorithm::HashValue
ByteU5BU5D_t4116647657* ___HashValue_1;
// System.Int32 System.Security.Cryptography.HashAlgorithm::State
int32_t ___State_2;
// System.Boolean System.Security.Cryptography.HashAlgorithm::m_bDisposed
bool ___m_bDisposed_3;
public:
inline static int32_t get_offset_of_HashSizeValue_0() { return static_cast<int32_t>(offsetof(HashAlgorithm_t1432317219, ___HashSizeValue_0)); }
inline int32_t get_HashSizeValue_0() const { return ___HashSizeValue_0; }
inline int32_t* get_address_of_HashSizeValue_0() { return &___HashSizeValue_0; }
inline void set_HashSizeValue_0(int32_t value)
{
___HashSizeValue_0 = value;
}
inline static int32_t get_offset_of_HashValue_1() { return static_cast<int32_t>(offsetof(HashAlgorithm_t1432317219, ___HashValue_1)); }
inline ByteU5BU5D_t4116647657* get_HashValue_1() const { return ___HashValue_1; }
inline ByteU5BU5D_t4116647657** get_address_of_HashValue_1() { return &___HashValue_1; }
inline void set_HashValue_1(ByteU5BU5D_t4116647657* value)
{
___HashValue_1 = value;
Il2CppCodeGenWriteBarrier((&___HashValue_1), value);
}
inline static int32_t get_offset_of_State_2() { return static_cast<int32_t>(offsetof(HashAlgorithm_t1432317219, ___State_2)); }
inline int32_t get_State_2() const { return ___State_2; }
inline int32_t* get_address_of_State_2() { return &___State_2; }
inline void set_State_2(int32_t value)
{
___State_2 = value;
}
inline static int32_t get_offset_of_m_bDisposed_3() { return static_cast<int32_t>(offsetof(HashAlgorithm_t1432317219, ___m_bDisposed_3)); }
inline bool get_m_bDisposed_3() const { return ___m_bDisposed_3; }
inline bool* get_address_of_m_bDisposed_3() { return &___m_bDisposed_3; }
inline void set_m_bDisposed_3(bool value)
{
___m_bDisposed_3 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HASHALGORITHM_T1432317219_H
#ifndef ASYMMETRICKEYEXCHANGEDEFORMATTER_T3370779160_H
#define ASYMMETRICKEYEXCHANGEDEFORMATTER_T3370779160_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.AsymmetricKeyExchangeDeformatter
struct AsymmetricKeyExchangeDeformatter_t3370779160 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASYMMETRICKEYEXCHANGEDEFORMATTER_T3370779160_H
#ifndef ASYMMETRICSIGNATUREDEFORMATTER_T2681190756_H
#define ASYMMETRICSIGNATUREDEFORMATTER_T2681190756_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.AsymmetricSignatureDeformatter
struct AsymmetricSignatureDeformatter_t2681190756 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ASYMMETRICSIGNATUREDEFORMATTER_T2681190756_H
#ifndef RANDOMNUMBERGENERATOR_T386037858_H
#define RANDOMNUMBERGENERATOR_T386037858_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t386037858 : public RuntimeObject
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RANDOMNUMBERGENERATOR_T386037858_H
#ifndef DSASIGNATUREDEFORMATTER_T3677955172_H
#define DSASIGNATUREDEFORMATTER_T3677955172_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.DSASignatureDeformatter
struct DSASignatureDeformatter_t3677955172 : public AsymmetricSignatureDeformatter_t2681190756
{
public:
// System.Security.Cryptography.DSA System.Security.Cryptography.DSASignatureDeformatter::_dsaKey
DSA_t2386879874 * ____dsaKey_0;
// System.String System.Security.Cryptography.DSASignatureDeformatter::_oid
String_t* ____oid_1;
public:
inline static int32_t get_offset_of__dsaKey_0() { return static_cast<int32_t>(offsetof(DSASignatureDeformatter_t3677955172, ____dsaKey_0)); }
inline DSA_t2386879874 * get__dsaKey_0() const { return ____dsaKey_0; }
inline DSA_t2386879874 ** get_address_of__dsaKey_0() { return &____dsaKey_0; }
inline void set__dsaKey_0(DSA_t2386879874 * value)
{
____dsaKey_0 = value;
Il2CppCodeGenWriteBarrier((&____dsaKey_0), value);
}
inline static int32_t get_offset_of__oid_1() { return static_cast<int32_t>(offsetof(DSASignatureDeformatter_t3677955172, ____oid_1)); }
inline String_t* get__oid_1() const { return ____oid_1; }
inline String_t** get_address_of__oid_1() { return &____oid_1; }
inline void set__oid_1(String_t* value)
{
____oid_1 = value;
Il2CppCodeGenWriteBarrier((&____oid_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DSASIGNATUREDEFORMATTER_T3677955172_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 OPTIONALFIELDATTRIBUTE_T761606048_H
#define OPTIONALFIELDATTRIBUTE_T761606048_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.OptionalFieldAttribute
struct OptionalFieldAttribute_t761606048 : public Attribute_t861562559
{
public:
// System.Int32 System.Runtime.Serialization.OptionalFieldAttribute::versionAdded
int32_t ___versionAdded_0;
public:
inline static int32_t get_offset_of_versionAdded_0() { return static_cast<int32_t>(offsetof(OptionalFieldAttribute_t761606048, ___versionAdded_0)); }
inline int32_t get_versionAdded_0() const { return ___versionAdded_0; }
inline int32_t* get_address_of_versionAdded_0() { return &___versionAdded_0; }
inline void set_versionAdded_0(int32_t value)
{
___versionAdded_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OPTIONALFIELDATTRIBUTE_T761606048_H
#ifndef X509CERTIFICATEIMPLMONO_T285361170_H
#define X509CERTIFICATEIMPLMONO_T285361170_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509CertificateImplMono
struct X509CertificateImplMono_t285361170 : public X509CertificateImpl_t2851385038
{
public:
// Mono.Security.X509.X509Certificate System.Security.Cryptography.X509Certificates.X509CertificateImplMono::x509
X509Certificate_t489243024 * ___x509_1;
public:
inline static int32_t get_offset_of_x509_1() { return static_cast<int32_t>(offsetof(X509CertificateImplMono_t285361170, ___x509_1)); }
inline X509Certificate_t489243024 * get_x509_1() const { return ___x509_1; }
inline X509Certificate_t489243024 ** get_address_of_x509_1() { return &___x509_1; }
inline void set_x509_1(X509Certificate_t489243024 * value)
{
___x509_1 = value;
Il2CppCodeGenWriteBarrier((&___x509_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATEIMPLMONO_T285361170_H
#ifndef RSAPKCS1SIGNATUREDESCRIPTION_T653172199_H
#define RSAPKCS1SIGNATUREDESCRIPTION_T653172199_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAPKCS1SignatureDescription
struct RSAPKCS1SignatureDescription_t653172199 : public SignatureDescription_t1971889425
{
public:
// System.String System.Security.Cryptography.RSAPKCS1SignatureDescription::_hashAlgorithm
String_t* ____hashAlgorithm_4;
public:
inline static int32_t get_offset_of__hashAlgorithm_4() { return static_cast<int32_t>(offsetof(RSAPKCS1SignatureDescription_t653172199, ____hashAlgorithm_4)); }
inline String_t* get__hashAlgorithm_4() const { return ____hashAlgorithm_4; }
inline String_t** get_address_of__hashAlgorithm_4() { return &____hashAlgorithm_4; }
inline void set__hashAlgorithm_4(String_t* value)
{
____hashAlgorithm_4 = value;
Il2CppCodeGenWriteBarrier((&____hashAlgorithm_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAPKCS1SIGNATUREDESCRIPTION_T653172199_H
#ifndef BOOLEAN_T97287965_H
#define BOOLEAN_T97287965_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Boolean
struct Boolean_t97287965
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_t97287965, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_t97287965_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_t97287965_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((&___TrueString_5), value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_t97287965_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((&___FalseString_6), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // BOOLEAN_T97287965_H
#ifndef HASHALGORITHMNAME_T3637476002_H
#define HASHALGORITHMNAME_T3637476002_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HashAlgorithmName
struct HashAlgorithmName_t3637476002
{
public:
// System.String System.Security.Cryptography.HashAlgorithmName::_name
String_t* ____name_0;
public:
inline static int32_t get_offset_of__name_0() { return static_cast<int32_t>(offsetof(HashAlgorithmName_t3637476002, ____name_0)); }
inline String_t* get__name_0() const { return ____name_0; }
inline String_t** get_address_of__name_0() { return &____name_0; }
inline void set__name_0(String_t* value)
{
____name_0 = value;
Il2CppCodeGenWriteBarrier((&____name_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Security.Cryptography.HashAlgorithmName
struct HashAlgorithmName_t3637476002_marshaled_pinvoke
{
char* ____name_0;
};
// Native definition for COM marshalling of System.Security.Cryptography.HashAlgorithmName
struct HashAlgorithmName_t3637476002_marshaled_com
{
Il2CppChar* ____name_0;
};
#endif // HASHALGORITHMNAME_T3637476002_H
#ifndef DSASIGNATUREFORMATTER_T2007981259_H
#define DSASIGNATUREFORMATTER_T2007981259_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.DSASignatureFormatter
struct DSASignatureFormatter_t2007981259 : public AsymmetricSignatureFormatter_t3486936014
{
public:
// System.Security.Cryptography.DSA System.Security.Cryptography.DSASignatureFormatter::_dsaKey
DSA_t2386879874 * ____dsaKey_0;
// System.String System.Security.Cryptography.DSASignatureFormatter::_oid
String_t* ____oid_1;
public:
inline static int32_t get_offset_of__dsaKey_0() { return static_cast<int32_t>(offsetof(DSASignatureFormatter_t2007981259, ____dsaKey_0)); }
inline DSA_t2386879874 * get__dsaKey_0() const { return ____dsaKey_0; }
inline DSA_t2386879874 ** get_address_of__dsaKey_0() { return &____dsaKey_0; }
inline void set__dsaKey_0(DSA_t2386879874 * value)
{
____dsaKey_0 = value;
Il2CppCodeGenWriteBarrier((&____dsaKey_0), value);
}
inline static int32_t get_offset_of__oid_1() { return static_cast<int32_t>(offsetof(DSASignatureFormatter_t2007981259, ____oid_1)); }
inline String_t* get__oid_1() const { return ____oid_1; }
inline String_t** get_address_of__oid_1() { return &____oid_1; }
inline void set__oid_1(String_t* value)
{
____oid_1 = value;
Il2CppCodeGenWriteBarrier((&____oid_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DSASIGNATUREFORMATTER_T2007981259_H
#ifndef VOID_T1185182177_H
#define VOID_T1185182177_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void
struct Void_t1185182177
{
public:
union
{
struct
{
};
uint8_t Void_t1185182177__padding[1];
};
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // VOID_T1185182177_H
#ifndef DSASIGNATUREDESCRIPTION_T1163053634_H
#define DSASIGNATUREDESCRIPTION_T1163053634_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.DSASignatureDescription
struct DSASignatureDescription_t1163053634 : public SignatureDescription_t1971889425
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DSASIGNATUREDESCRIPTION_T1163053634_H
#ifndef ONSERIALIZINGATTRIBUTE_T2580696919_H
#define ONSERIALIZINGATTRIBUTE_T2580696919_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.OnSerializingAttribute
struct OnSerializingAttribute_t2580696919 : public Attribute_t861562559
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ONSERIALIZINGATTRIBUTE_T2580696919_H
#ifndef RSA_T2385438082_H
#define RSA_T2385438082_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSA
struct RSA_t2385438082 : public AsymmetricAlgorithm_t932037087
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSA_T2385438082_H
#ifndef RSAPARAMETERS_T1728406613_H
#define RSAPARAMETERS_T1728406613_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAParameters
struct RSAParameters_t1728406613
{
public:
// System.Byte[] System.Security.Cryptography.RSAParameters::Exponent
ByteU5BU5D_t4116647657* ___Exponent_0;
// System.Byte[] System.Security.Cryptography.RSAParameters::Modulus
ByteU5BU5D_t4116647657* ___Modulus_1;
// System.Byte[] System.Security.Cryptography.RSAParameters::P
ByteU5BU5D_t4116647657* ___P_2;
// System.Byte[] System.Security.Cryptography.RSAParameters::Q
ByteU5BU5D_t4116647657* ___Q_3;
// System.Byte[] System.Security.Cryptography.RSAParameters::DP
ByteU5BU5D_t4116647657* ___DP_4;
// System.Byte[] System.Security.Cryptography.RSAParameters::DQ
ByteU5BU5D_t4116647657* ___DQ_5;
// System.Byte[] System.Security.Cryptography.RSAParameters::InverseQ
ByteU5BU5D_t4116647657* ___InverseQ_6;
// System.Byte[] System.Security.Cryptography.RSAParameters::D
ByteU5BU5D_t4116647657* ___D_7;
public:
inline static int32_t get_offset_of_Exponent_0() { return static_cast<int32_t>(offsetof(RSAParameters_t1728406613, ___Exponent_0)); }
inline ByteU5BU5D_t4116647657* get_Exponent_0() const { return ___Exponent_0; }
inline ByteU5BU5D_t4116647657** get_address_of_Exponent_0() { return &___Exponent_0; }
inline void set_Exponent_0(ByteU5BU5D_t4116647657* value)
{
___Exponent_0 = value;
Il2CppCodeGenWriteBarrier((&___Exponent_0), value);
}
inline static int32_t get_offset_of_Modulus_1() { return static_cast<int32_t>(offsetof(RSAParameters_t1728406613, ___Modulus_1)); }
inline ByteU5BU5D_t4116647657* get_Modulus_1() const { return ___Modulus_1; }
inline ByteU5BU5D_t4116647657** get_address_of_Modulus_1() { return &___Modulus_1; }
inline void set_Modulus_1(ByteU5BU5D_t4116647657* value)
{
___Modulus_1 = value;
Il2CppCodeGenWriteBarrier((&___Modulus_1), value);
}
inline static int32_t get_offset_of_P_2() { return static_cast<int32_t>(offsetof(RSAParameters_t1728406613, ___P_2)); }
inline ByteU5BU5D_t4116647657* get_P_2() const { return ___P_2; }
inline ByteU5BU5D_t4116647657** get_address_of_P_2() { return &___P_2; }
inline void set_P_2(ByteU5BU5D_t4116647657* value)
{
___P_2 = value;
Il2CppCodeGenWriteBarrier((&___P_2), value);
}
inline static int32_t get_offset_of_Q_3() { return static_cast<int32_t>(offsetof(RSAParameters_t1728406613, ___Q_3)); }
inline ByteU5BU5D_t4116647657* get_Q_3() const { return ___Q_3; }
inline ByteU5BU5D_t4116647657** get_address_of_Q_3() { return &___Q_3; }
inline void set_Q_3(ByteU5BU5D_t4116647657* value)
{
___Q_3 = value;
Il2CppCodeGenWriteBarrier((&___Q_3), value);
}
inline static int32_t get_offset_of_DP_4() { return static_cast<int32_t>(offsetof(RSAParameters_t1728406613, ___DP_4)); }
inline ByteU5BU5D_t4116647657* get_DP_4() const { return ___DP_4; }
inline ByteU5BU5D_t4116647657** get_address_of_DP_4() { return &___DP_4; }
inline void set_DP_4(ByteU5BU5D_t4116647657* value)
{
___DP_4 = value;
Il2CppCodeGenWriteBarrier((&___DP_4), value);
}
inline static int32_t get_offset_of_DQ_5() { return static_cast<int32_t>(offsetof(RSAParameters_t1728406613, ___DQ_5)); }
inline ByteU5BU5D_t4116647657* get_DQ_5() const { return ___DQ_5; }
inline ByteU5BU5D_t4116647657** get_address_of_DQ_5() { return &___DQ_5; }
inline void set_DQ_5(ByteU5BU5D_t4116647657* value)
{
___DQ_5 = value;
Il2CppCodeGenWriteBarrier((&___DQ_5), value);
}
inline static int32_t get_offset_of_InverseQ_6() { return static_cast<int32_t>(offsetof(RSAParameters_t1728406613, ___InverseQ_6)); }
inline ByteU5BU5D_t4116647657* get_InverseQ_6() const { return ___InverseQ_6; }
inline ByteU5BU5D_t4116647657** get_address_of_InverseQ_6() { return &___InverseQ_6; }
inline void set_InverseQ_6(ByteU5BU5D_t4116647657* value)
{
___InverseQ_6 = value;
Il2CppCodeGenWriteBarrier((&___InverseQ_6), value);
}
inline static int32_t get_offset_of_D_7() { return static_cast<int32_t>(offsetof(RSAParameters_t1728406613, ___D_7)); }
inline ByteU5BU5D_t4116647657* get_D_7() const { return ___D_7; }
inline ByteU5BU5D_t4116647657** get_address_of_D_7() { return &___D_7; }
inline void set_D_7(ByteU5BU5D_t4116647657* value)
{
___D_7 = value;
Il2CppCodeGenWriteBarrier((&___D_7), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Security.Cryptography.RSAParameters
struct RSAParameters_t1728406613_marshaled_pinvoke
{
uint8_t* ___Exponent_0;
uint8_t* ___Modulus_1;
uint8_t* ___P_2;
uint8_t* ___Q_3;
uint8_t* ___DP_4;
uint8_t* ___DQ_5;
uint8_t* ___InverseQ_6;
uint8_t* ___D_7;
};
// Native definition for COM marshalling of System.Security.Cryptography.RSAParameters
struct RSAParameters_t1728406613_marshaled_com
{
uint8_t* ___Exponent_0;
uint8_t* ___Modulus_1;
uint8_t* ___P_2;
uint8_t* ___Q_3;
uint8_t* ___DP_4;
uint8_t* ___DQ_5;
uint8_t* ___InverseQ_6;
uint8_t* ___D_7;
};
#endif // RSAPARAMETERS_T1728406613_H
#ifndef MD5_T3177620429_H
#define MD5_T3177620429_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.MD5
struct MD5_t3177620429 : public HashAlgorithm_t1432317219
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MD5_T3177620429_H
#ifndef PKCS1MASKGENERATIONMETHOD_T1129351447_H
#define PKCS1MASKGENERATIONMETHOD_T1129351447_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.PKCS1MaskGenerationMethod
struct PKCS1MaskGenerationMethod_t1129351447 : public MaskGenerationMethod_t2116484826
{
public:
// System.String System.Security.Cryptography.PKCS1MaskGenerationMethod::HashNameValue
String_t* ___HashNameValue_0;
public:
inline static int32_t get_offset_of_HashNameValue_0() { return static_cast<int32_t>(offsetof(PKCS1MaskGenerationMethod_t1129351447, ___HashNameValue_0)); }
inline String_t* get_HashNameValue_0() const { return ___HashNameValue_0; }
inline String_t** get_address_of_HashNameValue_0() { return &___HashNameValue_0; }
inline void set_HashNameValue_0(String_t* value)
{
___HashNameValue_0 = value;
Il2CppCodeGenWriteBarrier((&___HashNameValue_0), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PKCS1MASKGENERATIONMETHOD_T1129351447_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::enumSeperatorCharArray
CharU5BU5D_t3528271667* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t4135868527_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t3528271667* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t3528271667** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t3528271667* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((&___enumSeperatorCharArray_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 SHA512_T1346946930_H
#define SHA512_T1346946930_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SHA512
struct SHA512_t1346946930 : public HashAlgorithm_t1432317219
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SHA512_T1346946930_H
#ifndef RIPEMD160_T268675434_H
#define RIPEMD160_T268675434_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RIPEMD160
struct RIPEMD160_t268675434 : public HashAlgorithm_t1432317219
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RIPEMD160_T268675434_H
#ifndef STREAM_T1273022909_H
#define STREAM_T1273022909_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.IO.Stream
struct Stream_t1273022909 : public MarshalByRefObject_t2760389100
{
public:
// System.IO.Stream/ReadWriteTask System.IO.Stream::_activeReadWriteTask
ReadWriteTask_t156472862 * ____activeReadWriteTask_3;
// System.Threading.SemaphoreSlim System.IO.Stream::_asyncActiveSemaphore
SemaphoreSlim_t2974092902 * ____asyncActiveSemaphore_4;
public:
inline static int32_t get_offset_of__activeReadWriteTask_3() { return static_cast<int32_t>(offsetof(Stream_t1273022909, ____activeReadWriteTask_3)); }
inline ReadWriteTask_t156472862 * get__activeReadWriteTask_3() const { return ____activeReadWriteTask_3; }
inline ReadWriteTask_t156472862 ** get_address_of__activeReadWriteTask_3() { return &____activeReadWriteTask_3; }
inline void set__activeReadWriteTask_3(ReadWriteTask_t156472862 * value)
{
____activeReadWriteTask_3 = value;
Il2CppCodeGenWriteBarrier((&____activeReadWriteTask_3), value);
}
inline static int32_t get_offset_of__asyncActiveSemaphore_4() { return static_cast<int32_t>(offsetof(Stream_t1273022909, ____asyncActiveSemaphore_4)); }
inline SemaphoreSlim_t2974092902 * get__asyncActiveSemaphore_4() const { return ____asyncActiveSemaphore_4; }
inline SemaphoreSlim_t2974092902 ** get_address_of__asyncActiveSemaphore_4() { return &____asyncActiveSemaphore_4; }
inline void set__asyncActiveSemaphore_4(SemaphoreSlim_t2974092902 * value)
{
____asyncActiveSemaphore_4 = value;
Il2CppCodeGenWriteBarrier((&____asyncActiveSemaphore_4), value);
}
};
struct Stream_t1273022909_StaticFields
{
public:
// System.IO.Stream System.IO.Stream::Null
Stream_t1273022909 * ___Null_1;
public:
inline static int32_t get_offset_of_Null_1() { return static_cast<int32_t>(offsetof(Stream_t1273022909_StaticFields, ___Null_1)); }
inline Stream_t1273022909 * get_Null_1() const { return ___Null_1; }
inline Stream_t1273022909 ** get_address_of_Null_1() { return &___Null_1; }
inline void set_Null_1(Stream_t1273022909 * value)
{
___Null_1 = value;
Il2CppCodeGenWriteBarrier((&___Null_1), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STREAM_T1273022909_H
#ifndef NULLABLE_1_T1819850047_H
#define NULLABLE_1_T1819850047_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Nullable`1<System.Boolean>
struct Nullable_1_t1819850047
{
public:
// T System.Nullable`1::value
bool ___value_0;
// System.Boolean System.Nullable`1::has_value
bool ___has_value_1;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(Nullable_1_t1819850047, ___value_0)); }
inline bool get_value_0() const { return ___value_0; }
inline bool* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(bool value)
{
___value_0 = value;
}
inline static int32_t get_offset_of_has_value_1() { return static_cast<int32_t>(offsetof(Nullable_1_t1819850047, ___has_value_1)); }
inline bool get_has_value_1() const { return ___has_value_1; }
inline bool* get_address_of_has_value_1() { return &___has_value_1; }
inline void set_has_value_1(bool value)
{
___has_value_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // NULLABLE_1_T1819850047_H
#ifndef SHA384_T540967702_H
#define SHA384_T540967702_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SHA384
struct SHA384_t540967702 : public HashAlgorithm_t1432317219
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SHA384_T540967702_H
#ifndef ONDESERIALIZINGATTRIBUTE_T338753086_H
#define ONDESERIALIZINGATTRIBUTE_T338753086_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.OnDeserializingAttribute
struct OnDeserializingAttribute_t338753086 : public Attribute_t861562559
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ONDESERIALIZINGATTRIBUTE_T338753086_H
#ifndef DSA_T2386879874_H
#define DSA_T2386879874_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.DSA
struct DSA_t2386879874 : public AsymmetricAlgorithm_t932037087
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DSA_T2386879874_H
#ifndef ONSERIALIZEDATTRIBUTE_T2595932830_H
#define ONSERIALIZEDATTRIBUTE_T2595932830_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.OnSerializedAttribute
struct OnSerializedAttribute_t2595932830 : public Attribute_t861562559
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ONSERIALIZEDATTRIBUTE_T2595932830_H
#ifndef SHA256_T3672283617_H
#define SHA256_T3672283617_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SHA256
struct SHA256_t3672283617 : public HashAlgorithm_t1432317219
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SHA256_T3672283617_H
#ifndef KEYEDHASHALGORITHM_T112861511_H
#define KEYEDHASHALGORITHM_T112861511_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.KeyedHashAlgorithm
struct KeyedHashAlgorithm_t112861511 : public HashAlgorithm_t1432317219
{
public:
// System.Byte[] System.Security.Cryptography.KeyedHashAlgorithm::KeyValue
ByteU5BU5D_t4116647657* ___KeyValue_4;
public:
inline static int32_t get_offset_of_KeyValue_4() { return static_cast<int32_t>(offsetof(KeyedHashAlgorithm_t112861511, ___KeyValue_4)); }
inline ByteU5BU5D_t4116647657* get_KeyValue_4() const { return ___KeyValue_4; }
inline ByteU5BU5D_t4116647657** get_address_of_KeyValue_4() { return &___KeyValue_4; }
inline void set_KeyValue_4(ByteU5BU5D_t4116647657* value)
{
___KeyValue_4 = value;
Il2CppCodeGenWriteBarrier((&___KeyValue_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // KEYEDHASHALGORITHM_T112861511_H
#ifndef ONDESERIALIZEDATTRIBUTE_T1335880599_H
#define ONDESERIALIZEDATTRIBUTE_T1335880599_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.OnDeserializedAttribute
struct OnDeserializedAttribute_t1335880599 : public Attribute_t861562559
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // ONDESERIALIZEDATTRIBUTE_T1335880599_H
#ifndef SHA1_T1803193667_H
#define SHA1_T1803193667_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SHA1
struct SHA1_t1803193667 : public HashAlgorithm_t1432317219
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SHA1_T1803193667_H
#ifndef PADDINGMODE_T2546806710_H
#define PADDINGMODE_T2546806710_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.PaddingMode
struct PaddingMode_t2546806710
{
public:
// System.Int32 System.Security.Cryptography.PaddingMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(PaddingMode_t2546806710, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // PADDINGMODE_T2546806710_H
#ifndef FORMATTERSERVICES_T305532257_H
#define FORMATTERSERVICES_T305532257_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.FormatterServices
struct FormatterServices_t305532257 : public RuntimeObject
{
public:
public:
};
struct FormatterServices_t305532257_StaticFields
{
public:
// System.Collections.Generic.Dictionary`2<System.Runtime.Serialization.MemberHolder,System.Reflection.MemberInfo[]> System.Runtime.Serialization.FormatterServices::m_MemberInfoTable
Dictionary_2_t3564581838 * ___m_MemberInfoTable_0;
// System.Boolean System.Runtime.Serialization.FormatterServices::unsafeTypeForwardersIsEnabled
bool ___unsafeTypeForwardersIsEnabled_1;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.Runtime.Serialization.FormatterServices::unsafeTypeForwardersIsEnabledInitialized
bool ___unsafeTypeForwardersIsEnabledInitialized_2;
// System.Object System.Runtime.Serialization.FormatterServices::s_FormatterServicesSyncObject
RuntimeObject * ___s_FormatterServicesSyncObject_3;
// System.Type[] System.Runtime.Serialization.FormatterServices::advancedTypes
TypeU5BU5D_t3940880105* ___advancedTypes_4;
// System.Reflection.Binder System.Runtime.Serialization.FormatterServices::s_binder
Binder_t2999457153 * ___s_binder_5;
public:
inline static int32_t get_offset_of_m_MemberInfoTable_0() { return static_cast<int32_t>(offsetof(FormatterServices_t305532257_StaticFields, ___m_MemberInfoTable_0)); }
inline Dictionary_2_t3564581838 * get_m_MemberInfoTable_0() const { return ___m_MemberInfoTable_0; }
inline Dictionary_2_t3564581838 ** get_address_of_m_MemberInfoTable_0() { return &___m_MemberInfoTable_0; }
inline void set_m_MemberInfoTable_0(Dictionary_2_t3564581838 * value)
{
___m_MemberInfoTable_0 = value;
Il2CppCodeGenWriteBarrier((&___m_MemberInfoTable_0), value);
}
inline static int32_t get_offset_of_unsafeTypeForwardersIsEnabled_1() { return static_cast<int32_t>(offsetof(FormatterServices_t305532257_StaticFields, ___unsafeTypeForwardersIsEnabled_1)); }
inline bool get_unsafeTypeForwardersIsEnabled_1() const { return ___unsafeTypeForwardersIsEnabled_1; }
inline bool* get_address_of_unsafeTypeForwardersIsEnabled_1() { return &___unsafeTypeForwardersIsEnabled_1; }
inline void set_unsafeTypeForwardersIsEnabled_1(bool value)
{
___unsafeTypeForwardersIsEnabled_1 = value;
}
inline static int32_t get_offset_of_unsafeTypeForwardersIsEnabledInitialized_2() { return static_cast<int32_t>(offsetof(FormatterServices_t305532257_StaticFields, ___unsafeTypeForwardersIsEnabledInitialized_2)); }
inline bool get_unsafeTypeForwardersIsEnabledInitialized_2() const { return ___unsafeTypeForwardersIsEnabledInitialized_2; }
inline bool* get_address_of_unsafeTypeForwardersIsEnabledInitialized_2() { return &___unsafeTypeForwardersIsEnabledInitialized_2; }
inline void set_unsafeTypeForwardersIsEnabledInitialized_2(bool value)
{
___unsafeTypeForwardersIsEnabledInitialized_2 = value;
}
inline static int32_t get_offset_of_s_FormatterServicesSyncObject_3() { return static_cast<int32_t>(offsetof(FormatterServices_t305532257_StaticFields, ___s_FormatterServicesSyncObject_3)); }
inline RuntimeObject * get_s_FormatterServicesSyncObject_3() const { return ___s_FormatterServicesSyncObject_3; }
inline RuntimeObject ** get_address_of_s_FormatterServicesSyncObject_3() { return &___s_FormatterServicesSyncObject_3; }
inline void set_s_FormatterServicesSyncObject_3(RuntimeObject * value)
{
___s_FormatterServicesSyncObject_3 = value;
Il2CppCodeGenWriteBarrier((&___s_FormatterServicesSyncObject_3), value);
}
inline static int32_t get_offset_of_advancedTypes_4() { return static_cast<int32_t>(offsetof(FormatterServices_t305532257_StaticFields, ___advancedTypes_4)); }
inline TypeU5BU5D_t3940880105* get_advancedTypes_4() const { return ___advancedTypes_4; }
inline TypeU5BU5D_t3940880105** get_address_of_advancedTypes_4() { return &___advancedTypes_4; }
inline void set_advancedTypes_4(TypeU5BU5D_t3940880105* value)
{
___advancedTypes_4 = value;
Il2CppCodeGenWriteBarrier((&___advancedTypes_4), value);
}
inline static int32_t get_offset_of_s_binder_5() { return static_cast<int32_t>(offsetof(FormatterServices_t305532257_StaticFields, ___s_binder_5)); }
inline Binder_t2999457153 * get_s_binder_5() const { return ___s_binder_5; }
inline Binder_t2999457153 ** get_address_of_s_binder_5() { return &___s_binder_5; }
inline void set_s_binder_5(Binder_t2999457153 * value)
{
___s_binder_5 = value;
Il2CppCodeGenWriteBarrier((&___s_binder_5), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // FORMATTERSERVICES_T305532257_H
#ifndef DELEGATE_T1188392813_H
#define DELEGATE_T1188392813_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Delegate
struct Delegate_t1188392813 : public RuntimeObject
{
public:
// System.IntPtr System.Delegate::method_ptr
Il2CppMethodPointer ___method_ptr_0;
// System.IntPtr System.Delegate::invoke_impl
intptr_t ___invoke_impl_1;
// System.Object System.Delegate::m_target
RuntimeObject * ___m_target_2;
// System.IntPtr System.Delegate::method
intptr_t ___method_3;
// System.IntPtr System.Delegate::delegate_trampoline
intptr_t ___delegate_trampoline_4;
// System.IntPtr System.Delegate::extra_arg
intptr_t ___extra_arg_5;
// System.IntPtr System.Delegate::method_code
intptr_t ___method_code_6;
// System.Reflection.MethodInfo System.Delegate::method_info
MethodInfo_t * ___method_info_7;
// System.Reflection.MethodInfo System.Delegate::original_method_info
MethodInfo_t * ___original_method_info_8;
// System.DelegateData System.Delegate::data
DelegateData_t1677132599 * ___data_9;
// System.Boolean System.Delegate::method_is_virtual
bool ___method_is_virtual_10;
public:
inline static int32_t get_offset_of_method_ptr_0() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_ptr_0)); }
inline Il2CppMethodPointer get_method_ptr_0() const { return ___method_ptr_0; }
inline Il2CppMethodPointer* get_address_of_method_ptr_0() { return &___method_ptr_0; }
inline void set_method_ptr_0(Il2CppMethodPointer value)
{
___method_ptr_0 = value;
}
inline static int32_t get_offset_of_invoke_impl_1() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___invoke_impl_1)); }
inline intptr_t get_invoke_impl_1() const { return ___invoke_impl_1; }
inline intptr_t* get_address_of_invoke_impl_1() { return &___invoke_impl_1; }
inline void set_invoke_impl_1(intptr_t value)
{
___invoke_impl_1 = value;
}
inline static int32_t get_offset_of_m_target_2() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___m_target_2)); }
inline RuntimeObject * get_m_target_2() const { return ___m_target_2; }
inline RuntimeObject ** get_address_of_m_target_2() { return &___m_target_2; }
inline void set_m_target_2(RuntimeObject * value)
{
___m_target_2 = value;
Il2CppCodeGenWriteBarrier((&___m_target_2), value);
}
inline static int32_t get_offset_of_method_3() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_3)); }
inline intptr_t get_method_3() const { return ___method_3; }
inline intptr_t* get_address_of_method_3() { return &___method_3; }
inline void set_method_3(intptr_t value)
{
___method_3 = value;
}
inline static int32_t get_offset_of_delegate_trampoline_4() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___delegate_trampoline_4)); }
inline intptr_t get_delegate_trampoline_4() const { return ___delegate_trampoline_4; }
inline intptr_t* get_address_of_delegate_trampoline_4() { return &___delegate_trampoline_4; }
inline void set_delegate_trampoline_4(intptr_t value)
{
___delegate_trampoline_4 = value;
}
inline static int32_t get_offset_of_extra_arg_5() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___extra_arg_5)); }
inline intptr_t get_extra_arg_5() const { return ___extra_arg_5; }
inline intptr_t* get_address_of_extra_arg_5() { return &___extra_arg_5; }
inline void set_extra_arg_5(intptr_t value)
{
___extra_arg_5 = value;
}
inline static int32_t get_offset_of_method_code_6() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_code_6)); }
inline intptr_t get_method_code_6() const { return ___method_code_6; }
inline intptr_t* get_address_of_method_code_6() { return &___method_code_6; }
inline void set_method_code_6(intptr_t value)
{
___method_code_6 = value;
}
inline static int32_t get_offset_of_method_info_7() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_info_7)); }
inline MethodInfo_t * get_method_info_7() const { return ___method_info_7; }
inline MethodInfo_t ** get_address_of_method_info_7() { return &___method_info_7; }
inline void set_method_info_7(MethodInfo_t * value)
{
___method_info_7 = value;
Il2CppCodeGenWriteBarrier((&___method_info_7), value);
}
inline static int32_t get_offset_of_original_method_info_8() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___original_method_info_8)); }
inline MethodInfo_t * get_original_method_info_8() const { return ___original_method_info_8; }
inline MethodInfo_t ** get_address_of_original_method_info_8() { return &___original_method_info_8; }
inline void set_original_method_info_8(MethodInfo_t * value)
{
___original_method_info_8 = value;
Il2CppCodeGenWriteBarrier((&___original_method_info_8), value);
}
inline static int32_t get_offset_of_data_9() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___data_9)); }
inline DelegateData_t1677132599 * get_data_9() const { return ___data_9; }
inline DelegateData_t1677132599 ** get_address_of_data_9() { return &___data_9; }
inline void set_data_9(DelegateData_t1677132599 * value)
{
___data_9 = value;
Il2CppCodeGenWriteBarrier((&___data_9), value);
}
inline static int32_t get_offset_of_method_is_virtual_10() { return static_cast<int32_t>(offsetof(Delegate_t1188392813, ___method_is_virtual_10)); }
inline bool get_method_is_virtual_10() const { return ___method_is_virtual_10; }
inline bool* get_address_of_method_is_virtual_10() { return &___method_is_virtual_10; }
inline void set_method_is_virtual_10(bool value)
{
___method_is_virtual_10 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Delegate
struct Delegate_t1188392813_marshaled_pinvoke
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1677132599 * ___data_9;
int32_t ___method_is_virtual_10;
};
// Native definition for COM marshalling of System.Delegate
struct Delegate_t1188392813_marshaled_com
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1677132599 * ___data_9;
int32_t ___method_is_virtual_10;
};
#endif // DELEGATE_T1188392813_H
#ifndef CIPHERMODE_T84635067_H
#define CIPHERMODE_T84635067_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.CipherMode
struct CipherMode_t84635067
{
public:
// System.Int32 System.Security.Cryptography.CipherMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(CipherMode_t84635067, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // CIPHERMODE_T84635067_H
#ifndef SHA256MANAGED_T955042874_H
#define SHA256MANAGED_T955042874_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SHA256Managed
struct SHA256Managed_t955042874 : public SHA256_t3672283617
{
public:
// System.Byte[] System.Security.Cryptography.SHA256Managed::_buffer
ByteU5BU5D_t4116647657* ____buffer_4;
// System.Int64 System.Security.Cryptography.SHA256Managed::_count
int64_t ____count_5;
// System.UInt32[] System.Security.Cryptography.SHA256Managed::_stateSHA256
UInt32U5BU5D_t2770800703* ____stateSHA256_6;
// System.UInt32[] System.Security.Cryptography.SHA256Managed::_W
UInt32U5BU5D_t2770800703* ____W_7;
public:
inline static int32_t get_offset_of__buffer_4() { return static_cast<int32_t>(offsetof(SHA256Managed_t955042874, ____buffer_4)); }
inline ByteU5BU5D_t4116647657* get__buffer_4() const { return ____buffer_4; }
inline ByteU5BU5D_t4116647657** get_address_of__buffer_4() { return &____buffer_4; }
inline void set__buffer_4(ByteU5BU5D_t4116647657* value)
{
____buffer_4 = value;
Il2CppCodeGenWriteBarrier((&____buffer_4), value);
}
inline static int32_t get_offset_of__count_5() { return static_cast<int32_t>(offsetof(SHA256Managed_t955042874, ____count_5)); }
inline int64_t get__count_5() const { return ____count_5; }
inline int64_t* get_address_of__count_5() { return &____count_5; }
inline void set__count_5(int64_t value)
{
____count_5 = value;
}
inline static int32_t get_offset_of__stateSHA256_6() { return static_cast<int32_t>(offsetof(SHA256Managed_t955042874, ____stateSHA256_6)); }
inline UInt32U5BU5D_t2770800703* get__stateSHA256_6() const { return ____stateSHA256_6; }
inline UInt32U5BU5D_t2770800703** get_address_of__stateSHA256_6() { return &____stateSHA256_6; }
inline void set__stateSHA256_6(UInt32U5BU5D_t2770800703* value)
{
____stateSHA256_6 = value;
Il2CppCodeGenWriteBarrier((&____stateSHA256_6), value);
}
inline static int32_t get_offset_of__W_7() { return static_cast<int32_t>(offsetof(SHA256Managed_t955042874, ____W_7)); }
inline UInt32U5BU5D_t2770800703* get__W_7() const { return ____W_7; }
inline UInt32U5BU5D_t2770800703** get_address_of__W_7() { return &____W_7; }
inline void set__W_7(UInt32U5BU5D_t2770800703* value)
{
____W_7 = value;
Il2CppCodeGenWriteBarrier((&____W_7), value);
}
};
struct SHA256Managed_t955042874_StaticFields
{
public:
// System.UInt32[] System.Security.Cryptography.SHA256Managed::_K
UInt32U5BU5D_t2770800703* ____K_8;
public:
inline static int32_t get_offset_of__K_8() { return static_cast<int32_t>(offsetof(SHA256Managed_t955042874_StaticFields, ____K_8)); }
inline UInt32U5BU5D_t2770800703* get__K_8() const { return ____K_8; }
inline UInt32U5BU5D_t2770800703** get_address_of__K_8() { return &____K_8; }
inline void set__K_8(UInt32U5BU5D_t2770800703* value)
{
____K_8 = value;
Il2CppCodeGenWriteBarrier((&____K_8), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SHA256MANAGED_T955042874_H
#ifndef SHA1MANAGED_T1754513891_H
#define SHA1MANAGED_T1754513891_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SHA1Managed
struct SHA1Managed_t1754513891 : public SHA1_t1803193667
{
public:
// System.Byte[] System.Security.Cryptography.SHA1Managed::_buffer
ByteU5BU5D_t4116647657* ____buffer_4;
// System.Int64 System.Security.Cryptography.SHA1Managed::_count
int64_t ____count_5;
// System.UInt32[] System.Security.Cryptography.SHA1Managed::_stateSHA1
UInt32U5BU5D_t2770800703* ____stateSHA1_6;
// System.UInt32[] System.Security.Cryptography.SHA1Managed::_expandedBuffer
UInt32U5BU5D_t2770800703* ____expandedBuffer_7;
public:
inline static int32_t get_offset_of__buffer_4() { return static_cast<int32_t>(offsetof(SHA1Managed_t1754513891, ____buffer_4)); }
inline ByteU5BU5D_t4116647657* get__buffer_4() const { return ____buffer_4; }
inline ByteU5BU5D_t4116647657** get_address_of__buffer_4() { return &____buffer_4; }
inline void set__buffer_4(ByteU5BU5D_t4116647657* value)
{
____buffer_4 = value;
Il2CppCodeGenWriteBarrier((&____buffer_4), value);
}
inline static int32_t get_offset_of__count_5() { return static_cast<int32_t>(offsetof(SHA1Managed_t1754513891, ____count_5)); }
inline int64_t get__count_5() const { return ____count_5; }
inline int64_t* get_address_of__count_5() { return &____count_5; }
inline void set__count_5(int64_t value)
{
____count_5 = value;
}
inline static int32_t get_offset_of__stateSHA1_6() { return static_cast<int32_t>(offsetof(SHA1Managed_t1754513891, ____stateSHA1_6)); }
inline UInt32U5BU5D_t2770800703* get__stateSHA1_6() const { return ____stateSHA1_6; }
inline UInt32U5BU5D_t2770800703** get_address_of__stateSHA1_6() { return &____stateSHA1_6; }
inline void set__stateSHA1_6(UInt32U5BU5D_t2770800703* value)
{
____stateSHA1_6 = value;
Il2CppCodeGenWriteBarrier((&____stateSHA1_6), value);
}
inline static int32_t get_offset_of__expandedBuffer_7() { return static_cast<int32_t>(offsetof(SHA1Managed_t1754513891, ____expandedBuffer_7)); }
inline UInt32U5BU5D_t2770800703* get__expandedBuffer_7() const { return ____expandedBuffer_7; }
inline UInt32U5BU5D_t2770800703** get_address_of__expandedBuffer_7() { return &____expandedBuffer_7; }
inline void set__expandedBuffer_7(UInt32U5BU5D_t2770800703* value)
{
____expandedBuffer_7 = value;
Il2CppCodeGenWriteBarrier((&____expandedBuffer_7), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SHA1MANAGED_T1754513891_H
#ifndef RSAENCRYPTIONPADDINGMODE_T4163793404_H
#define RSAENCRYPTIONPADDINGMODE_T4163793404_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAEncryptionPaddingMode
struct RSAEncryptionPaddingMode_t4163793404
{
public:
// System.Int32 System.Security.Cryptography.RSAEncryptionPaddingMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(RSAEncryptionPaddingMode_t4163793404, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAENCRYPTIONPADDINGMODE_T4163793404_H
#ifndef SHA384MANAGED_T74158575_H
#define SHA384MANAGED_T74158575_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SHA384Managed
struct SHA384Managed_t74158575 : public SHA384_t540967702
{
public:
// System.Byte[] System.Security.Cryptography.SHA384Managed::_buffer
ByteU5BU5D_t4116647657* ____buffer_4;
// System.UInt64 System.Security.Cryptography.SHA384Managed::_count
uint64_t ____count_5;
// System.UInt64[] System.Security.Cryptography.SHA384Managed::_stateSHA384
UInt64U5BU5D_t1659327989* ____stateSHA384_6;
// System.UInt64[] System.Security.Cryptography.SHA384Managed::_W
UInt64U5BU5D_t1659327989* ____W_7;
public:
inline static int32_t get_offset_of__buffer_4() { return static_cast<int32_t>(offsetof(SHA384Managed_t74158575, ____buffer_4)); }
inline ByteU5BU5D_t4116647657* get__buffer_4() const { return ____buffer_4; }
inline ByteU5BU5D_t4116647657** get_address_of__buffer_4() { return &____buffer_4; }
inline void set__buffer_4(ByteU5BU5D_t4116647657* value)
{
____buffer_4 = value;
Il2CppCodeGenWriteBarrier((&____buffer_4), value);
}
inline static int32_t get_offset_of__count_5() { return static_cast<int32_t>(offsetof(SHA384Managed_t74158575, ____count_5)); }
inline uint64_t get__count_5() const { return ____count_5; }
inline uint64_t* get_address_of__count_5() { return &____count_5; }
inline void set__count_5(uint64_t value)
{
____count_5 = value;
}
inline static int32_t get_offset_of__stateSHA384_6() { return static_cast<int32_t>(offsetof(SHA384Managed_t74158575, ____stateSHA384_6)); }
inline UInt64U5BU5D_t1659327989* get__stateSHA384_6() const { return ____stateSHA384_6; }
inline UInt64U5BU5D_t1659327989** get_address_of__stateSHA384_6() { return &____stateSHA384_6; }
inline void set__stateSHA384_6(UInt64U5BU5D_t1659327989* value)
{
____stateSHA384_6 = value;
Il2CppCodeGenWriteBarrier((&____stateSHA384_6), value);
}
inline static int32_t get_offset_of__W_7() { return static_cast<int32_t>(offsetof(SHA384Managed_t74158575, ____W_7)); }
inline UInt64U5BU5D_t1659327989* get__W_7() const { return ____W_7; }
inline UInt64U5BU5D_t1659327989** get_address_of__W_7() { return &____W_7; }
inline void set__W_7(UInt64U5BU5D_t1659327989* value)
{
____W_7 = value;
Il2CppCodeGenWriteBarrier((&____W_7), value);
}
};
struct SHA384Managed_t74158575_StaticFields
{
public:
// System.UInt64[] System.Security.Cryptography.SHA384Managed::_K
UInt64U5BU5D_t1659327989* ____K_8;
public:
inline static int32_t get_offset_of__K_8() { return static_cast<int32_t>(offsetof(SHA384Managed_t74158575_StaticFields, ____K_8)); }
inline UInt64U5BU5D_t1659327989* get__K_8() const { return ____K_8; }
inline UInt64U5BU5D_t1659327989** get_address_of__K_8() { return &____K_8; }
inline void set__K_8(UInt64U5BU5D_t1659327989* value)
{
____K_8 = value;
Il2CppCodeGenWriteBarrier((&____K_8), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SHA384MANAGED_T74158575_H
#ifndef RSAPKCS1SHA256SIGNATUREDESCRIPTION_T4122087809_H
#define RSAPKCS1SHA256SIGNATUREDESCRIPTION_T4122087809_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAPKCS1SHA256SignatureDescription
struct RSAPKCS1SHA256SignatureDescription_t4122087809 : public RSAPKCS1SignatureDescription_t653172199
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAPKCS1SHA256SIGNATUREDESCRIPTION_T4122087809_H
#ifndef RSAPKCS1SHA1SIGNATUREDESCRIPTION_T2887980541_H
#define RSAPKCS1SHA1SIGNATUREDESCRIPTION_T2887980541_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAPKCS1SHA1SignatureDescription
struct RSAPKCS1SHA1SignatureDescription_t2887980541 : public RSAPKCS1SignatureDescription_t653172199
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAPKCS1SHA1SIGNATUREDESCRIPTION_T2887980541_H
#ifndef SHA512MANAGED_T1787336339_H
#define SHA512MANAGED_T1787336339_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SHA512Managed
struct SHA512Managed_t1787336339 : public SHA512_t1346946930
{
public:
// System.Byte[] System.Security.Cryptography.SHA512Managed::_buffer
ByteU5BU5D_t4116647657* ____buffer_4;
// System.UInt64 System.Security.Cryptography.SHA512Managed::_count
uint64_t ____count_5;
// System.UInt64[] System.Security.Cryptography.SHA512Managed::_stateSHA512
UInt64U5BU5D_t1659327989* ____stateSHA512_6;
// System.UInt64[] System.Security.Cryptography.SHA512Managed::_W
UInt64U5BU5D_t1659327989* ____W_7;
public:
inline static int32_t get_offset_of__buffer_4() { return static_cast<int32_t>(offsetof(SHA512Managed_t1787336339, ____buffer_4)); }
inline ByteU5BU5D_t4116647657* get__buffer_4() const { return ____buffer_4; }
inline ByteU5BU5D_t4116647657** get_address_of__buffer_4() { return &____buffer_4; }
inline void set__buffer_4(ByteU5BU5D_t4116647657* value)
{
____buffer_4 = value;
Il2CppCodeGenWriteBarrier((&____buffer_4), value);
}
inline static int32_t get_offset_of__count_5() { return static_cast<int32_t>(offsetof(SHA512Managed_t1787336339, ____count_5)); }
inline uint64_t get__count_5() const { return ____count_5; }
inline uint64_t* get_address_of__count_5() { return &____count_5; }
inline void set__count_5(uint64_t value)
{
____count_5 = value;
}
inline static int32_t get_offset_of__stateSHA512_6() { return static_cast<int32_t>(offsetof(SHA512Managed_t1787336339, ____stateSHA512_6)); }
inline UInt64U5BU5D_t1659327989* get__stateSHA512_6() const { return ____stateSHA512_6; }
inline UInt64U5BU5D_t1659327989** get_address_of__stateSHA512_6() { return &____stateSHA512_6; }
inline void set__stateSHA512_6(UInt64U5BU5D_t1659327989* value)
{
____stateSHA512_6 = value;
Il2CppCodeGenWriteBarrier((&____stateSHA512_6), value);
}
inline static int32_t get_offset_of__W_7() { return static_cast<int32_t>(offsetof(SHA512Managed_t1787336339, ____W_7)); }
inline UInt64U5BU5D_t1659327989* get__W_7() const { return ____W_7; }
inline UInt64U5BU5D_t1659327989** get_address_of__W_7() { return &____W_7; }
inline void set__W_7(UInt64U5BU5D_t1659327989* value)
{
____W_7 = value;
Il2CppCodeGenWriteBarrier((&____W_7), value);
}
};
struct SHA512Managed_t1787336339_StaticFields
{
public:
// System.UInt64[] System.Security.Cryptography.SHA512Managed::_K
UInt64U5BU5D_t1659327989* ____K_8;
public:
inline static int32_t get_offset_of__K_8() { return static_cast<int32_t>(offsetof(SHA512Managed_t1787336339_StaticFields, ____K_8)); }
inline UInt64U5BU5D_t1659327989* get__K_8() const { return ____K_8; }
inline UInt64U5BU5D_t1659327989** get_address_of__K_8() { return &____K_8; }
inline void set__K_8(UInt64U5BU5D_t1659327989* value)
{
____K_8 = value;
Il2CppCodeGenWriteBarrier((&____K_8), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SHA512MANAGED_T1787336339_H
#ifndef RIJNDAELMANAGEDTRANSFORMMODE_T144661339_H
#define RIJNDAELMANAGEDTRANSFORMMODE_T144661339_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RijndaelManagedTransformMode
struct RijndaelManagedTransformMode_t144661339
{
public:
// System.Int32 System.Security.Cryptography.RijndaelManagedTransformMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(RijndaelManagedTransformMode_t144661339, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RIJNDAELMANAGEDTRANSFORMMODE_T144661339_H
#ifndef MACTRIPLEDES_T1631262397_H
#define MACTRIPLEDES_T1631262397_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.MACTripleDES
struct MACTripleDES_t1631262397 : public KeyedHashAlgorithm_t112861511
{
public:
// System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.MACTripleDES::m_encryptor
RuntimeObject* ___m_encryptor_5;
// System.Security.Cryptography.CryptoStream System.Security.Cryptography.MACTripleDES::_cs
CryptoStream_t2702504504 * ____cs_6;
// System.Security.Cryptography.TailStream System.Security.Cryptography.MACTripleDES::_ts
TailStream_t1447577651 * ____ts_7;
// System.Int32 System.Security.Cryptography.MACTripleDES::m_bytesPerBlock
int32_t ___m_bytesPerBlock_8;
// System.Security.Cryptography.TripleDES System.Security.Cryptography.MACTripleDES::des
TripleDES_t92303514 * ___des_9;
public:
inline static int32_t get_offset_of_m_encryptor_5() { return static_cast<int32_t>(offsetof(MACTripleDES_t1631262397, ___m_encryptor_5)); }
inline RuntimeObject* get_m_encryptor_5() const { return ___m_encryptor_5; }
inline RuntimeObject** get_address_of_m_encryptor_5() { return &___m_encryptor_5; }
inline void set_m_encryptor_5(RuntimeObject* value)
{
___m_encryptor_5 = value;
Il2CppCodeGenWriteBarrier((&___m_encryptor_5), value);
}
inline static int32_t get_offset_of__cs_6() { return static_cast<int32_t>(offsetof(MACTripleDES_t1631262397, ____cs_6)); }
inline CryptoStream_t2702504504 * get__cs_6() const { return ____cs_6; }
inline CryptoStream_t2702504504 ** get_address_of__cs_6() { return &____cs_6; }
inline void set__cs_6(CryptoStream_t2702504504 * value)
{
____cs_6 = value;
Il2CppCodeGenWriteBarrier((&____cs_6), value);
}
inline static int32_t get_offset_of__ts_7() { return static_cast<int32_t>(offsetof(MACTripleDES_t1631262397, ____ts_7)); }
inline TailStream_t1447577651 * get__ts_7() const { return ____ts_7; }
inline TailStream_t1447577651 ** get_address_of__ts_7() { return &____ts_7; }
inline void set__ts_7(TailStream_t1447577651 * value)
{
____ts_7 = value;
Il2CppCodeGenWriteBarrier((&____ts_7), value);
}
inline static int32_t get_offset_of_m_bytesPerBlock_8() { return static_cast<int32_t>(offsetof(MACTripleDES_t1631262397, ___m_bytesPerBlock_8)); }
inline int32_t get_m_bytesPerBlock_8() const { return ___m_bytesPerBlock_8; }
inline int32_t* get_address_of_m_bytesPerBlock_8() { return &___m_bytesPerBlock_8; }
inline void set_m_bytesPerBlock_8(int32_t value)
{
___m_bytesPerBlock_8 = value;
}
inline static int32_t get_offset_of_des_9() { return static_cast<int32_t>(offsetof(MACTripleDES_t1631262397, ___des_9)); }
inline TripleDES_t92303514 * get_des_9() const { return ___des_9; }
inline TripleDES_t92303514 ** get_address_of_des_9() { return &___des_9; }
inline void set_des_9(TripleDES_t92303514 * value)
{
___des_9 = value;
Il2CppCodeGenWriteBarrier((&___des_9), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MACTRIPLEDES_T1631262397_H
#ifndef TAILSTREAM_T1447577651_H
#define TAILSTREAM_T1447577651_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.TailStream
struct TailStream_t1447577651 : public Stream_t1273022909
{
public:
// System.Byte[] System.Security.Cryptography.TailStream::_Buffer
ByteU5BU5D_t4116647657* ____Buffer_5;
// System.Int32 System.Security.Cryptography.TailStream::_BufferSize
int32_t ____BufferSize_6;
// System.Int32 System.Security.Cryptography.TailStream::_BufferIndex
int32_t ____BufferIndex_7;
// System.Boolean System.Security.Cryptography.TailStream::_BufferFull
bool ____BufferFull_8;
public:
inline static int32_t get_offset_of__Buffer_5() { return static_cast<int32_t>(offsetof(TailStream_t1447577651, ____Buffer_5)); }
inline ByteU5BU5D_t4116647657* get__Buffer_5() const { return ____Buffer_5; }
inline ByteU5BU5D_t4116647657** get_address_of__Buffer_5() { return &____Buffer_5; }
inline void set__Buffer_5(ByteU5BU5D_t4116647657* value)
{
____Buffer_5 = value;
Il2CppCodeGenWriteBarrier((&____Buffer_5), value);
}
inline static int32_t get_offset_of__BufferSize_6() { return static_cast<int32_t>(offsetof(TailStream_t1447577651, ____BufferSize_6)); }
inline int32_t get__BufferSize_6() const { return ____BufferSize_6; }
inline int32_t* get_address_of__BufferSize_6() { return &____BufferSize_6; }
inline void set__BufferSize_6(int32_t value)
{
____BufferSize_6 = value;
}
inline static int32_t get_offset_of__BufferIndex_7() { return static_cast<int32_t>(offsetof(TailStream_t1447577651, ____BufferIndex_7)); }
inline int32_t get__BufferIndex_7() const { return ____BufferIndex_7; }
inline int32_t* get_address_of__BufferIndex_7() { return &____BufferIndex_7; }
inline void set__BufferIndex_7(int32_t value)
{
____BufferIndex_7 = value;
}
inline static int32_t get_offset_of__BufferFull_8() { return static_cast<int32_t>(offsetof(TailStream_t1447577651, ____BufferFull_8)); }
inline bool get__BufferFull_8() const { return ____BufferFull_8; }
inline bool* get_address_of__BufferFull_8() { return &____BufferFull_8; }
inline void set__BufferFull_8(bool value)
{
____BufferFull_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TAILSTREAM_T1447577651_H
#ifndef RIPEMD160MANAGED_T2491561941_H
#define RIPEMD160MANAGED_T2491561941_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RIPEMD160Managed
struct RIPEMD160Managed_t2491561941 : public RIPEMD160_t268675434
{
public:
// System.Byte[] System.Security.Cryptography.RIPEMD160Managed::_buffer
ByteU5BU5D_t4116647657* ____buffer_4;
// System.Int64 System.Security.Cryptography.RIPEMD160Managed::_count
int64_t ____count_5;
// System.UInt32[] System.Security.Cryptography.RIPEMD160Managed::_stateMD160
UInt32U5BU5D_t2770800703* ____stateMD160_6;
// System.UInt32[] System.Security.Cryptography.RIPEMD160Managed::_blockDWords
UInt32U5BU5D_t2770800703* ____blockDWords_7;
public:
inline static int32_t get_offset_of__buffer_4() { return static_cast<int32_t>(offsetof(RIPEMD160Managed_t2491561941, ____buffer_4)); }
inline ByteU5BU5D_t4116647657* get__buffer_4() const { return ____buffer_4; }
inline ByteU5BU5D_t4116647657** get_address_of__buffer_4() { return &____buffer_4; }
inline void set__buffer_4(ByteU5BU5D_t4116647657* value)
{
____buffer_4 = value;
Il2CppCodeGenWriteBarrier((&____buffer_4), value);
}
inline static int32_t get_offset_of__count_5() { return static_cast<int32_t>(offsetof(RIPEMD160Managed_t2491561941, ____count_5)); }
inline int64_t get__count_5() const { return ____count_5; }
inline int64_t* get_address_of__count_5() { return &____count_5; }
inline void set__count_5(int64_t value)
{
____count_5 = value;
}
inline static int32_t get_offset_of__stateMD160_6() { return static_cast<int32_t>(offsetof(RIPEMD160Managed_t2491561941, ____stateMD160_6)); }
inline UInt32U5BU5D_t2770800703* get__stateMD160_6() const { return ____stateMD160_6; }
inline UInt32U5BU5D_t2770800703** get_address_of__stateMD160_6() { return &____stateMD160_6; }
inline void set__stateMD160_6(UInt32U5BU5D_t2770800703* value)
{
____stateMD160_6 = value;
Il2CppCodeGenWriteBarrier((&____stateMD160_6), value);
}
inline static int32_t get_offset_of__blockDWords_7() { return static_cast<int32_t>(offsetof(RIPEMD160Managed_t2491561941, ____blockDWords_7)); }
inline UInt32U5BU5D_t2770800703* get__blockDWords_7() const { return ____blockDWords_7; }
inline UInt32U5BU5D_t2770800703** get_address_of__blockDWords_7() { return &____blockDWords_7; }
inline void set__blockDWords_7(UInt32U5BU5D_t2770800703* value)
{
____blockDWords_7 = value;
Il2CppCodeGenWriteBarrier((&____blockDWords_7), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RIPEMD160MANAGED_T2491561941_H
#ifndef RSAPKCS1KEYEXCHANGEDEFORMATTER_T2578812791_H
#define RSAPKCS1KEYEXCHANGEDEFORMATTER_T2578812791_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAPKCS1KeyExchangeDeformatter
struct RSAPKCS1KeyExchangeDeformatter_t2578812791 : public AsymmetricKeyExchangeDeformatter_t3370779160
{
public:
// System.Security.Cryptography.RSA System.Security.Cryptography.RSAPKCS1KeyExchangeDeformatter::_rsaKey
RSA_t2385438082 * ____rsaKey_0;
// System.Nullable`1<System.Boolean> System.Security.Cryptography.RSAPKCS1KeyExchangeDeformatter::_rsaOverridesDecrypt
Nullable_1_t1819850047 ____rsaOverridesDecrypt_1;
public:
inline static int32_t get_offset_of__rsaKey_0() { return static_cast<int32_t>(offsetof(RSAPKCS1KeyExchangeDeformatter_t2578812791, ____rsaKey_0)); }
inline RSA_t2385438082 * get__rsaKey_0() const { return ____rsaKey_0; }
inline RSA_t2385438082 ** get_address_of__rsaKey_0() { return &____rsaKey_0; }
inline void set__rsaKey_0(RSA_t2385438082 * value)
{
____rsaKey_0 = value;
Il2CppCodeGenWriteBarrier((&____rsaKey_0), value);
}
inline static int32_t get_offset_of__rsaOverridesDecrypt_1() { return static_cast<int32_t>(offsetof(RSAPKCS1KeyExchangeDeformatter_t2578812791, ____rsaOverridesDecrypt_1)); }
inline Nullable_1_t1819850047 get__rsaOverridesDecrypt_1() const { return ____rsaOverridesDecrypt_1; }
inline Nullable_1_t1819850047 * get_address_of__rsaOverridesDecrypt_1() { return &____rsaOverridesDecrypt_1; }
inline void set__rsaOverridesDecrypt_1(Nullable_1_t1819850047 value)
{
____rsaOverridesDecrypt_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAPKCS1KEYEXCHANGEDEFORMATTER_T2578812791_H
#ifndef RSAOAEPKEYEXCHANGEFORMATTER_T2041696538_H
#define RSAOAEPKEYEXCHANGEFORMATTER_T2041696538_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAOAEPKeyExchangeFormatter
struct RSAOAEPKeyExchangeFormatter_t2041696538 : public AsymmetricKeyExchangeFormatter_t937192061
{
public:
// System.Security.Cryptography.RSA System.Security.Cryptography.RSAOAEPKeyExchangeFormatter::_rsaKey
RSA_t2385438082 * ____rsaKey_0;
// System.Nullable`1<System.Boolean> System.Security.Cryptography.RSAOAEPKeyExchangeFormatter::_rsaOverridesEncrypt
Nullable_1_t1819850047 ____rsaOverridesEncrypt_1;
public:
inline static int32_t get_offset_of__rsaKey_0() { return static_cast<int32_t>(offsetof(RSAOAEPKeyExchangeFormatter_t2041696538, ____rsaKey_0)); }
inline RSA_t2385438082 * get__rsaKey_0() const { return ____rsaKey_0; }
inline RSA_t2385438082 ** get_address_of__rsaKey_0() { return &____rsaKey_0; }
inline void set__rsaKey_0(RSA_t2385438082 * value)
{
____rsaKey_0 = value;
Il2CppCodeGenWriteBarrier((&____rsaKey_0), value);
}
inline static int32_t get_offset_of__rsaOverridesEncrypt_1() { return static_cast<int32_t>(offsetof(RSAOAEPKeyExchangeFormatter_t2041696538, ____rsaOverridesEncrypt_1)); }
inline Nullable_1_t1819850047 get__rsaOverridesEncrypt_1() const { return ____rsaOverridesEncrypt_1; }
inline Nullable_1_t1819850047 * get_address_of__rsaOverridesEncrypt_1() { return &____rsaOverridesEncrypt_1; }
inline void set__rsaOverridesEncrypt_1(Nullable_1_t1819850047 value)
{
____rsaOverridesEncrypt_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAOAEPKEYEXCHANGEFORMATTER_T2041696538_H
#ifndef RSAOAEPKEYEXCHANGEDEFORMATTER_T3344463048_H
#define RSAOAEPKEYEXCHANGEDEFORMATTER_T3344463048_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAOAEPKeyExchangeDeformatter
struct RSAOAEPKeyExchangeDeformatter_t3344463048 : public AsymmetricKeyExchangeDeformatter_t3370779160
{
public:
// System.Security.Cryptography.RSA System.Security.Cryptography.RSAOAEPKeyExchangeDeformatter::_rsaKey
RSA_t2385438082 * ____rsaKey_0;
// System.Nullable`1<System.Boolean> System.Security.Cryptography.RSAOAEPKeyExchangeDeformatter::_rsaOverridesDecrypt
Nullable_1_t1819850047 ____rsaOverridesDecrypt_1;
public:
inline static int32_t get_offset_of__rsaKey_0() { return static_cast<int32_t>(offsetof(RSAOAEPKeyExchangeDeformatter_t3344463048, ____rsaKey_0)); }
inline RSA_t2385438082 * get__rsaKey_0() const { return ____rsaKey_0; }
inline RSA_t2385438082 ** get_address_of__rsaKey_0() { return &____rsaKey_0; }
inline void set__rsaKey_0(RSA_t2385438082 * value)
{
____rsaKey_0 = value;
Il2CppCodeGenWriteBarrier((&____rsaKey_0), value);
}
inline static int32_t get_offset_of__rsaOverridesDecrypt_1() { return static_cast<int32_t>(offsetof(RSAOAEPKeyExchangeDeformatter_t3344463048, ____rsaOverridesDecrypt_1)); }
inline Nullable_1_t1819850047 get__rsaOverridesDecrypt_1() const { return ____rsaOverridesDecrypt_1; }
inline Nullable_1_t1819850047 * get_address_of__rsaOverridesDecrypt_1() { return &____rsaOverridesDecrypt_1; }
inline void set__rsaOverridesDecrypt_1(Nullable_1_t1819850047 value)
{
____rsaOverridesDecrypt_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAOAEPKEYEXCHANGEDEFORMATTER_T3344463048_H
#ifndef RSAPKCS1KEYEXCHANGEFORMATTER_T2761096101_H
#define RSAPKCS1KEYEXCHANGEFORMATTER_T2761096101_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAPKCS1KeyExchangeFormatter
struct RSAPKCS1KeyExchangeFormatter_t2761096101 : public AsymmetricKeyExchangeFormatter_t937192061
{
public:
// System.Security.Cryptography.RandomNumberGenerator System.Security.Cryptography.RSAPKCS1KeyExchangeFormatter::RngValue
RandomNumberGenerator_t386037858 * ___RngValue_0;
// System.Security.Cryptography.RSA System.Security.Cryptography.RSAPKCS1KeyExchangeFormatter::_rsaKey
RSA_t2385438082 * ____rsaKey_1;
// System.Nullable`1<System.Boolean> System.Security.Cryptography.RSAPKCS1KeyExchangeFormatter::_rsaOverridesEncrypt
Nullable_1_t1819850047 ____rsaOverridesEncrypt_2;
public:
inline static int32_t get_offset_of_RngValue_0() { return static_cast<int32_t>(offsetof(RSAPKCS1KeyExchangeFormatter_t2761096101, ___RngValue_0)); }
inline RandomNumberGenerator_t386037858 * get_RngValue_0() const { return ___RngValue_0; }
inline RandomNumberGenerator_t386037858 ** get_address_of_RngValue_0() { return &___RngValue_0; }
inline void set_RngValue_0(RandomNumberGenerator_t386037858 * value)
{
___RngValue_0 = value;
Il2CppCodeGenWriteBarrier((&___RngValue_0), value);
}
inline static int32_t get_offset_of__rsaKey_1() { return static_cast<int32_t>(offsetof(RSAPKCS1KeyExchangeFormatter_t2761096101, ____rsaKey_1)); }
inline RSA_t2385438082 * get__rsaKey_1() const { return ____rsaKey_1; }
inline RSA_t2385438082 ** get_address_of__rsaKey_1() { return &____rsaKey_1; }
inline void set__rsaKey_1(RSA_t2385438082 * value)
{
____rsaKey_1 = value;
Il2CppCodeGenWriteBarrier((&____rsaKey_1), value);
}
inline static int32_t get_offset_of__rsaOverridesEncrypt_2() { return static_cast<int32_t>(offsetof(RSAPKCS1KeyExchangeFormatter_t2761096101, ____rsaOverridesEncrypt_2)); }
inline Nullable_1_t1819850047 get__rsaOverridesEncrypt_2() const { return ____rsaOverridesEncrypt_2; }
inline Nullable_1_t1819850047 * get_address_of__rsaOverridesEncrypt_2() { return &____rsaOverridesEncrypt_2; }
inline void set__rsaOverridesEncrypt_2(Nullable_1_t1819850047 value)
{
____rsaOverridesEncrypt_2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAPKCS1KEYEXCHANGEFORMATTER_T2761096101_H
#ifndef X509KEYSTORAGEFLAGS_T441861693_H
#define X509KEYSTORAGEFLAGS_T441861693_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509KeyStorageFlags
struct X509KeyStorageFlags_t441861693
{
public:
// System.Int32 System.Security.Cryptography.X509Certificates.X509KeyStorageFlags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(X509KeyStorageFlags_t441861693, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509KEYSTORAGEFLAGS_T441861693_H
#ifndef X509CERTIFICATEIMPLAPPLE_T630491926_H
#define X509CERTIFICATEIMPLAPPLE_T630491926_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.X509CertificateImplApple
struct X509CertificateImplApple_t630491926 : public X509CertificateImpl_t2851385038
{
public:
// System.IntPtr System.Security.Cryptography.X509Certificates.X509CertificateImplApple::handle
intptr_t ___handle_1;
// System.Security.Cryptography.X509Certificates.X509CertificateImpl System.Security.Cryptography.X509Certificates.X509CertificateImplApple::fallback
X509CertificateImpl_t2851385038 * ___fallback_2;
public:
inline static int32_t get_offset_of_handle_1() { return static_cast<int32_t>(offsetof(X509CertificateImplApple_t630491926, ___handle_1)); }
inline intptr_t get_handle_1() const { return ___handle_1; }
inline intptr_t* get_address_of_handle_1() { return &___handle_1; }
inline void set_handle_1(intptr_t value)
{
___handle_1 = value;
}
inline static int32_t get_offset_of_fallback_2() { return static_cast<int32_t>(offsetof(X509CertificateImplApple_t630491926, ___fallback_2)); }
inline X509CertificateImpl_t2851385038 * get_fallback_2() const { return ___fallback_2; }
inline X509CertificateImpl_t2851385038 ** get_address_of_fallback_2() { return &___fallback_2; }
inline void set_fallback_2(X509CertificateImpl_t2851385038 * value)
{
___fallback_2 = value;
Il2CppCodeGenWriteBarrier((&___fallback_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // X509CERTIFICATEIMPLAPPLE_T630491926_H
#ifndef HMAC_T2621101144_H
#define HMAC_T2621101144_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMAC
struct HMAC_t2621101144 : public KeyedHashAlgorithm_t112861511
{
public:
// System.Int32 System.Security.Cryptography.HMAC::blockSizeValue
int32_t ___blockSizeValue_5;
// System.String System.Security.Cryptography.HMAC::m_hashName
String_t* ___m_hashName_6;
// System.Security.Cryptography.HashAlgorithm System.Security.Cryptography.HMAC::m_hash1
HashAlgorithm_t1432317219 * ___m_hash1_7;
// System.Security.Cryptography.HashAlgorithm System.Security.Cryptography.HMAC::m_hash2
HashAlgorithm_t1432317219 * ___m_hash2_8;
// System.Byte[] System.Security.Cryptography.HMAC::m_inner
ByteU5BU5D_t4116647657* ___m_inner_9;
// System.Byte[] System.Security.Cryptography.HMAC::m_outer
ByteU5BU5D_t4116647657* ___m_outer_10;
// System.Boolean System.Security.Cryptography.HMAC::m_hashing
bool ___m_hashing_11;
public:
inline static int32_t get_offset_of_blockSizeValue_5() { return static_cast<int32_t>(offsetof(HMAC_t2621101144, ___blockSizeValue_5)); }
inline int32_t get_blockSizeValue_5() const { return ___blockSizeValue_5; }
inline int32_t* get_address_of_blockSizeValue_5() { return &___blockSizeValue_5; }
inline void set_blockSizeValue_5(int32_t value)
{
___blockSizeValue_5 = value;
}
inline static int32_t get_offset_of_m_hashName_6() { return static_cast<int32_t>(offsetof(HMAC_t2621101144, ___m_hashName_6)); }
inline String_t* get_m_hashName_6() const { return ___m_hashName_6; }
inline String_t** get_address_of_m_hashName_6() { return &___m_hashName_6; }
inline void set_m_hashName_6(String_t* value)
{
___m_hashName_6 = value;
Il2CppCodeGenWriteBarrier((&___m_hashName_6), value);
}
inline static int32_t get_offset_of_m_hash1_7() { return static_cast<int32_t>(offsetof(HMAC_t2621101144, ___m_hash1_7)); }
inline HashAlgorithm_t1432317219 * get_m_hash1_7() const { return ___m_hash1_7; }
inline HashAlgorithm_t1432317219 ** get_address_of_m_hash1_7() { return &___m_hash1_7; }
inline void set_m_hash1_7(HashAlgorithm_t1432317219 * value)
{
___m_hash1_7 = value;
Il2CppCodeGenWriteBarrier((&___m_hash1_7), value);
}
inline static int32_t get_offset_of_m_hash2_8() { return static_cast<int32_t>(offsetof(HMAC_t2621101144, ___m_hash2_8)); }
inline HashAlgorithm_t1432317219 * get_m_hash2_8() const { return ___m_hash2_8; }
inline HashAlgorithm_t1432317219 ** get_address_of_m_hash2_8() { return &___m_hash2_8; }
inline void set_m_hash2_8(HashAlgorithm_t1432317219 * value)
{
___m_hash2_8 = value;
Il2CppCodeGenWriteBarrier((&___m_hash2_8), value);
}
inline static int32_t get_offset_of_m_inner_9() { return static_cast<int32_t>(offsetof(HMAC_t2621101144, ___m_inner_9)); }
inline ByteU5BU5D_t4116647657* get_m_inner_9() const { return ___m_inner_9; }
inline ByteU5BU5D_t4116647657** get_address_of_m_inner_9() { return &___m_inner_9; }
inline void set_m_inner_9(ByteU5BU5D_t4116647657* value)
{
___m_inner_9 = value;
Il2CppCodeGenWriteBarrier((&___m_inner_9), value);
}
inline static int32_t get_offset_of_m_outer_10() { return static_cast<int32_t>(offsetof(HMAC_t2621101144, ___m_outer_10)); }
inline ByteU5BU5D_t4116647657* get_m_outer_10() const { return ___m_outer_10; }
inline ByteU5BU5D_t4116647657** get_address_of_m_outer_10() { return &___m_outer_10; }
inline void set_m_outer_10(ByteU5BU5D_t4116647657* value)
{
___m_outer_10 = value;
Il2CppCodeGenWriteBarrier((&___m_outer_10), value);
}
inline static int32_t get_offset_of_m_hashing_11() { return static_cast<int32_t>(offsetof(HMAC_t2621101144, ___m_hashing_11)); }
inline bool get_m_hashing_11() const { return ___m_hashing_11; }
inline bool* get_address_of_m_hashing_11() { return &___m_hashing_11; }
inline void set_m_hashing_11(bool value)
{
___m_hashing_11 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HMAC_T2621101144_H
#ifndef REGISTRYRIGHTS_T345449412_H
#define REGISTRYRIGHTS_T345449412_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.AccessControl.RegistryRights
struct RegistryRights_t345449412
{
public:
// System.Int32 System.Security.AccessControl.RegistryRights::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(RegistryRights_t345449412, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // REGISTRYRIGHTS_T345449412_H
#ifndef STREAMINGCONTEXTSTATES_T3580100459_H
#define STREAMINGCONTEXTSTATES_T3580100459_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.StreamingContextStates
struct StreamingContextStates_t3580100459
{
public:
// System.Int32 System.Runtime.Serialization.StreamingContextStates::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(StreamingContextStates_t3580100459, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // STREAMINGCONTEXTSTATES_T3580100459_H
#ifndef RSAPKCS1SHA512SIGNATUREDESCRIPTION_T4135346397_H
#define RSAPKCS1SHA512SIGNATUREDESCRIPTION_T4135346397_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAPKCS1SHA512SignatureDescription
struct RSAPKCS1SHA512SignatureDescription_t4135346397 : public RSAPKCS1SignatureDescription_t653172199
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAPKCS1SHA512SIGNATUREDESCRIPTION_T4135346397_H
#ifndef OIDGROUP_T1489865352_H
#define OIDGROUP_T1489865352_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.X509Certificates.OidGroup
struct OidGroup_t1489865352
{
public:
// System.Int32 System.Security.Cryptography.X509Certificates.OidGroup::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(OidGroup_t1489865352, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OIDGROUP_T1489865352_H
#ifndef RSAPKCS1SHA384SIGNATUREDESCRIPTION_T519503511_H
#define RSAPKCS1SHA384SIGNATUREDESCRIPTION_T519503511_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAPKCS1SHA384SignatureDescription
struct RSAPKCS1SHA384SignatureDescription_t519503511 : public RSAPKCS1SignatureDescription_t653172199
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAPKCS1SHA384SIGNATUREDESCRIPTION_T519503511_H
#ifndef HMACSHA256_T3249253224_H
#define HMACSHA256_T3249253224_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMACSHA256
struct HMACSHA256_t3249253224 : public HMAC_t2621101144
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HMACSHA256_T3249253224_H
#ifndef HMACSHA384_T117937311_H
#define HMACSHA384_T117937311_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMACSHA384
struct HMACSHA384_t117937311 : public HMAC_t2621101144
{
public:
// System.Boolean System.Security.Cryptography.HMACSHA384::m_useLegacyBlockSize
bool ___m_useLegacyBlockSize_12;
public:
inline static int32_t get_offset_of_m_useLegacyBlockSize_12() { return static_cast<int32_t>(offsetof(HMACSHA384_t117937311, ___m_useLegacyBlockSize_12)); }
inline bool get_m_useLegacyBlockSize_12() const { return ___m_useLegacyBlockSize_12; }
inline bool* get_address_of_m_useLegacyBlockSize_12() { return &___m_useLegacyBlockSize_12; }
inline void set_m_useLegacyBlockSize_12(bool value)
{
___m_useLegacyBlockSize_12 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HMACSHA384_T117937311_H
#ifndef HMACSHA512_T923916539_H
#define HMACSHA512_T923916539_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMACSHA512
struct HMACSHA512_t923916539 : public HMAC_t2621101144
{
public:
// System.Boolean System.Security.Cryptography.HMACSHA512::m_useLegacyBlockSize
bool ___m_useLegacyBlockSize_12;
public:
inline static int32_t get_offset_of_m_useLegacyBlockSize_12() { return static_cast<int32_t>(offsetof(HMACSHA512_t923916539, ___m_useLegacyBlockSize_12)); }
inline bool get_m_useLegacyBlockSize_12() const { return ___m_useLegacyBlockSize_12; }
inline bool* get_address_of_m_useLegacyBlockSize_12() { return &___m_useLegacyBlockSize_12; }
inline void set_m_useLegacyBlockSize_12(bool value)
{
___m_useLegacyBlockSize_12 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HMACSHA512_T923916539_H
#ifndef MULTICASTDELEGATE_T_H
#define MULTICASTDELEGATE_T_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.MulticastDelegate
struct MulticastDelegate_t : public Delegate_t1188392813
{
public:
// System.Delegate[] System.MulticastDelegate::delegates
DelegateU5BU5D_t1703627840* ___delegates_11;
public:
inline static int32_t get_offset_of_delegates_11() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___delegates_11)); }
inline DelegateU5BU5D_t1703627840* get_delegates_11() const { return ___delegates_11; }
inline DelegateU5BU5D_t1703627840** get_address_of_delegates_11() { return &___delegates_11; }
inline void set_delegates_11(DelegateU5BU5D_t1703627840* value)
{
___delegates_11 = value;
Il2CppCodeGenWriteBarrier((&___delegates_11), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_pinvoke : public Delegate_t1188392813_marshaled_pinvoke
{
DelegateU5BU5D_t1703627840* ___delegates_11;
};
// Native definition for COM marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_com : public Delegate_t1188392813_marshaled_com
{
DelegateU5BU5D_t1703627840* ___delegates_11;
};
#endif // MULTICASTDELEGATE_T_H
#ifndef RIJNDAELMANAGEDTRANSFORM_T4102601014_H
#define RIJNDAELMANAGEDTRANSFORM_T4102601014_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RijndaelManagedTransform
struct RijndaelManagedTransform_t4102601014 : public RuntimeObject
{
public:
// System.Security.Cryptography.CipherMode System.Security.Cryptography.RijndaelManagedTransform::m_cipherMode
int32_t ___m_cipherMode_0;
// System.Security.Cryptography.PaddingMode System.Security.Cryptography.RijndaelManagedTransform::m_paddingValue
int32_t ___m_paddingValue_1;
// System.Security.Cryptography.RijndaelManagedTransformMode System.Security.Cryptography.RijndaelManagedTransform::m_transformMode
int32_t ___m_transformMode_2;
// System.Int32 System.Security.Cryptography.RijndaelManagedTransform::m_blockSizeBits
int32_t ___m_blockSizeBits_3;
// System.Int32 System.Security.Cryptography.RijndaelManagedTransform::m_blockSizeBytes
int32_t ___m_blockSizeBytes_4;
// System.Int32 System.Security.Cryptography.RijndaelManagedTransform::m_inputBlockSize
int32_t ___m_inputBlockSize_5;
// System.Int32 System.Security.Cryptography.RijndaelManagedTransform::m_outputBlockSize
int32_t ___m_outputBlockSize_6;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::m_encryptKeyExpansion
Int32U5BU5D_t385246372* ___m_encryptKeyExpansion_7;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::m_decryptKeyExpansion
Int32U5BU5D_t385246372* ___m_decryptKeyExpansion_8;
// System.Int32 System.Security.Cryptography.RijndaelManagedTransform::m_Nr
int32_t ___m_Nr_9;
// System.Int32 System.Security.Cryptography.RijndaelManagedTransform::m_Nb
int32_t ___m_Nb_10;
// System.Int32 System.Security.Cryptography.RijndaelManagedTransform::m_Nk
int32_t ___m_Nk_11;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::m_encryptindex
Int32U5BU5D_t385246372* ___m_encryptindex_12;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::m_decryptindex
Int32U5BU5D_t385246372* ___m_decryptindex_13;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::m_IV
Int32U5BU5D_t385246372* ___m_IV_14;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::m_lastBlockBuffer
Int32U5BU5D_t385246372* ___m_lastBlockBuffer_15;
// System.Byte[] System.Security.Cryptography.RijndaelManagedTransform::m_depadBuffer
ByteU5BU5D_t4116647657* ___m_depadBuffer_16;
// System.Byte[] System.Security.Cryptography.RijndaelManagedTransform::m_shiftRegister
ByteU5BU5D_t4116647657* ___m_shiftRegister_17;
public:
inline static int32_t get_offset_of_m_cipherMode_0() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_cipherMode_0)); }
inline int32_t get_m_cipherMode_0() const { return ___m_cipherMode_0; }
inline int32_t* get_address_of_m_cipherMode_0() { return &___m_cipherMode_0; }
inline void set_m_cipherMode_0(int32_t value)
{
___m_cipherMode_0 = value;
}
inline static int32_t get_offset_of_m_paddingValue_1() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_paddingValue_1)); }
inline int32_t get_m_paddingValue_1() const { return ___m_paddingValue_1; }
inline int32_t* get_address_of_m_paddingValue_1() { return &___m_paddingValue_1; }
inline void set_m_paddingValue_1(int32_t value)
{
___m_paddingValue_1 = value;
}
inline static int32_t get_offset_of_m_transformMode_2() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_transformMode_2)); }
inline int32_t get_m_transformMode_2() const { return ___m_transformMode_2; }
inline int32_t* get_address_of_m_transformMode_2() { return &___m_transformMode_2; }
inline void set_m_transformMode_2(int32_t value)
{
___m_transformMode_2 = value;
}
inline static int32_t get_offset_of_m_blockSizeBits_3() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_blockSizeBits_3)); }
inline int32_t get_m_blockSizeBits_3() const { return ___m_blockSizeBits_3; }
inline int32_t* get_address_of_m_blockSizeBits_3() { return &___m_blockSizeBits_3; }
inline void set_m_blockSizeBits_3(int32_t value)
{
___m_blockSizeBits_3 = value;
}
inline static int32_t get_offset_of_m_blockSizeBytes_4() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_blockSizeBytes_4)); }
inline int32_t get_m_blockSizeBytes_4() const { return ___m_blockSizeBytes_4; }
inline int32_t* get_address_of_m_blockSizeBytes_4() { return &___m_blockSizeBytes_4; }
inline void set_m_blockSizeBytes_4(int32_t value)
{
___m_blockSizeBytes_4 = value;
}
inline static int32_t get_offset_of_m_inputBlockSize_5() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_inputBlockSize_5)); }
inline int32_t get_m_inputBlockSize_5() const { return ___m_inputBlockSize_5; }
inline int32_t* get_address_of_m_inputBlockSize_5() { return &___m_inputBlockSize_5; }
inline void set_m_inputBlockSize_5(int32_t value)
{
___m_inputBlockSize_5 = value;
}
inline static int32_t get_offset_of_m_outputBlockSize_6() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_outputBlockSize_6)); }
inline int32_t get_m_outputBlockSize_6() const { return ___m_outputBlockSize_6; }
inline int32_t* get_address_of_m_outputBlockSize_6() { return &___m_outputBlockSize_6; }
inline void set_m_outputBlockSize_6(int32_t value)
{
___m_outputBlockSize_6 = value;
}
inline static int32_t get_offset_of_m_encryptKeyExpansion_7() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_encryptKeyExpansion_7)); }
inline Int32U5BU5D_t385246372* get_m_encryptKeyExpansion_7() const { return ___m_encryptKeyExpansion_7; }
inline Int32U5BU5D_t385246372** get_address_of_m_encryptKeyExpansion_7() { return &___m_encryptKeyExpansion_7; }
inline void set_m_encryptKeyExpansion_7(Int32U5BU5D_t385246372* value)
{
___m_encryptKeyExpansion_7 = value;
Il2CppCodeGenWriteBarrier((&___m_encryptKeyExpansion_7), value);
}
inline static int32_t get_offset_of_m_decryptKeyExpansion_8() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_decryptKeyExpansion_8)); }
inline Int32U5BU5D_t385246372* get_m_decryptKeyExpansion_8() const { return ___m_decryptKeyExpansion_8; }
inline Int32U5BU5D_t385246372** get_address_of_m_decryptKeyExpansion_8() { return &___m_decryptKeyExpansion_8; }
inline void set_m_decryptKeyExpansion_8(Int32U5BU5D_t385246372* value)
{
___m_decryptKeyExpansion_8 = value;
Il2CppCodeGenWriteBarrier((&___m_decryptKeyExpansion_8), value);
}
inline static int32_t get_offset_of_m_Nr_9() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_Nr_9)); }
inline int32_t get_m_Nr_9() const { return ___m_Nr_9; }
inline int32_t* get_address_of_m_Nr_9() { return &___m_Nr_9; }
inline void set_m_Nr_9(int32_t value)
{
___m_Nr_9 = value;
}
inline static int32_t get_offset_of_m_Nb_10() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_Nb_10)); }
inline int32_t get_m_Nb_10() const { return ___m_Nb_10; }
inline int32_t* get_address_of_m_Nb_10() { return &___m_Nb_10; }
inline void set_m_Nb_10(int32_t value)
{
___m_Nb_10 = value;
}
inline static int32_t get_offset_of_m_Nk_11() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_Nk_11)); }
inline int32_t get_m_Nk_11() const { return ___m_Nk_11; }
inline int32_t* get_address_of_m_Nk_11() { return &___m_Nk_11; }
inline void set_m_Nk_11(int32_t value)
{
___m_Nk_11 = value;
}
inline static int32_t get_offset_of_m_encryptindex_12() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_encryptindex_12)); }
inline Int32U5BU5D_t385246372* get_m_encryptindex_12() const { return ___m_encryptindex_12; }
inline Int32U5BU5D_t385246372** get_address_of_m_encryptindex_12() { return &___m_encryptindex_12; }
inline void set_m_encryptindex_12(Int32U5BU5D_t385246372* value)
{
___m_encryptindex_12 = value;
Il2CppCodeGenWriteBarrier((&___m_encryptindex_12), value);
}
inline static int32_t get_offset_of_m_decryptindex_13() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_decryptindex_13)); }
inline Int32U5BU5D_t385246372* get_m_decryptindex_13() const { return ___m_decryptindex_13; }
inline Int32U5BU5D_t385246372** get_address_of_m_decryptindex_13() { return &___m_decryptindex_13; }
inline void set_m_decryptindex_13(Int32U5BU5D_t385246372* value)
{
___m_decryptindex_13 = value;
Il2CppCodeGenWriteBarrier((&___m_decryptindex_13), value);
}
inline static int32_t get_offset_of_m_IV_14() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_IV_14)); }
inline Int32U5BU5D_t385246372* get_m_IV_14() const { return ___m_IV_14; }
inline Int32U5BU5D_t385246372** get_address_of_m_IV_14() { return &___m_IV_14; }
inline void set_m_IV_14(Int32U5BU5D_t385246372* value)
{
___m_IV_14 = value;
Il2CppCodeGenWriteBarrier((&___m_IV_14), value);
}
inline static int32_t get_offset_of_m_lastBlockBuffer_15() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_lastBlockBuffer_15)); }
inline Int32U5BU5D_t385246372* get_m_lastBlockBuffer_15() const { return ___m_lastBlockBuffer_15; }
inline Int32U5BU5D_t385246372** get_address_of_m_lastBlockBuffer_15() { return &___m_lastBlockBuffer_15; }
inline void set_m_lastBlockBuffer_15(Int32U5BU5D_t385246372* value)
{
___m_lastBlockBuffer_15 = value;
Il2CppCodeGenWriteBarrier((&___m_lastBlockBuffer_15), value);
}
inline static int32_t get_offset_of_m_depadBuffer_16() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_depadBuffer_16)); }
inline ByteU5BU5D_t4116647657* get_m_depadBuffer_16() const { return ___m_depadBuffer_16; }
inline ByteU5BU5D_t4116647657** get_address_of_m_depadBuffer_16() { return &___m_depadBuffer_16; }
inline void set_m_depadBuffer_16(ByteU5BU5D_t4116647657* value)
{
___m_depadBuffer_16 = value;
Il2CppCodeGenWriteBarrier((&___m_depadBuffer_16), value);
}
inline static int32_t get_offset_of_m_shiftRegister_17() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014, ___m_shiftRegister_17)); }
inline ByteU5BU5D_t4116647657* get_m_shiftRegister_17() const { return ___m_shiftRegister_17; }
inline ByteU5BU5D_t4116647657** get_address_of_m_shiftRegister_17() { return &___m_shiftRegister_17; }
inline void set_m_shiftRegister_17(ByteU5BU5D_t4116647657* value)
{
___m_shiftRegister_17 = value;
Il2CppCodeGenWriteBarrier((&___m_shiftRegister_17), value);
}
};
struct RijndaelManagedTransform_t4102601014_StaticFields
{
public:
// System.Byte[] System.Security.Cryptography.RijndaelManagedTransform::s_Sbox
ByteU5BU5D_t4116647657* ___s_Sbox_18;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::s_Rcon
Int32U5BU5D_t385246372* ___s_Rcon_19;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::s_T
Int32U5BU5D_t385246372* ___s_T_20;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::s_TF
Int32U5BU5D_t385246372* ___s_TF_21;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::s_iT
Int32U5BU5D_t385246372* ___s_iT_22;
// System.Int32[] System.Security.Cryptography.RijndaelManagedTransform::s_iTF
Int32U5BU5D_t385246372* ___s_iTF_23;
public:
inline static int32_t get_offset_of_s_Sbox_18() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014_StaticFields, ___s_Sbox_18)); }
inline ByteU5BU5D_t4116647657* get_s_Sbox_18() const { return ___s_Sbox_18; }
inline ByteU5BU5D_t4116647657** get_address_of_s_Sbox_18() { return &___s_Sbox_18; }
inline void set_s_Sbox_18(ByteU5BU5D_t4116647657* value)
{
___s_Sbox_18 = value;
Il2CppCodeGenWriteBarrier((&___s_Sbox_18), value);
}
inline static int32_t get_offset_of_s_Rcon_19() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014_StaticFields, ___s_Rcon_19)); }
inline Int32U5BU5D_t385246372* get_s_Rcon_19() const { return ___s_Rcon_19; }
inline Int32U5BU5D_t385246372** get_address_of_s_Rcon_19() { return &___s_Rcon_19; }
inline void set_s_Rcon_19(Int32U5BU5D_t385246372* value)
{
___s_Rcon_19 = value;
Il2CppCodeGenWriteBarrier((&___s_Rcon_19), value);
}
inline static int32_t get_offset_of_s_T_20() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014_StaticFields, ___s_T_20)); }
inline Int32U5BU5D_t385246372* get_s_T_20() const { return ___s_T_20; }
inline Int32U5BU5D_t385246372** get_address_of_s_T_20() { return &___s_T_20; }
inline void set_s_T_20(Int32U5BU5D_t385246372* value)
{
___s_T_20 = value;
Il2CppCodeGenWriteBarrier((&___s_T_20), value);
}
inline static int32_t get_offset_of_s_TF_21() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014_StaticFields, ___s_TF_21)); }
inline Int32U5BU5D_t385246372* get_s_TF_21() const { return ___s_TF_21; }
inline Int32U5BU5D_t385246372** get_address_of_s_TF_21() { return &___s_TF_21; }
inline void set_s_TF_21(Int32U5BU5D_t385246372* value)
{
___s_TF_21 = value;
Il2CppCodeGenWriteBarrier((&___s_TF_21), value);
}
inline static int32_t get_offset_of_s_iT_22() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014_StaticFields, ___s_iT_22)); }
inline Int32U5BU5D_t385246372* get_s_iT_22() const { return ___s_iT_22; }
inline Int32U5BU5D_t385246372** get_address_of_s_iT_22() { return &___s_iT_22; }
inline void set_s_iT_22(Int32U5BU5D_t385246372* value)
{
___s_iT_22 = value;
Il2CppCodeGenWriteBarrier((&___s_iT_22), value);
}
inline static int32_t get_offset_of_s_iTF_23() { return static_cast<int32_t>(offsetof(RijndaelManagedTransform_t4102601014_StaticFields, ___s_iTF_23)); }
inline Int32U5BU5D_t385246372* get_s_iTF_23() const { return ___s_iTF_23; }
inline Int32U5BU5D_t385246372** get_address_of_s_iTF_23() { return &___s_iTF_23; }
inline void set_s_iTF_23(Int32U5BU5D_t385246372* value)
{
___s_iTF_23 = value;
Il2CppCodeGenWriteBarrier((&___s_iTF_23), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RIJNDAELMANAGEDTRANSFORM_T4102601014_H
#ifndef STREAMINGCONTEXT_T3711869237_H
#define STREAMINGCONTEXT_T3711869237_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.StreamingContext
struct StreamingContext_t3711869237
{
public:
// System.Object System.Runtime.Serialization.StreamingContext::m_additionalContext
RuntimeObject * ___m_additionalContext_0;
// System.Runtime.Serialization.StreamingContextStates System.Runtime.Serialization.StreamingContext::m_state
int32_t ___m_state_1;
public:
inline static int32_t get_offset_of_m_additionalContext_0() { return static_cast<int32_t>(offsetof(StreamingContext_t3711869237, ___m_additionalContext_0)); }
inline RuntimeObject * get_m_additionalContext_0() const { return ___m_additionalContext_0; }
inline RuntimeObject ** get_address_of_m_additionalContext_0() { return &___m_additionalContext_0; }
inline void set_m_additionalContext_0(RuntimeObject * value)
{
___m_additionalContext_0 = value;
Il2CppCodeGenWriteBarrier((&___m_additionalContext_0), value);
}
inline static int32_t get_offset_of_m_state_1() { return static_cast<int32_t>(offsetof(StreamingContext_t3711869237, ___m_state_1)); }
inline int32_t get_m_state_1() const { return ___m_state_1; }
inline int32_t* get_address_of_m_state_1() { return &___m_state_1; }
inline void set_m_state_1(int32_t value)
{
___m_state_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// Native definition for P/Invoke marshalling of System.Runtime.Serialization.StreamingContext
struct StreamingContext_t3711869237_marshaled_pinvoke
{
Il2CppIUnknown* ___m_additionalContext_0;
int32_t ___m_state_1;
};
// Native definition for COM marshalling of System.Runtime.Serialization.StreamingContext
struct StreamingContext_t3711869237_marshaled_com
{
Il2CppIUnknown* ___m_additionalContext_0;
int32_t ___m_state_1;
};
#endif // STREAMINGCONTEXT_T3711869237_H
#ifndef RSAENCRYPTIONPADDING_T979300544_H
#define RSAENCRYPTIONPADDING_T979300544_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RSAEncryptionPadding
struct RSAEncryptionPadding_t979300544 : public RuntimeObject
{
public:
// System.Security.Cryptography.RSAEncryptionPaddingMode System.Security.Cryptography.RSAEncryptionPadding::_mode
int32_t ____mode_5;
// System.Security.Cryptography.HashAlgorithmName System.Security.Cryptography.RSAEncryptionPadding::_oaepHashAlgorithm
HashAlgorithmName_t3637476002 ____oaepHashAlgorithm_6;
public:
inline static int32_t get_offset_of__mode_5() { return static_cast<int32_t>(offsetof(RSAEncryptionPadding_t979300544, ____mode_5)); }
inline int32_t get__mode_5() const { return ____mode_5; }
inline int32_t* get_address_of__mode_5() { return &____mode_5; }
inline void set__mode_5(int32_t value)
{
____mode_5 = value;
}
inline static int32_t get_offset_of__oaepHashAlgorithm_6() { return static_cast<int32_t>(offsetof(RSAEncryptionPadding_t979300544, ____oaepHashAlgorithm_6)); }
inline HashAlgorithmName_t3637476002 get__oaepHashAlgorithm_6() const { return ____oaepHashAlgorithm_6; }
inline HashAlgorithmName_t3637476002 * get_address_of__oaepHashAlgorithm_6() { return &____oaepHashAlgorithm_6; }
inline void set__oaepHashAlgorithm_6(HashAlgorithmName_t3637476002 value)
{
____oaepHashAlgorithm_6 = value;
}
};
struct RSAEncryptionPadding_t979300544_StaticFields
{
public:
// System.Security.Cryptography.RSAEncryptionPadding System.Security.Cryptography.RSAEncryptionPadding::s_pkcs1
RSAEncryptionPadding_t979300544 * ___s_pkcs1_0;
// System.Security.Cryptography.RSAEncryptionPadding System.Security.Cryptography.RSAEncryptionPadding::s_oaepSHA1
RSAEncryptionPadding_t979300544 * ___s_oaepSHA1_1;
// System.Security.Cryptography.RSAEncryptionPadding System.Security.Cryptography.RSAEncryptionPadding::s_oaepSHA256
RSAEncryptionPadding_t979300544 * ___s_oaepSHA256_2;
// System.Security.Cryptography.RSAEncryptionPadding System.Security.Cryptography.RSAEncryptionPadding::s_oaepSHA384
RSAEncryptionPadding_t979300544 * ___s_oaepSHA384_3;
// System.Security.Cryptography.RSAEncryptionPadding System.Security.Cryptography.RSAEncryptionPadding::s_oaepSHA512
RSAEncryptionPadding_t979300544 * ___s_oaepSHA512_4;
public:
inline static int32_t get_offset_of_s_pkcs1_0() { return static_cast<int32_t>(offsetof(RSAEncryptionPadding_t979300544_StaticFields, ___s_pkcs1_0)); }
inline RSAEncryptionPadding_t979300544 * get_s_pkcs1_0() const { return ___s_pkcs1_0; }
inline RSAEncryptionPadding_t979300544 ** get_address_of_s_pkcs1_0() { return &___s_pkcs1_0; }
inline void set_s_pkcs1_0(RSAEncryptionPadding_t979300544 * value)
{
___s_pkcs1_0 = value;
Il2CppCodeGenWriteBarrier((&___s_pkcs1_0), value);
}
inline static int32_t get_offset_of_s_oaepSHA1_1() { return static_cast<int32_t>(offsetof(RSAEncryptionPadding_t979300544_StaticFields, ___s_oaepSHA1_1)); }
inline RSAEncryptionPadding_t979300544 * get_s_oaepSHA1_1() const { return ___s_oaepSHA1_1; }
inline RSAEncryptionPadding_t979300544 ** get_address_of_s_oaepSHA1_1() { return &___s_oaepSHA1_1; }
inline void set_s_oaepSHA1_1(RSAEncryptionPadding_t979300544 * value)
{
___s_oaepSHA1_1 = value;
Il2CppCodeGenWriteBarrier((&___s_oaepSHA1_1), value);
}
inline static int32_t get_offset_of_s_oaepSHA256_2() { return static_cast<int32_t>(offsetof(RSAEncryptionPadding_t979300544_StaticFields, ___s_oaepSHA256_2)); }
inline RSAEncryptionPadding_t979300544 * get_s_oaepSHA256_2() const { return ___s_oaepSHA256_2; }
inline RSAEncryptionPadding_t979300544 ** get_address_of_s_oaepSHA256_2() { return &___s_oaepSHA256_2; }
inline void set_s_oaepSHA256_2(RSAEncryptionPadding_t979300544 * value)
{
___s_oaepSHA256_2 = value;
Il2CppCodeGenWriteBarrier((&___s_oaepSHA256_2), value);
}
inline static int32_t get_offset_of_s_oaepSHA384_3() { return static_cast<int32_t>(offsetof(RSAEncryptionPadding_t979300544_StaticFields, ___s_oaepSHA384_3)); }
inline RSAEncryptionPadding_t979300544 * get_s_oaepSHA384_3() const { return ___s_oaepSHA384_3; }
inline RSAEncryptionPadding_t979300544 ** get_address_of_s_oaepSHA384_3() { return &___s_oaepSHA384_3; }
inline void set_s_oaepSHA384_3(RSAEncryptionPadding_t979300544 * value)
{
___s_oaepSHA384_3 = value;
Il2CppCodeGenWriteBarrier((&___s_oaepSHA384_3), value);
}
inline static int32_t get_offset_of_s_oaepSHA512_4() { return static_cast<int32_t>(offsetof(RSAEncryptionPadding_t979300544_StaticFields, ___s_oaepSHA512_4)); }
inline RSAEncryptionPadding_t979300544 * get_s_oaepSHA512_4() const { return ___s_oaepSHA512_4; }
inline RSAEncryptionPadding_t979300544 ** get_address_of_s_oaepSHA512_4() { return &___s_oaepSHA512_4; }
inline void set_s_oaepSHA512_4(RSAEncryptionPadding_t979300544 * value)
{
___s_oaepSHA512_4 = value;
Il2CppCodeGenWriteBarrier((&___s_oaepSHA512_4), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RSAENCRYPTIONPADDING_T979300544_H
#ifndef HMACSHA1_T1952596188_H
#define HMACSHA1_T1952596188_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMACSHA1
struct HMACSHA1_t1952596188 : public HMAC_t2621101144
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HMACSHA1_T1952596188_H
#ifndef HMACMD5_T2742219965_H
#define HMACMD5_T2742219965_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMACMD5
struct HMACMD5_t2742219965 : public HMAC_t2621101144
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HMACMD5_T2742219965_H
#ifndef HMACRIPEMD160_T3724196729_H
#define HMACRIPEMD160_T3724196729_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.HMACRIPEMD160
struct HMACRIPEMD160_t3724196729 : public HMAC_t2621101144
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // HMACRIPEMD160_T3724196729_H
#ifndef SYMMETRICALGORITHM_T4254223087_H
#define SYMMETRICALGORITHM_T4254223087_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.SymmetricAlgorithm
struct SymmetricAlgorithm_t4254223087 : public RuntimeObject
{
public:
// System.Int32 System.Security.Cryptography.SymmetricAlgorithm::BlockSizeValue
int32_t ___BlockSizeValue_0;
// System.Int32 System.Security.Cryptography.SymmetricAlgorithm::FeedbackSizeValue
int32_t ___FeedbackSizeValue_1;
// System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::IVValue
ByteU5BU5D_t4116647657* ___IVValue_2;
// System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::KeyValue
ByteU5BU5D_t4116647657* ___KeyValue_3;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.SymmetricAlgorithm::LegalBlockSizesValue
KeySizesU5BU5D_t722666473* ___LegalBlockSizesValue_4;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.SymmetricAlgorithm::LegalKeySizesValue
KeySizesU5BU5D_t722666473* ___LegalKeySizesValue_5;
// System.Int32 System.Security.Cryptography.SymmetricAlgorithm::KeySizeValue
int32_t ___KeySizeValue_6;
// System.Security.Cryptography.CipherMode System.Security.Cryptography.SymmetricAlgorithm::ModeValue
int32_t ___ModeValue_7;
// System.Security.Cryptography.PaddingMode System.Security.Cryptography.SymmetricAlgorithm::PaddingValue
int32_t ___PaddingValue_8;
public:
inline static int32_t get_offset_of_BlockSizeValue_0() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t4254223087, ___BlockSizeValue_0)); }
inline int32_t get_BlockSizeValue_0() const { return ___BlockSizeValue_0; }
inline int32_t* get_address_of_BlockSizeValue_0() { return &___BlockSizeValue_0; }
inline void set_BlockSizeValue_0(int32_t value)
{
___BlockSizeValue_0 = value;
}
inline static int32_t get_offset_of_FeedbackSizeValue_1() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t4254223087, ___FeedbackSizeValue_1)); }
inline int32_t get_FeedbackSizeValue_1() const { return ___FeedbackSizeValue_1; }
inline int32_t* get_address_of_FeedbackSizeValue_1() { return &___FeedbackSizeValue_1; }
inline void set_FeedbackSizeValue_1(int32_t value)
{
___FeedbackSizeValue_1 = value;
}
inline static int32_t get_offset_of_IVValue_2() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t4254223087, ___IVValue_2)); }
inline ByteU5BU5D_t4116647657* get_IVValue_2() const { return ___IVValue_2; }
inline ByteU5BU5D_t4116647657** get_address_of_IVValue_2() { return &___IVValue_2; }
inline void set_IVValue_2(ByteU5BU5D_t4116647657* value)
{
___IVValue_2 = value;
Il2CppCodeGenWriteBarrier((&___IVValue_2), value);
}
inline static int32_t get_offset_of_KeyValue_3() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t4254223087, ___KeyValue_3)); }
inline ByteU5BU5D_t4116647657* get_KeyValue_3() const { return ___KeyValue_3; }
inline ByteU5BU5D_t4116647657** get_address_of_KeyValue_3() { return &___KeyValue_3; }
inline void set_KeyValue_3(ByteU5BU5D_t4116647657* value)
{
___KeyValue_3 = value;
Il2CppCodeGenWriteBarrier((&___KeyValue_3), value);
}
inline static int32_t get_offset_of_LegalBlockSizesValue_4() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t4254223087, ___LegalBlockSizesValue_4)); }
inline KeySizesU5BU5D_t722666473* get_LegalBlockSizesValue_4() const { return ___LegalBlockSizesValue_4; }
inline KeySizesU5BU5D_t722666473** get_address_of_LegalBlockSizesValue_4() { return &___LegalBlockSizesValue_4; }
inline void set_LegalBlockSizesValue_4(KeySizesU5BU5D_t722666473* value)
{
___LegalBlockSizesValue_4 = value;
Il2CppCodeGenWriteBarrier((&___LegalBlockSizesValue_4), value);
}
inline static int32_t get_offset_of_LegalKeySizesValue_5() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t4254223087, ___LegalKeySizesValue_5)); }
inline KeySizesU5BU5D_t722666473* get_LegalKeySizesValue_5() const { return ___LegalKeySizesValue_5; }
inline KeySizesU5BU5D_t722666473** get_address_of_LegalKeySizesValue_5() { return &___LegalKeySizesValue_5; }
inline void set_LegalKeySizesValue_5(KeySizesU5BU5D_t722666473* value)
{
___LegalKeySizesValue_5 = value;
Il2CppCodeGenWriteBarrier((&___LegalKeySizesValue_5), value);
}
inline static int32_t get_offset_of_KeySizeValue_6() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t4254223087, ___KeySizeValue_6)); }
inline int32_t get_KeySizeValue_6() const { return ___KeySizeValue_6; }
inline int32_t* get_address_of_KeySizeValue_6() { return &___KeySizeValue_6; }
inline void set_KeySizeValue_6(int32_t value)
{
___KeySizeValue_6 = value;
}
inline static int32_t get_offset_of_ModeValue_7() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t4254223087, ___ModeValue_7)); }
inline int32_t get_ModeValue_7() const { return ___ModeValue_7; }
inline int32_t* get_address_of_ModeValue_7() { return &___ModeValue_7; }
inline void set_ModeValue_7(int32_t value)
{
___ModeValue_7 = value;
}
inline static int32_t get_offset_of_PaddingValue_8() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t4254223087, ___PaddingValue_8)); }
inline int32_t get_PaddingValue_8() const { return ___PaddingValue_8; }
inline int32_t* get_address_of_PaddingValue_8() { return &___PaddingValue_8; }
inline void set_PaddingValue_8(int32_t value)
{
___PaddingValue_8 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SYMMETRICALGORITHM_T4254223087_H
#ifndef TRIPLEDES_T92303514_H
#define TRIPLEDES_T92303514_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.TripleDES
struct TripleDES_t92303514 : public SymmetricAlgorithm_t4254223087
{
public:
public:
};
struct TripleDES_t92303514_StaticFields
{
public:
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.TripleDES::s_legalBlockSizes
KeySizesU5BU5D_t722666473* ___s_legalBlockSizes_9;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.TripleDES::s_legalKeySizes
KeySizesU5BU5D_t722666473* ___s_legalKeySizes_10;
public:
inline static int32_t get_offset_of_s_legalBlockSizes_9() { return static_cast<int32_t>(offsetof(TripleDES_t92303514_StaticFields, ___s_legalBlockSizes_9)); }
inline KeySizesU5BU5D_t722666473* get_s_legalBlockSizes_9() const { return ___s_legalBlockSizes_9; }
inline KeySizesU5BU5D_t722666473** get_address_of_s_legalBlockSizes_9() { return &___s_legalBlockSizes_9; }
inline void set_s_legalBlockSizes_9(KeySizesU5BU5D_t722666473* value)
{
___s_legalBlockSizes_9 = value;
Il2CppCodeGenWriteBarrier((&___s_legalBlockSizes_9), value);
}
inline static int32_t get_offset_of_s_legalKeySizes_10() { return static_cast<int32_t>(offsetof(TripleDES_t92303514_StaticFields, ___s_legalKeySizes_10)); }
inline KeySizesU5BU5D_t722666473* get_s_legalKeySizes_10() const { return ___s_legalKeySizes_10; }
inline KeySizesU5BU5D_t722666473** get_address_of_s_legalKeySizes_10() { return &___s_legalKeySizes_10; }
inline void set_s_legalKeySizes_10(KeySizesU5BU5D_t722666473* value)
{
___s_legalKeySizes_10 = value;
Il2CppCodeGenWriteBarrier((&___s_legalKeySizes_10), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TRIPLEDES_T92303514_H
#ifndef SAFESERIALIZATIONEVENTARGS_T27819340_H
#define SAFESERIALIZATIONEVENTARGS_T27819340_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.SafeSerializationEventArgs
struct SafeSerializationEventArgs_t27819340 : public EventArgs_t3591816995
{
public:
// System.Runtime.Serialization.StreamingContext System.Runtime.Serialization.SafeSerializationEventArgs::m_streamingContext
StreamingContext_t3711869237 ___m_streamingContext_1;
// System.Collections.Generic.List`1<System.Object> System.Runtime.Serialization.SafeSerializationEventArgs::m_serializedStates
List_1_t257213610 * ___m_serializedStates_2;
public:
inline static int32_t get_offset_of_m_streamingContext_1() { return static_cast<int32_t>(offsetof(SafeSerializationEventArgs_t27819340, ___m_streamingContext_1)); }
inline StreamingContext_t3711869237 get_m_streamingContext_1() const { return ___m_streamingContext_1; }
inline StreamingContext_t3711869237 * get_address_of_m_streamingContext_1() { return &___m_streamingContext_1; }
inline void set_m_streamingContext_1(StreamingContext_t3711869237 value)
{
___m_streamingContext_1 = value;
}
inline static int32_t get_offset_of_m_serializedStates_2() { return static_cast<int32_t>(offsetof(SafeSerializationEventArgs_t27819340, ___m_serializedStates_2)); }
inline List_1_t257213610 * get_m_serializedStates_2() const { return ___m_serializedStates_2; }
inline List_1_t257213610 ** get_address_of_m_serializedStates_2() { return &___m_serializedStates_2; }
inline void set_m_serializedStates_2(List_1_t257213610 * value)
{
___m_serializedStates_2 = value;
Il2CppCodeGenWriteBarrier((&___m_serializedStates_2), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SAFESERIALIZATIONEVENTARGS_T27819340_H
#ifndef OBJECTMANAGER_T1653064325_H
#define OBJECTMANAGER_T1653064325_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.ObjectManager
struct ObjectManager_t1653064325 : public RuntimeObject
{
public:
// System.Runtime.Serialization.DeserializationEventHandler System.Runtime.Serialization.ObjectManager::m_onDeserializationHandler
DeserializationEventHandler_t1473997819 * ___m_onDeserializationHandler_0;
// System.Runtime.Serialization.SerializationEventHandler System.Runtime.Serialization.ObjectManager::m_onDeserializedHandler
SerializationEventHandler_t2446424469 * ___m_onDeserializedHandler_1;
// System.Runtime.Serialization.ObjectHolder[] System.Runtime.Serialization.ObjectManager::m_objects
ObjectHolderU5BU5D_t663564126* ___m_objects_2;
// System.Object System.Runtime.Serialization.ObjectManager::m_topObject
RuntimeObject * ___m_topObject_3;
// System.Runtime.Serialization.ObjectHolderList System.Runtime.Serialization.ObjectManager::m_specialFixupObjects
ObjectHolderList_t2007846727 * ___m_specialFixupObjects_4;
// System.Int64 System.Runtime.Serialization.ObjectManager::m_fixupCount
int64_t ___m_fixupCount_5;
// System.Runtime.Serialization.ISurrogateSelector System.Runtime.Serialization.ObjectManager::m_selector
RuntimeObject* ___m_selector_6;
// System.Runtime.Serialization.StreamingContext System.Runtime.Serialization.ObjectManager::m_context
StreamingContext_t3711869237 ___m_context_7;
public:
inline static int32_t get_offset_of_m_onDeserializationHandler_0() { return static_cast<int32_t>(offsetof(ObjectManager_t1653064325, ___m_onDeserializationHandler_0)); }
inline DeserializationEventHandler_t1473997819 * get_m_onDeserializationHandler_0() const { return ___m_onDeserializationHandler_0; }
inline DeserializationEventHandler_t1473997819 ** get_address_of_m_onDeserializationHandler_0() { return &___m_onDeserializationHandler_0; }
inline void set_m_onDeserializationHandler_0(DeserializationEventHandler_t1473997819 * value)
{
___m_onDeserializationHandler_0 = value;
Il2CppCodeGenWriteBarrier((&___m_onDeserializationHandler_0), value);
}
inline static int32_t get_offset_of_m_onDeserializedHandler_1() { return static_cast<int32_t>(offsetof(ObjectManager_t1653064325, ___m_onDeserializedHandler_1)); }
inline SerializationEventHandler_t2446424469 * get_m_onDeserializedHandler_1() const { return ___m_onDeserializedHandler_1; }
inline SerializationEventHandler_t2446424469 ** get_address_of_m_onDeserializedHandler_1() { return &___m_onDeserializedHandler_1; }
inline void set_m_onDeserializedHandler_1(SerializationEventHandler_t2446424469 * value)
{
___m_onDeserializedHandler_1 = value;
Il2CppCodeGenWriteBarrier((&___m_onDeserializedHandler_1), value);
}
inline static int32_t get_offset_of_m_objects_2() { return static_cast<int32_t>(offsetof(ObjectManager_t1653064325, ___m_objects_2)); }
inline ObjectHolderU5BU5D_t663564126* get_m_objects_2() const { return ___m_objects_2; }
inline ObjectHolderU5BU5D_t663564126** get_address_of_m_objects_2() { return &___m_objects_2; }
inline void set_m_objects_2(ObjectHolderU5BU5D_t663564126* value)
{
___m_objects_2 = value;
Il2CppCodeGenWriteBarrier((&___m_objects_2), value);
}
inline static int32_t get_offset_of_m_topObject_3() { return static_cast<int32_t>(offsetof(ObjectManager_t1653064325, ___m_topObject_3)); }
inline RuntimeObject * get_m_topObject_3() const { return ___m_topObject_3; }
inline RuntimeObject ** get_address_of_m_topObject_3() { return &___m_topObject_3; }
inline void set_m_topObject_3(RuntimeObject * value)
{
___m_topObject_3 = value;
Il2CppCodeGenWriteBarrier((&___m_topObject_3), value);
}
inline static int32_t get_offset_of_m_specialFixupObjects_4() { return static_cast<int32_t>(offsetof(ObjectManager_t1653064325, ___m_specialFixupObjects_4)); }
inline ObjectHolderList_t2007846727 * get_m_specialFixupObjects_4() const { return ___m_specialFixupObjects_4; }
inline ObjectHolderList_t2007846727 ** get_address_of_m_specialFixupObjects_4() { return &___m_specialFixupObjects_4; }
inline void set_m_specialFixupObjects_4(ObjectHolderList_t2007846727 * value)
{
___m_specialFixupObjects_4 = value;
Il2CppCodeGenWriteBarrier((&___m_specialFixupObjects_4), value);
}
inline static int32_t get_offset_of_m_fixupCount_5() { return static_cast<int32_t>(offsetof(ObjectManager_t1653064325, ___m_fixupCount_5)); }
inline int64_t get_m_fixupCount_5() const { return ___m_fixupCount_5; }
inline int64_t* get_address_of_m_fixupCount_5() { return &___m_fixupCount_5; }
inline void set_m_fixupCount_5(int64_t value)
{
___m_fixupCount_5 = value;
}
inline static int32_t get_offset_of_m_selector_6() { return static_cast<int32_t>(offsetof(ObjectManager_t1653064325, ___m_selector_6)); }
inline RuntimeObject* get_m_selector_6() const { return ___m_selector_6; }
inline RuntimeObject** get_address_of_m_selector_6() { return &___m_selector_6; }
inline void set_m_selector_6(RuntimeObject* value)
{
___m_selector_6 = value;
Il2CppCodeGenWriteBarrier((&___m_selector_6), value);
}
inline static int32_t get_offset_of_m_context_7() { return static_cast<int32_t>(offsetof(ObjectManager_t1653064325, ___m_context_7)); }
inline StreamingContext_t3711869237 get_m_context_7() const { return ___m_context_7; }
inline StreamingContext_t3711869237 * get_address_of_m_context_7() { return &___m_context_7; }
inline void set_m_context_7(StreamingContext_t3711869237 value)
{
___m_context_7 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // OBJECTMANAGER_T1653064325_H
#ifndef DESERIALIZATIONEVENTHANDLER_T1473997819_H
#define DESERIALIZATIONEVENTHANDLER_T1473997819_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.DeserializationEventHandler
struct DeserializationEventHandler_t1473997819 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // DESERIALIZATIONEVENTHANDLER_T1473997819_H
#ifndef MEMBERHOLDER_T2755910714_H
#define MEMBERHOLDER_T2755910714_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.MemberHolder
struct MemberHolder_t2755910714 : public RuntimeObject
{
public:
// System.Type System.Runtime.Serialization.MemberHolder::memberType
Type_t * ___memberType_0;
// System.Runtime.Serialization.StreamingContext System.Runtime.Serialization.MemberHolder::context
StreamingContext_t3711869237 ___context_1;
public:
inline static int32_t get_offset_of_memberType_0() { return static_cast<int32_t>(offsetof(MemberHolder_t2755910714, ___memberType_0)); }
inline Type_t * get_memberType_0() const { return ___memberType_0; }
inline Type_t ** get_address_of_memberType_0() { return &___memberType_0; }
inline void set_memberType_0(Type_t * value)
{
___memberType_0 = value;
Il2CppCodeGenWriteBarrier((&___memberType_0), value);
}
inline static int32_t get_offset_of_context_1() { return static_cast<int32_t>(offsetof(MemberHolder_t2755910714, ___context_1)); }
inline StreamingContext_t3711869237 get_context_1() const { return ___context_1; }
inline StreamingContext_t3711869237 * get_address_of_context_1() { return &___context_1; }
inline void set_context_1(StreamingContext_t3711869237 value)
{
___context_1 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // MEMBERHOLDER_T2755910714_H
#ifndef RIJNDAEL_T2986313634_H
#define RIJNDAEL_T2986313634_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.Rijndael
struct Rijndael_t2986313634 : public SymmetricAlgorithm_t4254223087
{
public:
public:
};
struct Rijndael_t2986313634_StaticFields
{
public:
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.Rijndael::s_legalBlockSizes
KeySizesU5BU5D_t722666473* ___s_legalBlockSizes_9;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.Rijndael::s_legalKeySizes
KeySizesU5BU5D_t722666473* ___s_legalKeySizes_10;
public:
inline static int32_t get_offset_of_s_legalBlockSizes_9() { return static_cast<int32_t>(offsetof(Rijndael_t2986313634_StaticFields, ___s_legalBlockSizes_9)); }
inline KeySizesU5BU5D_t722666473* get_s_legalBlockSizes_9() const { return ___s_legalBlockSizes_9; }
inline KeySizesU5BU5D_t722666473** get_address_of_s_legalBlockSizes_9() { return &___s_legalBlockSizes_9; }
inline void set_s_legalBlockSizes_9(KeySizesU5BU5D_t722666473* value)
{
___s_legalBlockSizes_9 = value;
Il2CppCodeGenWriteBarrier((&___s_legalBlockSizes_9), value);
}
inline static int32_t get_offset_of_s_legalKeySizes_10() { return static_cast<int32_t>(offsetof(Rijndael_t2986313634_StaticFields, ___s_legalKeySizes_10)); }
inline KeySizesU5BU5D_t722666473* get_s_legalKeySizes_10() const { return ___s_legalKeySizes_10; }
inline KeySizesU5BU5D_t722666473** get_address_of_s_legalKeySizes_10() { return &___s_legalKeySizes_10; }
inline void set_s_legalKeySizes_10(KeySizesU5BU5D_t722666473* value)
{
___s_legalKeySizes_10 = value;
Il2CppCodeGenWriteBarrier((&___s_legalKeySizes_10), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RIJNDAEL_T2986313634_H
#ifndef RC2_T3167825714_H
#define RC2_T3167825714_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RC2
struct RC2_t3167825714 : public SymmetricAlgorithm_t4254223087
{
public:
// System.Int32 System.Security.Cryptography.RC2::EffectiveKeySizeValue
int32_t ___EffectiveKeySizeValue_9;
public:
inline static int32_t get_offset_of_EffectiveKeySizeValue_9() { return static_cast<int32_t>(offsetof(RC2_t3167825714, ___EffectiveKeySizeValue_9)); }
inline int32_t get_EffectiveKeySizeValue_9() const { return ___EffectiveKeySizeValue_9; }
inline int32_t* get_address_of_EffectiveKeySizeValue_9() { return &___EffectiveKeySizeValue_9; }
inline void set_EffectiveKeySizeValue_9(int32_t value)
{
___EffectiveKeySizeValue_9 = value;
}
};
struct RC2_t3167825714_StaticFields
{
public:
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.RC2::s_legalBlockSizes
KeySizesU5BU5D_t722666473* ___s_legalBlockSizes_10;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.RC2::s_legalKeySizes
KeySizesU5BU5D_t722666473* ___s_legalKeySizes_11;
public:
inline static int32_t get_offset_of_s_legalBlockSizes_10() { return static_cast<int32_t>(offsetof(RC2_t3167825714_StaticFields, ___s_legalBlockSizes_10)); }
inline KeySizesU5BU5D_t722666473* get_s_legalBlockSizes_10() const { return ___s_legalBlockSizes_10; }
inline KeySizesU5BU5D_t722666473** get_address_of_s_legalBlockSizes_10() { return &___s_legalBlockSizes_10; }
inline void set_s_legalBlockSizes_10(KeySizesU5BU5D_t722666473* value)
{
___s_legalBlockSizes_10 = value;
Il2CppCodeGenWriteBarrier((&___s_legalBlockSizes_10), value);
}
inline static int32_t get_offset_of_s_legalKeySizes_11() { return static_cast<int32_t>(offsetof(RC2_t3167825714_StaticFields, ___s_legalKeySizes_11)); }
inline KeySizesU5BU5D_t722666473* get_s_legalKeySizes_11() const { return ___s_legalKeySizes_11; }
inline KeySizesU5BU5D_t722666473** get_address_of_s_legalKeySizes_11() { return &___s_legalKeySizes_11; }
inline void set_s_legalKeySizes_11(KeySizesU5BU5D_t722666473* value)
{
___s_legalKeySizes_11 = value;
Il2CppCodeGenWriteBarrier((&___s_legalKeySizes_11), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RC2_T3167825714_H
#ifndef SERIALIZATIONEVENTHANDLER_T2446424469_H
#define SERIALIZATIONEVENTHANDLER_T2446424469_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Runtime.Serialization.SerializationEventHandler
struct SerializationEventHandler_t2446424469 : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // SERIALIZATIONEVENTHANDLER_T2446424469_H
#ifndef TRIPLEDESCRYPTOSERVICEPROVIDER_T3595206342_H
#define TRIPLEDESCRYPTOSERVICEPROVIDER_T3595206342_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.TripleDESCryptoServiceProvider
struct TripleDESCryptoServiceProvider_t3595206342 : public TripleDES_t92303514
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // TRIPLEDESCRYPTOSERVICEPROVIDER_T3595206342_H
#ifndef RIJNDAELMANAGED_T3586970409_H
#define RIJNDAELMANAGED_T3586970409_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RijndaelManaged
struct RijndaelManaged_t3586970409 : public Rijndael_t2986313634
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RIJNDAELMANAGED_T3586970409_H
#ifndef RC2CRYPTOSERVICEPROVIDER_T662919463_H
#define RC2CRYPTOSERVICEPROVIDER_T662919463_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.RC2CryptoServiceProvider
struct RC2CryptoServiceProvider_t662919463 : public RC2_t3167825714
{
public:
// System.Boolean System.Security.Cryptography.RC2CryptoServiceProvider::m_use40bitSalt
bool ___m_use40bitSalt_12;
public:
inline static int32_t get_offset_of_m_use40bitSalt_12() { return static_cast<int32_t>(offsetof(RC2CryptoServiceProvider_t662919463, ___m_use40bitSalt_12)); }
inline bool get_m_use40bitSalt_12() const { return ___m_use40bitSalt_12; }
inline bool* get_address_of_m_use40bitSalt_12() { return &___m_use40bitSalt_12; }
inline void set_m_use40bitSalt_12(bool value)
{
___m_use40bitSalt_12 = value;
}
};
struct RC2CryptoServiceProvider_t662919463_StaticFields
{
public:
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.RC2CryptoServiceProvider::s_legalKeySizes
KeySizesU5BU5D_t722666473* ___s_legalKeySizes_13;
public:
inline static int32_t get_offset_of_s_legalKeySizes_13() { return static_cast<int32_t>(offsetof(RC2CryptoServiceProvider_t662919463_StaticFields, ___s_legalKeySizes_13)); }
inline KeySizesU5BU5D_t722666473* get_s_legalKeySizes_13() const { return ___s_legalKeySizes_13; }
inline KeySizesU5BU5D_t722666473** get_address_of_s_legalKeySizes_13() { return &___s_legalKeySizes_13; }
inline void set_s_legalKeySizes_13(KeySizesU5BU5D_t722666473* value)
{
___s_legalKeySizes_13 = value;
Il2CppCodeGenWriteBarrier((&___s_legalKeySizes_13), value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#endif // RC2CRYPTOSERVICEPROVIDER_T662919463_H
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize700 = { sizeof (DSA_t2386879874), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize701 = { sizeof (DSASignatureDeformatter_t3677955172), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable701[2] =
{
DSASignatureDeformatter_t3677955172::get_offset_of__dsaKey_0(),
DSASignatureDeformatter_t3677955172::get_offset_of__oid_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize702 = { sizeof (DSASignatureFormatter_t2007981259), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable702[2] =
{
DSASignatureFormatter_t2007981259::get_offset_of__dsaKey_0(),
DSASignatureFormatter_t2007981259::get_offset_of__oid_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize703 = { sizeof (HashAlgorithm_t1432317219), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable703[4] =
{
HashAlgorithm_t1432317219::get_offset_of_HashSizeValue_0(),
HashAlgorithm_t1432317219::get_offset_of_HashValue_1(),
HashAlgorithm_t1432317219::get_offset_of_State_2(),
HashAlgorithm_t1432317219::get_offset_of_m_bDisposed_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize704 = { sizeof (HashAlgorithmName_t3637476002)+ sizeof (RuntimeObject), sizeof(HashAlgorithmName_t3637476002_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable704[1] =
{
HashAlgorithmName_t3637476002::get_offset_of__name_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize705 = { sizeof (HMAC_t2621101144), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable705[7] =
{
HMAC_t2621101144::get_offset_of_blockSizeValue_5(),
HMAC_t2621101144::get_offset_of_m_hashName_6(),
HMAC_t2621101144::get_offset_of_m_hash1_7(),
HMAC_t2621101144::get_offset_of_m_hash2_8(),
HMAC_t2621101144::get_offset_of_m_inner_9(),
HMAC_t2621101144::get_offset_of_m_outer_10(),
HMAC_t2621101144::get_offset_of_m_hashing_11(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize706 = { sizeof (HMACMD5_t2742219965), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize707 = { sizeof (HMACRIPEMD160_t3724196729), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize708 = { sizeof (HMACSHA1_t1952596188), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize709 = { sizeof (HMACSHA256_t3249253224), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize710 = { sizeof (U3CU3Ec_t44063686), -1, sizeof(U3CU3Ec_t44063686_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable710[5] =
{
U3CU3Ec_t44063686_StaticFields::get_offset_of_U3CU3E9_0(),
U3CU3Ec_t44063686_StaticFields::get_offset_of_U3CU3E9__1_0_1(),
U3CU3Ec_t44063686_StaticFields::get_offset_of_U3CU3E9__1_1_2(),
U3CU3Ec_t44063686_StaticFields::get_offset_of_U3CU3E9__1_2_3(),
U3CU3Ec_t44063686_StaticFields::get_offset_of_U3CU3E9__1_3_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize711 = { sizeof (HMACSHA384_t117937311), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable711[1] =
{
HMACSHA384_t117937311::get_offset_of_m_useLegacyBlockSize_12(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize712 = { sizeof (U3CU3Ec_t3166561961), -1, sizeof(U3CU3Ec_t3166561961_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable712[5] =
{
U3CU3Ec_t3166561961_StaticFields::get_offset_of_U3CU3E9_0(),
U3CU3Ec_t3166561961_StaticFields::get_offset_of_U3CU3E9__2_0_1(),
U3CU3Ec_t3166561961_StaticFields::get_offset_of_U3CU3E9__2_1_2(),
U3CU3Ec_t3166561961_StaticFields::get_offset_of_U3CU3E9__2_2_3(),
U3CU3Ec_t3166561961_StaticFields::get_offset_of_U3CU3E9__2_3_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize713 = { sizeof (HMACSHA512_t923916539), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable713[1] =
{
HMACSHA512_t923916539::get_offset_of_m_useLegacyBlockSize_12(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize714 = { sizeof (U3CU3Ec_t616840057), -1, sizeof(U3CU3Ec_t616840057_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable714[5] =
{
U3CU3Ec_t616840057_StaticFields::get_offset_of_U3CU3E9_0(),
U3CU3Ec_t616840057_StaticFields::get_offset_of_U3CU3E9__2_0_1(),
U3CU3Ec_t616840057_StaticFields::get_offset_of_U3CU3E9__2_1_2(),
U3CU3Ec_t616840057_StaticFields::get_offset_of_U3CU3E9__2_2_3(),
U3CU3Ec_t616840057_StaticFields::get_offset_of_U3CU3E9__2_3_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize715 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize716 = { sizeof (KeyedHashAlgorithm_t112861511), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable716[1] =
{
KeyedHashAlgorithm_t112861511::get_offset_of_KeyValue_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize717 = { sizeof (MACTripleDES_t1631262397), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable717[5] =
{
MACTripleDES_t1631262397::get_offset_of_m_encryptor_5(),
MACTripleDES_t1631262397::get_offset_of__cs_6(),
MACTripleDES_t1631262397::get_offset_of__ts_7(),
MACTripleDES_t1631262397::get_offset_of_m_bytesPerBlock_8(),
MACTripleDES_t1631262397::get_offset_of_des_9(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize718 = { sizeof (TailStream_t1447577651), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable718[4] =
{
TailStream_t1447577651::get_offset_of__Buffer_5(),
TailStream_t1447577651::get_offset_of__BufferSize_6(),
TailStream_t1447577651::get_offset_of__BufferIndex_7(),
TailStream_t1447577651::get_offset_of__BufferFull_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize719 = { sizeof (MaskGenerationMethod_t2116484826), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize720 = { sizeof (MD5_t3177620429), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize721 = { sizeof (PKCS1MaskGenerationMethod_t1129351447), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable721[1] =
{
PKCS1MaskGenerationMethod_t1129351447::get_offset_of_HashNameValue_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize722 = { sizeof (RandomNumberGenerator_t386037858), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize723 = { sizeof (RC2_t3167825714), -1, sizeof(RC2_t3167825714_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable723[3] =
{
RC2_t3167825714::get_offset_of_EffectiveKeySizeValue_9(),
RC2_t3167825714_StaticFields::get_offset_of_s_legalBlockSizes_10(),
RC2_t3167825714_StaticFields::get_offset_of_s_legalKeySizes_11(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize724 = { sizeof (RC2CryptoServiceProvider_t662919463), -1, sizeof(RC2CryptoServiceProvider_t662919463_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable724[2] =
{
RC2CryptoServiceProvider_t662919463::get_offset_of_m_use40bitSalt_12(),
RC2CryptoServiceProvider_t662919463_StaticFields::get_offset_of_s_legalKeySizes_13(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize725 = { sizeof (Rijndael_t2986313634), -1, sizeof(Rijndael_t2986313634_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable725[2] =
{
Rijndael_t2986313634_StaticFields::get_offset_of_s_legalBlockSizes_9(),
Rijndael_t2986313634_StaticFields::get_offset_of_s_legalKeySizes_10(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize726 = { sizeof (RijndaelManaged_t3586970409), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize727 = { sizeof (RijndaelManagedTransformMode_t144661339)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable727[3] =
{
RijndaelManagedTransformMode_t144661339::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize728 = { sizeof (RijndaelManagedTransform_t4102601014), -1, sizeof(RijndaelManagedTransform_t4102601014_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable728[24] =
{
RijndaelManagedTransform_t4102601014::get_offset_of_m_cipherMode_0(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_paddingValue_1(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_transformMode_2(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_blockSizeBits_3(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_blockSizeBytes_4(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_inputBlockSize_5(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_outputBlockSize_6(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_encryptKeyExpansion_7(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_decryptKeyExpansion_8(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_Nr_9(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_Nb_10(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_Nk_11(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_encryptindex_12(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_decryptindex_13(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_IV_14(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_lastBlockBuffer_15(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_depadBuffer_16(),
RijndaelManagedTransform_t4102601014::get_offset_of_m_shiftRegister_17(),
RijndaelManagedTransform_t4102601014_StaticFields::get_offset_of_s_Sbox_18(),
RijndaelManagedTransform_t4102601014_StaticFields::get_offset_of_s_Rcon_19(),
RijndaelManagedTransform_t4102601014_StaticFields::get_offset_of_s_T_20(),
RijndaelManagedTransform_t4102601014_StaticFields::get_offset_of_s_TF_21(),
RijndaelManagedTransform_t4102601014_StaticFields::get_offset_of_s_iT_22(),
RijndaelManagedTransform_t4102601014_StaticFields::get_offset_of_s_iTF_23(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize729 = { sizeof (RIPEMD160_t268675434), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize730 = { sizeof (RIPEMD160Managed_t2491561941), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable730[4] =
{
RIPEMD160Managed_t2491561941::get_offset_of__buffer_4(),
RIPEMD160Managed_t2491561941::get_offset_of__count_5(),
RIPEMD160Managed_t2491561941::get_offset_of__stateMD160_6(),
RIPEMD160Managed_t2491561941::get_offset_of__blockDWords_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize731 = { sizeof (RSAParameters_t1728406613)+ sizeof (RuntimeObject), sizeof(RSAParameters_t1728406613_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable731[8] =
{
RSAParameters_t1728406613::get_offset_of_Exponent_0() + static_cast<int32_t>(sizeof(RuntimeObject)),
RSAParameters_t1728406613::get_offset_of_Modulus_1() + static_cast<int32_t>(sizeof(RuntimeObject)),
RSAParameters_t1728406613::get_offset_of_P_2() + static_cast<int32_t>(sizeof(RuntimeObject)),
RSAParameters_t1728406613::get_offset_of_Q_3() + static_cast<int32_t>(sizeof(RuntimeObject)),
RSAParameters_t1728406613::get_offset_of_DP_4() + static_cast<int32_t>(sizeof(RuntimeObject)),
RSAParameters_t1728406613::get_offset_of_DQ_5() + static_cast<int32_t>(sizeof(RuntimeObject)),
RSAParameters_t1728406613::get_offset_of_InverseQ_6() + static_cast<int32_t>(sizeof(RuntimeObject)),
RSAParameters_t1728406613::get_offset_of_D_7() + static_cast<int32_t>(sizeof(RuntimeObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize732 = { sizeof (RSA_t2385438082), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize733 = { sizeof (RSAOAEPKeyExchangeDeformatter_t3344463048), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable733[2] =
{
RSAOAEPKeyExchangeDeformatter_t3344463048::get_offset_of__rsaKey_0(),
RSAOAEPKeyExchangeDeformatter_t3344463048::get_offset_of__rsaOverridesDecrypt_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize734 = { sizeof (RSAOAEPKeyExchangeFormatter_t2041696538), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable734[2] =
{
RSAOAEPKeyExchangeFormatter_t2041696538::get_offset_of__rsaKey_0(),
RSAOAEPKeyExchangeFormatter_t2041696538::get_offset_of__rsaOverridesEncrypt_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize735 = { sizeof (RSAPKCS1KeyExchangeDeformatter_t2578812791), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable735[2] =
{
RSAPKCS1KeyExchangeDeformatter_t2578812791::get_offset_of__rsaKey_0(),
RSAPKCS1KeyExchangeDeformatter_t2578812791::get_offset_of__rsaOverridesDecrypt_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize736 = { sizeof (RSAPKCS1KeyExchangeFormatter_t2761096101), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable736[3] =
{
RSAPKCS1KeyExchangeFormatter_t2761096101::get_offset_of_RngValue_0(),
RSAPKCS1KeyExchangeFormatter_t2761096101::get_offset_of__rsaKey_1(),
RSAPKCS1KeyExchangeFormatter_t2761096101::get_offset_of__rsaOverridesEncrypt_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize737 = { sizeof (RSAEncryptionPadding_t979300544), -1, sizeof(RSAEncryptionPadding_t979300544_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable737[7] =
{
RSAEncryptionPadding_t979300544_StaticFields::get_offset_of_s_pkcs1_0(),
RSAEncryptionPadding_t979300544_StaticFields::get_offset_of_s_oaepSHA1_1(),
RSAEncryptionPadding_t979300544_StaticFields::get_offset_of_s_oaepSHA256_2(),
RSAEncryptionPadding_t979300544_StaticFields::get_offset_of_s_oaepSHA384_3(),
RSAEncryptionPadding_t979300544_StaticFields::get_offset_of_s_oaepSHA512_4(),
RSAEncryptionPadding_t979300544::get_offset_of__mode_5(),
RSAEncryptionPadding_t979300544::get_offset_of__oaepHashAlgorithm_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize738 = { sizeof (RSAEncryptionPaddingMode_t4163793404)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable738[3] =
{
RSAEncryptionPaddingMode_t4163793404::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize739 = { sizeof (SHA1_t1803193667), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize740 = { sizeof (SHA1Managed_t1754513891), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable740[4] =
{
SHA1Managed_t1754513891::get_offset_of__buffer_4(),
SHA1Managed_t1754513891::get_offset_of__count_5(),
SHA1Managed_t1754513891::get_offset_of__stateSHA1_6(),
SHA1Managed_t1754513891::get_offset_of__expandedBuffer_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize741 = { sizeof (SHA256_t3672283617), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize742 = { sizeof (SHA256Managed_t955042874), -1, sizeof(SHA256Managed_t955042874_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable742[5] =
{
SHA256Managed_t955042874::get_offset_of__buffer_4(),
SHA256Managed_t955042874::get_offset_of__count_5(),
SHA256Managed_t955042874::get_offset_of__stateSHA256_6(),
SHA256Managed_t955042874::get_offset_of__W_7(),
SHA256Managed_t955042874_StaticFields::get_offset_of__K_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize743 = { sizeof (SHA384_t540967702), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize744 = { sizeof (SHA384Managed_t74158575), -1, sizeof(SHA384Managed_t74158575_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable744[5] =
{
SHA384Managed_t74158575::get_offset_of__buffer_4(),
SHA384Managed_t74158575::get_offset_of__count_5(),
SHA384Managed_t74158575::get_offset_of__stateSHA384_6(),
SHA384Managed_t74158575::get_offset_of__W_7(),
SHA384Managed_t74158575_StaticFields::get_offset_of__K_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize745 = { sizeof (SHA512_t1346946930), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize746 = { sizeof (SHA512Managed_t1787336339), -1, sizeof(SHA512Managed_t1787336339_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable746[5] =
{
SHA512Managed_t1787336339::get_offset_of__buffer_4(),
SHA512Managed_t1787336339::get_offset_of__count_5(),
SHA512Managed_t1787336339::get_offset_of__stateSHA512_6(),
SHA512Managed_t1787336339::get_offset_of__W_7(),
SHA512Managed_t1787336339_StaticFields::get_offset_of__K_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize747 = { sizeof (SignatureDescription_t1971889425), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable747[4] =
{
SignatureDescription_t1971889425::get_offset_of__strKey_0(),
SignatureDescription_t1971889425::get_offset_of__strDigest_1(),
SignatureDescription_t1971889425::get_offset_of__strFormatter_2(),
SignatureDescription_t1971889425::get_offset_of__strDeformatter_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize748 = { sizeof (RSAPKCS1SignatureDescription_t653172199), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable748[1] =
{
RSAPKCS1SignatureDescription_t653172199::get_offset_of__hashAlgorithm_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize749 = { sizeof (RSAPKCS1SHA1SignatureDescription_t2887980541), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize750 = { sizeof (RSAPKCS1SHA256SignatureDescription_t4122087809), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize751 = { sizeof (RSAPKCS1SHA384SignatureDescription_t519503511), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize752 = { sizeof (RSAPKCS1SHA512SignatureDescription_t4135346397), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize753 = { sizeof (DSASignatureDescription_t1163053634), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize754 = { sizeof (SymmetricAlgorithm_t4254223087), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable754[9] =
{
SymmetricAlgorithm_t4254223087::get_offset_of_BlockSizeValue_0(),
SymmetricAlgorithm_t4254223087::get_offset_of_FeedbackSizeValue_1(),
SymmetricAlgorithm_t4254223087::get_offset_of_IVValue_2(),
SymmetricAlgorithm_t4254223087::get_offset_of_KeyValue_3(),
SymmetricAlgorithm_t4254223087::get_offset_of_LegalBlockSizesValue_4(),
SymmetricAlgorithm_t4254223087::get_offset_of_LegalKeySizesValue_5(),
SymmetricAlgorithm_t4254223087::get_offset_of_KeySizeValue_6(),
SymmetricAlgorithm_t4254223087::get_offset_of_ModeValue_7(),
SymmetricAlgorithm_t4254223087::get_offset_of_PaddingValue_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize755 = { sizeof (TripleDES_t92303514), -1, sizeof(TripleDES_t92303514_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable755[2] =
{
TripleDES_t92303514_StaticFields::get_offset_of_s_legalBlockSizes_9(),
TripleDES_t92303514_StaticFields::get_offset_of_s_legalKeySizes_10(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize756 = { sizeof (TripleDESCryptoServiceProvider_t3595206342), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize757 = { sizeof (Utils_t1416439708), -1, sizeof(Utils_t1416439708_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable757[1] =
{
Utils_t1416439708_StaticFields::get_offset_of__rng_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize758 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize759 = { sizeof (X509Certificate_t713131622), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable759[4] =
{
X509Certificate_t713131622::get_offset_of_impl_0(),
X509Certificate_t713131622::get_offset_of_hideDates_1(),
X509Certificate_t713131622::get_offset_of_issuer_name_2(),
X509Certificate_t713131622::get_offset_of_subject_name_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize760 = { sizeof (X509CertificateImpl_t2851385038), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable760[1] =
{
X509CertificateImpl_t2851385038::get_offset_of_cachedCertificateHash_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize761 = { sizeof (X509CertificateImplMono_t285361170), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable761[1] =
{
X509CertificateImplMono_t285361170::get_offset_of_x509_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize762 = { sizeof (X509Helper_t1273321433), -1, sizeof(X509Helper_t1273321433_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable762[1] =
{
X509Helper_t1273321433_StaticFields::get_offset_of_nativeHelper_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize763 = { sizeof (X509KeyStorageFlags_t441861693)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable763[7] =
{
X509KeyStorageFlags_t441861693::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize764 = { sizeof (OidGroup_t1489865352)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable764[13] =
{
OidGroup_t1489865352::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize765 = { sizeof (X509CertificateImplApple_t630491926), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable765[2] =
{
X509CertificateImplApple_t630491926::get_offset_of_handle_1(),
X509CertificateImplApple_t630491926::get_offset_of_fallback_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize766 = { sizeof (RegistryRights_t345449412)+ sizeof (RuntimeObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable766[15] =
{
RegistryRights_t345449412::get_offset_of_value___2() + static_cast<int32_t>(sizeof(RuntimeObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize767 = { sizeof (DeserializationEventHandler_t1473997819), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize768 = { sizeof (SerializationEventHandler_t2446424469), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize769 = { sizeof (FormatterConverter_t2760117746), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize770 = { sizeof (FormatterServices_t305532257), -1, sizeof(FormatterServices_t305532257_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable770[6] =
{
FormatterServices_t305532257_StaticFields::get_offset_of_m_MemberInfoTable_0(),
FormatterServices_t305532257_StaticFields::get_offset_of_unsafeTypeForwardersIsEnabled_1(),
FormatterServices_t305532257_StaticFields::get_offset_of_unsafeTypeForwardersIsEnabledInitialized_2(),
FormatterServices_t305532257_StaticFields::get_offset_of_s_FormatterServicesSyncObject_3(),
FormatterServices_t305532257_StaticFields::get_offset_of_advancedTypes_4(),
FormatterServices_t305532257_StaticFields::get_offset_of_s_binder_5(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize771 = { sizeof (SurrogateForCyclicalReference_t3309482836), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable771[1] =
{
SurrogateForCyclicalReference_t3309482836::get_offset_of_innerSurrogate_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize772 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize773 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize774 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize775 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize776 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize777 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize778 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize779 = { sizeof (MemberHolder_t2755910714), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable779[2] =
{
MemberHolder_t2755910714::get_offset_of_memberType_0(),
MemberHolder_t2755910714::get_offset_of_context_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize780 = { sizeof (ObjectIDGenerator_t1260826161), -1, sizeof(ObjectIDGenerator_t1260826161_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable780[5] =
{
ObjectIDGenerator_t1260826161::get_offset_of_m_currentCount_0(),
ObjectIDGenerator_t1260826161::get_offset_of_m_currentSize_1(),
ObjectIDGenerator_t1260826161::get_offset_of_m_ids_2(),
ObjectIDGenerator_t1260826161::get_offset_of_m_objs_3(),
ObjectIDGenerator_t1260826161_StaticFields::get_offset_of_sizes_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize781 = { sizeof (ObjectManager_t1653064325), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable781[8] =
{
ObjectManager_t1653064325::get_offset_of_m_onDeserializationHandler_0(),
ObjectManager_t1653064325::get_offset_of_m_onDeserializedHandler_1(),
ObjectManager_t1653064325::get_offset_of_m_objects_2(),
ObjectManager_t1653064325::get_offset_of_m_topObject_3(),
ObjectManager_t1653064325::get_offset_of_m_specialFixupObjects_4(),
ObjectManager_t1653064325::get_offset_of_m_fixupCount_5(),
ObjectManager_t1653064325::get_offset_of_m_selector_6(),
ObjectManager_t1653064325::get_offset_of_m_context_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize782 = { sizeof (ObjectHolder_t2801344551), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable782[14] =
{
ObjectHolder_t2801344551::get_offset_of_m_object_0(),
ObjectHolder_t2801344551::get_offset_of_m_id_1(),
ObjectHolder_t2801344551::get_offset_of_m_missingElementsRemaining_2(),
ObjectHolder_t2801344551::get_offset_of_m_missingDecendents_3(),
ObjectHolder_t2801344551::get_offset_of_m_serInfo_4(),
ObjectHolder_t2801344551::get_offset_of_m_surrogate_5(),
ObjectHolder_t2801344551::get_offset_of_m_missingElements_6(),
ObjectHolder_t2801344551::get_offset_of_m_dependentObjects_7(),
ObjectHolder_t2801344551::get_offset_of_m_next_8(),
ObjectHolder_t2801344551::get_offset_of_m_flags_9(),
ObjectHolder_t2801344551::get_offset_of_m_markForFixupWhenAvailable_10(),
ObjectHolder_t2801344551::get_offset_of_m_valueFixup_11(),
ObjectHolder_t2801344551::get_offset_of_m_typeLoad_12(),
ObjectHolder_t2801344551::get_offset_of_m_reachable_13(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize783 = { sizeof (FixupHolder_t3112688910), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable783[3] =
{
FixupHolder_t3112688910::get_offset_of_m_id_0(),
FixupHolder_t3112688910::get_offset_of_m_fixupInfo_1(),
FixupHolder_t3112688910::get_offset_of_m_fixupType_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize784 = { sizeof (FixupHolderList_t3799028159), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable784[2] =
{
FixupHolderList_t3799028159::get_offset_of_m_values_0(),
FixupHolderList_t3799028159::get_offset_of_m_count_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize785 = { sizeof (LongList_t2258305620), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable785[4] =
{
LongList_t2258305620::get_offset_of_m_values_0(),
LongList_t2258305620::get_offset_of_m_count_1(),
LongList_t2258305620::get_offset_of_m_totalItems_2(),
LongList_t2258305620::get_offset_of_m_currentItem_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize786 = { sizeof (ObjectHolderList_t2007846727), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable786[2] =
{
ObjectHolderList_t2007846727::get_offset_of_m_values_0(),
ObjectHolderList_t2007846727::get_offset_of_m_count_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize787 = { sizeof (ObjectHolderListEnumerator_t501693956), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable787[4] =
{
ObjectHolderListEnumerator_t501693956::get_offset_of_m_isFixupEnumerator_0(),
ObjectHolderListEnumerator_t501693956::get_offset_of_m_list_1(),
ObjectHolderListEnumerator_t501693956::get_offset_of_m_startingVersion_2(),
ObjectHolderListEnumerator_t501693956::get_offset_of_m_currPos_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize788 = { sizeof (TypeLoadExceptionHolder_t2983813904), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable788[1] =
{
TypeLoadExceptionHolder_t2983813904::get_offset_of_m_typeName_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize789 = { sizeof (SafeSerializationEventArgs_t27819340), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable789[2] =
{
SafeSerializationEventArgs_t27819340::get_offset_of_m_streamingContext_1(),
SafeSerializationEventArgs_t27819340::get_offset_of_m_serializedStates_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize790 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize791 = { sizeof (SafeSerializationManager_t2481557153), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable791[6] =
{
SafeSerializationManager_t2481557153::get_offset_of_m_serializedStates_0(),
SafeSerializationManager_t2481557153::get_offset_of_m_savedSerializationInfo_1(),
SafeSerializationManager_t2481557153::get_offset_of_m_realObject_2(),
SafeSerializationManager_t2481557153::get_offset_of_m_realType_3(),
SafeSerializationManager_t2481557153::get_offset_of_SerializeObjectState_4(),
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize792 = { sizeof (OptionalFieldAttribute_t761606048), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable792[1] =
{
OptionalFieldAttribute_t761606048::get_offset_of_versionAdded_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize793 = { sizeof (OnSerializingAttribute_t2580696919), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize794 = { sizeof (OnSerializedAttribute_t2595932830), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize795 = { sizeof (OnDeserializingAttribute_t338753086), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize796 = { sizeof (OnDeserializedAttribute_t1335880599), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize797 = { sizeof (SerializationBinder_t274213469), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize798 = { sizeof (SerializationEvents_t3591775508), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable798[4] =
{
SerializationEvents_t3591775508::get_offset_of_m_OnSerializingMethods_0(),
SerializationEvents_t3591775508::get_offset_of_m_OnSerializedMethods_1(),
SerializationEvents_t3591775508::get_offset_of_m_OnDeserializingMethods_2(),
SerializationEvents_t3591775508::get_offset_of_m_OnDeserializedMethods_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize799 = { sizeof (SerializationEventsCache_t2327969880), -1, sizeof(SerializationEventsCache_t2327969880_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable799[1] =
{
SerializationEventsCache_t2327969880_StaticFields::get_offset_of_cache_0(),
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"tuannapci@gmail.com"
] | tuannapci@gmail.com |
de3321a73c22f47f061891bc83f6a3bd64645815 | c0e0138bff95c2eac038349772e36754887a10ae | /mdk_release_18.08.10_general_purpose/mdk/common/components/kernelLib/MvCV/kernels/gaussVx2_fp16/unittest/dummy/shave/init.cpp | 241327709ed20f2dc4fc7e0aca6fbf230b623703 | [] | no_license | elfmedy/vvdn_tofa | f24d2e1adc617db5f2b1aef85f478998aa1840c9 | ce514e0506738a50c0e3f098d8363f206503a311 | refs/heads/master | 2020-04-13T17:52:19.490921 | 2018-09-25T12:01:21 | 2018-09-25T12:01:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,336 | cpp | ///
/// @file
/// @copyright All code copyright Movidius Ltd 2013, all rights reserved.
/// For License Warranty see: common/license.txt
///
/// @brief kernel function call for unitary test
///
#include <gaussVx2_fp16.h>
#include <stdio.h>
#include <mv_types.h>
#include <moviVectorTypes.h>
#include <svuCommonShave.h>
#define TEST_FRAME_WIDTH 1920
#define TEST_FRAME_HEIGHT 16
half __attribute__ ((aligned (16))) input[TEST_FRAME_HEIGHT][TEST_FRAME_WIDTH];
/*output pre pad marker*/
uint32_t __attribute__((section(".kept.data"))) output_u32prePad[4] __attribute__ ((aligned (16)));
/*output data marker*/
half __attribute__((section(".kept.data"))) output[1][TEST_FRAME_WIDTH] __attribute__ ((aligned (16)));
/*output post pad marker*/
uint32_t __attribute__((section(".kept.data"))) output_u32postPad[4] __attribute__ ((aligned (16)));
u32 width;
half* inLine[TEST_FRAME_HEIGHT];
half* outLine[TEST_FRAME_HEIGHT];
half** inLines;
half** outLines;
int main( void )
{
int i;
for(i = 0; i < 5; i++)
{
inLine[i] = (half*)input[i];
}
outLine[0] = (half*)output[0];
inLines = (half**)inLine;
outLines = (half**)outLine;
#ifdef UNIT_TEST_USE_C_VERSION
mvcvGaussVx2_fp16(inLines, outLines, width);
#else
mvcvGaussVx2_fp16_asm(inLines, outLines, width);
#endif
SHAVE_HALT;
return 0;
}
| [
"palani.andavan@vvdntech.com"
] | palani.andavan@vvdntech.com |
1a2c35fbeb2f642ab9484019ce0ed118eaac19c1 | afe991161d81ea71dec338ecb5cd287243cbbcdb | /FundOfComp/Lab6-2/kilomile.cpp | d7799571db26e3574b7c72afb5f78d91a6149f45 | [] | no_license | ryanlockman333/UCDenver_School_Projects | 909bfe4ba4952f702026a0cdc796fa59a295a68b | ea69b8ffb8056aef6ecc017db86191a4edfcddd0 | refs/heads/master | 2022-01-17T12:54:05.796899 | 2022-01-12T20:09:31 | 2022-01-12T20:09:31 | 153,162,614 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,626 | cpp | /*
This program will calculate miles into kilometres or kilometres into miles
depending on the user's choice.
Ryan Lockman: 101430670
*/
// Headers
#include <iostream>
// Global Constants
const float KTOM = .621, MTOK = 1.61;
// Function Prototypes
float kiloToMile(float kiloIn);
float mileToKilo(float mileIn);
int main() {
// Declarations
float kilos = 0, miles = 0;
int choice = 0;
// Greet User
std::cout << "This program converts miles to kilometres\n"
<< "and also kilometres into miles.\n\n";
// Loop Program
do {
std::cout << "\n\n MENU \n"
<< "1. Miles to Kilometres\n"
<< "2. Kilometres to Miles\n"
<< "3. Quit\n\n"
<< "Please enter your choice: ";
std::cin >> choice;
// Process Choice
if(choice == 1) {
std::cout << "\nPlease enter your miles to be converted: ";
std::cin >> miles;
std::cout << "\n" << miles << " miles = " << mileToKilo(miles) << " kilometres";
}
else if(choice == 2) {
std::cout << "\nPlease enter your kilometres to be converted: ";
std::cin >> kilos;
std::cout << "\n" << kilos << " kilometres = " << kiloToMile(kilos) << " miles";
}
}while(choice != 3);
std::cout << "\n\nGood-Bye\n\n";
return 0;
}
// Pre_Condition: kiloIn is of type float
// Post-Condition: The return is the kilometres converted to miles
float kiloToMile(float kiloIn) {
return(kiloIn * KTOM);
}
// Pre_Condition: mileIn is of type float
// Post-Condition: The return is the miles converted to kilometres
float mileToKilo(float mileIn) {
return(mileIn * MTOK);
} | [
"noreply@github.com"
] | ryanlockman333.noreply@github.com |
bc1d662657797561f5b3dd91017de765393c19ad | 07b79ec27132b2632fc0273efad4647f56b70068 | /cpptest1.cpp | 5b8f26adac5624ba2899695012a1dee09682b804 | [] | no_license | oliverhust/cpp_lianxi | 549797eefb4742c87dc10155cedd31b4c6081518 | 6a162068a374af0ded7237af7eb9d4dc11112034 | refs/heads/master | 2020-07-22T22:41:58.162958 | 2016-12-09T01:15:23 | 2016-12-09T01:15:23 | 67,104,685 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 207 | cpp | #include <iostream>
#include <string>
using namespace std;
int main()
{
char str[100];
memcpy(str, "abc", 4);
printf("%s\n", str);
cout << "abcdeg1" << endl;
cout << "abcdeg2" << endl;
return 0;
} | [
"liangjinchao@d3p.com"
] | liangjinchao@d3p.com |
b6fc6baec63d92eb27cbcbdce3307a90e848c9fa | 7ffc27ff353e974f6257e7ada0cd494439e2be4f | /11/1172.cpp | 4c35231ee232514633c004ba8f9c2390e83e4744 | [] | no_license | ryogo108/AOJ | 95811475b9f4fbbe18bbf52dd4bb849a4f5395a5 | b91ad129cf63413f819963d74e10639b50caa778 | refs/heads/master | 2018-12-28T08:59:18.429325 | 2015-08-12T06:11:44 | 2015-08-12T06:11:44 | 28,731,035 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 357 | cpp | #include<iostream>
#include<set>
using namespace std;
set<int>prime;
int main(){
prime.insert(2);
for(int i=3;i<500000;i++){
for(int j=2;j*j<=i;j++){
if(i%j==0)goto fail;
}
prime.insert(i);
fail:;
}
int n;
while(cin>>n && n){
int ans=0;
for(set<int>::iterator itr=prime.upper_bound(n);*itr<=n*2;itr++)ans++;
cout<<ans<<endl;
}
}
| [
"ryogo.1008@gmail.com"
] | ryogo.1008@gmail.com |
41cf27fb7171adb5d4a9dd5b64ba5cbea9a54f65 | ff21dffd374ea4dc40977a0388671d515c22ca01 | /include/script.h | 52640f4e38552816cc1c7814abc5a64d83aa76c8 | [] | no_license | fangcun010/UnLike3D | c701d06ed94854f55868bad9569aaafa67b5f295 | ad53751674479f4b25ac2a88b4b43ed9bb84d5dc | refs/heads/master | 2020-05-01T08:25:39.050517 | 2019-07-05T09:50:22 | 2019-07-05T09:50:22 | 177,378,619 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,444 | h | /*
MIT License
Copyright(c) 2019 fangcun
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
#ifndef _SCRIPT_H_INCLUDED
#define _SCRIPT_H_INCLUDED
#include <scriptinterface.h>
namespace unlike3d {
class Script {
private:
ScriptInterface script_interface_;
public:
ScriptInterface &GetScriptInterface();
virtual void MakeEnvironment();
virtual void DestroyEnvironment();
virtual bool RunScript(const char *script_file);
virtual ~Script();
};
}
#endif | [
"fangcun010@gmail.com"
] | fangcun010@gmail.com |
baf3732f627f1308da647185f710f42e30475631 | 3802934b14ec8bbc0e62cd37f25fcc337d37d426 | /Online Judge/Number Theory/Unisequence.cpp | 427b7faebaee417e3e864f91414e86085716c66a | [] | no_license | Mdananda/Competitive-Programming | b8f21c177bc71d55e086689f3782be2bb4caae2d | a59f605f2d2bc7f693001831c1aeb1182581e3da | refs/heads/master | 2023-04-27T14:14:48.799117 | 2021-05-02T15:26:56 | 2021-05-02T15:26:56 | 363,454,275 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 645 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define sc scanf
#define pf printf
#define pb push_back
int main()
{
ll i, j, n, cnt = 0, ans = 0;
sc("%lld", &n);
vector<int> vec;
map <ll, ll> mp;
for(int i = 1; i <= n; ++i)
{
ll x;
sc("%lld", &x);
vec.pb(x);
}
for(int i = 0; i < n; ++i)
{
mp[vec[i]]++;
if(mp[x] == 2)
break;
}
if(i == n)
{
cout<<"0"<<endl;
return 0;
}
for(j = n-1; j >= 0; j--)
{
mp[vec[j]]++;
if(mp[vec[j]] == 2)
break;
}
return 0;
}
| [
"ananda_0121@yahoo.com"
] | ananda_0121@yahoo.com |
e3617eb8a7cc027de63ba6ec508af85cbca8ff55 | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_6404600001200128_0/C++/stzgd/A.cpp | 9d0daa375abe2148945baa7f72365c658c2cc313 | [] | no_license | alexandraback/datacollection | 0bc67a9ace00abbc843f4912562f3a064992e0e9 | 076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf | refs/heads/master | 2021-01-24T18:27:24.417992 | 2017-05-23T09:23:38 | 2017-05-23T09:23:38 | 84,313,442 | 2 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 777 | cpp | #include <cstdio>
#include <cassert>
const int MAXN = 1111;
int n;
int m[MAXN];
void Init() {
assert(scanf("%d", &n) == 1);
for (int i = 0; i < n; ++i) {
assert(scanf("%d", m + i) == 1);
}
}
void Work() {
int ans1 = 0;
for (int i = 1; i < n; ++i) {
if (m[i] < m[i - 1]) {
ans1 += m[i - 1] - m[i];
}
}
int rate = 0;
for (int i = 1; i < n; ++i)
if (m[i - 1] - m[i] > rate)
rate = m[i - 1] - m[i];
int ans2 = 0;
for (int i = 0; i < n - 1; ++i) {
if (rate >= m[i])
ans2 += m[i];
else
ans2 += rate;
}
printf("%d %d\n", ans1, ans2);
}
int main() {
int cases;
assert(scanf("%d", &cases) == 1);
for (int i = 1; i <= cases; ++i) {
printf("Case #%d: ", i);
Init();
Work();
}
return 0;
}
| [
"eewestman@gmail.com"
] | eewestman@gmail.com |
4b94c9262be038db7ca7f7e321c2ce57f6a3be15 | 0af0e7e9d42da580595ff421efe0b06acf38f0c3 | /include/ReadWrite.h | 76cade4a2a1611dc697231625645eac5d7a6ffb8 | [] | no_license | StevenLarge/DiscreteControl_BaseCode | 1425212bb5cd94a449dfd5aa658320e96a359f0a | 0ece5dc2a7366aa850f9cea64b926188a2db2a73 | refs/heads/master | 2020-03-16T20:00:25.031041 | 2018-05-10T18:55:22 | 2018-05-10T18:55:22 | 132,942,308 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 751 | h | /* This is a header file for the Discrete Control Nonequilbrium simulations pertaining to protocol read-in */
#include <string>
void ImportProtocol(double * CPVals, double * LagTimes, int NumCPVals, int TotalTime, int FLAG=0);
void ImportProtocol_String(double * CPVals, double * LagTimes, int NumCPVals, std::string FileName);
void WriteSingleWork(double ProtocolWork, int NumCPVals, int TotalTime, int FLAG);
void WriteWorkArray(double **WorkArray, int * CPVals, int * TotalTime, int NumCPVals, int NumTimes, int FLAG);
void WriteWorkArray_NewLine(int FLAG);
void WriteWorkArray_Element(double Work, int FLAG);
void WriteWorkArray_CPVal(double CPVal, int FLAG);
void WriteWorkArray_Initial(int * TotalTime_Vector, int TimeCounterSize, int FLAG);
| [
"stevelarge7@gmail.com"
] | stevelarge7@gmail.com |
60234d1788cdaa87cad6e357fb198d7e69a938e2 | be1c5a30a6afbb1c7b076eb648651297259a1ed5 | /ObjLoader.hpp | 1405df9b9150ff8af59aaac8e47b1cd1d69417b7 | [] | no_license | slinh/art-toolkit-magic-weapon | 01fdbf3bb1be701ce64269bb942aa17da889cca5 | b6a68f35f74049b6d9ab100ecce694d47ddc3826 | refs/heads/master | 2020-08-06T15:29:12.957187 | 2011-03-16T11:32:43 | 2011-03-16T11:32:43 | 32,493,654 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,261 | hpp | #ifndef __OBJ_LOADER_HPP__
#define __OBJ_LOADER_HPP__
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <iostream>
#include <string>
#include <vector>
class Bbox;
/* vector */
typedef float vec3_t[3];
typedef float vec4_t[4];
/* vertex */
typedef struct
{
vec4_t xyzw;
} obj_vertex_t;
/* texture coordinates */
typedef struct
{
vec3_t uvw;
} obj_texCoord_t;
/* normal vector */
typedef struct
{
vec3_t ijk;
} obj_normal_t;
/* polygon */
typedef struct
{
GLenum type; /* primitive type */
int num_elems; /* number of vertices */
int *vert_indices; /* vertex indices */
int *uvw_indices; /* texture coordinate indices */
int *norm_indices; /* normal vector indices */
} obj_face_t;
typedef enum _typeObj
{
HOUSE,
SETTING
} TypeObj;
class ObjLoader {
protected:
int num_verts; /* number of vertices */
int num_texCoords; /* number of texture coords. */
int num_normals; /* number of normal vectors */
int num_faces; /* number of polygons */
int has_texCoords; /* has texture coordinates? */
int has_normals; /* has normal vectors? */
std::vector<obj_vertex_t *> vertices; /* vertex list */
std::vector<obj_texCoord_t *> texCoords; /* tex. coord. list */
std::vector<obj_normal_t *> normals; /* normal vector list */
std::vector<obj_face_t *> faces; /* model's polygons */
// infos XML
std::string modelFileName;
GLint displayListId;
Bbox * bbox;
public:
ObjLoader();
ObjLoader(std::string filename);
~ObjLoader();
inline const Bbox & getBbox() const { return *bbox; }
inline Bbox & setBbox() { return *bbox; }
inline const GLint & getDisplayListId() const { return displayListId;}
inline GLint & setDisplayListId() { return displayListId;}
inline const std::string & getModelFileName() const { return modelFileName;}
inline std::string & setModelFileName() { return modelFileName;}
int FirstPass (FILE *fp);
int SecondPass (FILE *fp);
int ReadOBJModel (const char *filename);
void RenderOBJModel ();
void initGL();
void draw();
};
#endif
| [
"sophie.linh@86055e40-30d1-0f7e-394c-3b6f406c40ea"
] | sophie.linh@86055e40-30d1-0f7e-394c-3b6f406c40ea |
3f37e023fa025fc054869136719126d8f00b08a5 | 7b2c18f8e8db5e3cfe71e8a791d2cc6e180e208c | /assignments/week1/day5/Dewan_Sunnah_LC_1190.cpp | 4b2704c0bd12139fcb44fb145f60953625547139 | [] | no_license | Dew613/TechnicalInterviewPrep2020 | 909ca0d9311c60e268624ff265670cbcd9a986a9 | be307bd14d8560979cf42fb5f685274003e44f86 | refs/heads/master | 2022-10-16T21:25:39.432613 | 2020-06-15T15:24:34 | 2020-06-15T15:24:34 | 268,604,148 | 0 | 0 | null | 2020-06-01T18:43:40 | 2020-06-01T18:43:40 | null | UTF-8 | C++ | false | false | 1,684 | cpp | /*
Name: Dewan Sunnah
Date: 6/5/20
Problem: https://leetcode.com/problems/reverse-substrings-between-each-pair-of-parentheses/
*/
#include <stack>
#include <iostream>
using namespace std;
string reverse_string(string s){
string ans = "";
for (int i = s.length()-1; i >= 0; i--)
ans+= s[i];
return ans;
}
string reverseParentheses(string s) {
//use a stack to keep track of the last '(' index since i can't use hashmap
stack<int> open_indices;
for (int i = 0; i < (int)s.length(); i++){
if (s[i] == '(')
open_indices.push(i);
if (s[i] == ')'){
int left_index = open_indices.top();
open_indices.pop();
//cout << left_index << " " << i << endl;
//part of the string that needs to be flipped
string flip = s.substr((left_index+1), ((i - left_index) - 1));
//cout << flip << endl;
flip = reverse_string(flip);
//cout << s.substr(0, left_index+1) << " " << flip << " " <<s.substr(i + 1, s.length() - i) << endl;
//puts the string back together
s = s.substr(0, left_index+1) + flip + s.substr(i, (int)s.length() - i);
}
}
//removes the '(' and ')' from the string, need to do this last so theres no errors caused by changing the lenght of s.
string ans = "";
for(int i = 0; i < (int)s.length(); i++){
if(s[i] != '(' && s[i] != ')')
ans+=s[i];
}
return ans;
}
int main(){
return 0;
}
| [
"dewansunnah@Dewans-MBP.fios-router.home"
] | dewansunnah@Dewans-MBP.fios-router.home |
31df750eb1d6c5a00772a3611ddb8ae039c93e94 | f48b6190bd8ff46a8b2c4feeffeef221fd4a8f2b | /invert/src/ofApp.h | e136880e2bbcddbd3a30cf388467e7eece0c907f | [] | no_license | minhajfalaki/cv_basic_cpp | 059d3aa021f01cd2a9f929fa821484575ab1e978 | 08e1cfbb9a41b3d8013213ec67ca76a7d9b7b155 | refs/heads/master | 2020-04-11T11:12:39.178151 | 2018-12-14T06:37:01 | 2018-12-14T06:37:01 | 161,741,296 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 227 | h |
# pragma once
# include "ofMain.h"
class ofApp : public ofBaseApp
{
public:
void setup();
void update();
void draw();
int w,h;
unsigned char * output1;
ofTexture videoTexture01;
ofVideoGrabber videoFeed;
}; | [
"minhajfalaki@github.com"
] | minhajfalaki@github.com |
4918de0e0eebae0313c5eb40434cc941d91d903b | 5678e5fce02d70efd418bb8594966d8b1acadf9d | /app/src/CQRotatedText.cpp | a45955b4ea00829baaa8ae045008f7717db17cfe | [
"MIT"
] | permissive | colinw7/CTk | 2a4f408c4482c9fa4d498ad6fb92d8f81470d5e9 | a68c5d5aafcd6dbe0b01c9cb4d384be5cbad092b | refs/heads/master | 2023-08-17T06:33:22.845710 | 2023-08-15T14:00:19 | 2023-08-15T14:00:19 | 67,455,686 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,312 | cpp | #include <CQRotatedText.h>
#include <QPainter>
#include <cmath>
namespace CQRotatedText {
void
drawRotatedText(QPainter *painter, double x, double y, const QString &text,
double angle, Qt::Alignment align, bool alignBBox)
{
painter->save();
QFontMetrics fm(painter->font());
int th = fm.height();
int tw = fm.horizontalAdvance(text);
double a1 = M_PI*angle/180.0;
double c = cos(-a1);
double s = sin(-a1);
double tx = 0.0, ty = 0.0;
double ax = 0.0, ay = 0.0;
if (! alignBBox) {
double dx = 0.0, dy = 0.0;
if (align & Qt::AlignLeft)
dx = 0.0;
else if (align & Qt::AlignRight)
dx = -tw;
else if (align & Qt::AlignHCenter)
dx = -tw/2.0;
if (align & Qt::AlignBottom)
dy = 0.0;
else if (align & Qt::AlignTop)
dy = th;
else if (align & Qt::AlignVCenter)
dy = th/2.0;
tx = c*dx - s*dy;
ty = s*dx + c*dy;
ax = -s*fm.descent();
ay = c*fm.descent();
}
else {
if (align & Qt::AlignLeft)
tx = -th*s;
else if (align & Qt::AlignRight)
tx = -tw*c;
else if (align & Qt::AlignHCenter)
tx = -(th*s + tw*c)/2.0;
if (align & Qt::AlignBottom)
ty = 0.0;
else if (align & Qt::AlignTop)
ty = -(tw*s - th*c);
else if (align & Qt::AlignVCenter)
ty = -(tw*s - th*c)/2;
ax = -s*fm.descent();
ay = c*fm.descent();
}
//------
QTransform t;
t.translate(x + tx - ax, y + ty - ay);
t.rotate(-angle);
//t.translate(0, -fm.descent());
painter->setTransform(t);
painter->drawText(0, 0, text);
painter->restore();
}
QRectF
bbox(double x, double y, const QString &text, const QFont &font, double angle, double border,
Qt::Alignment align, bool alignBBox)
{
QRectF bbox;
Points points;
bboxData(x, y, text, font, angle, border, bbox, points, align, alignBBox);
return bbox;
}
Points
bboxPoints(double x, double y, const QString &text, const QFont &font, double angle, double border,
Qt::Alignment align, bool alignBBox)
{
QRectF bbox;
Points points;
bboxData(x, y, text, font, angle, border, bbox, points, align, alignBBox);
return points;
}
void
bboxData(double x, double y, const QString &text, const QFont &font, double angle,
double border, QRectF &bbox, Points &points, Qt::Alignment align, bool alignBBox)
{
QFontMetrics fm(font);
//------
int th = int(fm.height() + 2*border);
int tw = int(fm.horizontalAdvance(text) + 2*border);
double a1 = M_PI*angle/180.0;
double c = cos(-a1);
double s = sin(-a1);
//---
double tx = 0.0, ty = 0.0;
if (! alignBBox) {
double dx = 0.0, dy = 0.0;
if (align & Qt::AlignLeft)
dx = -border;
else if (align & Qt::AlignRight)
dx = -tw + border;
else if (align & Qt::AlignHCenter)
dx = -tw/2.0;
if (align & Qt::AlignBottom)
dy = border;
else if (align & Qt::AlignTop)
dy = th - border;
else if (align & Qt::AlignVCenter)
dy = th/2.0;
//---
tx = c*dx - s*dy;
ty = s*dx + c*dy;
}
else {
if (align & Qt::AlignLeft)
tx = -th*s - border;
else if (align & Qt::AlignRight)
tx = -tw*c + border;
else if (align & Qt::AlignHCenter)
tx = -(th*s + tw*c)/2.0;
if (align & Qt::AlignBottom)
ty = border;
else if (align & Qt::AlignTop)
ty = -(tw*s - th*c) - border;
else if (align & Qt::AlignVCenter)
ty = -(tw*s - th*c)/2.0;
}
//------
//x -= c*border - s*border;
//y -= s*border + c*border;
double x1 = x + tx, x2 = x + tw*c + tx, x3 = x + tw*c + th*s + tx, x4 = x + th*s + tx;
double y1 = y + ty, y2 = y + tw*s + ty, y3 = y + tw*s - th*c + ty, y4 = y - th*c + ty;
points.clear();
points.push_back(QPointF(x1, y1));
points.push_back(QPointF(x2, y2));
points.push_back(QPointF(x3, y3));
points.push_back(QPointF(x4, y4));
//---
double xmin = points[0].x(); double xmax = xmin;
double ymin = points[0].y(); double ymax = ymin;
for (uint i = 1; i < 4; ++i) {
xmin = std::min(xmin, points[i].x());
ymin = std::min(ymin, points[i].y());
xmax = std::max(xmax, points[i].x());
ymax = std::max(ymax, points[i].y());
}
bbox = QRectF(xmin, ymin, xmax - xmin, ymax - ymin);
}
}
| [
"colinw7@gmail.com"
] | colinw7@gmail.com |
fde286e26b446a9ec7cdc49d3b9020d79039398e | cad04bb71f3afd50c4df3b2f321cd378d3ad8cb9 | /OJ practices/PTA习题：数据结构与算法题目集/7-38 寻找大富翁.cpp | 03b8ed959edc9ec47e12adc3694f82b11ff85fb8 | [] | no_license | SourDumplings/CodeSolutions | 9033de38005b1d90488e64ccbb99f91c7e7b71ec | 5f9eca3fe5701a8fca234343fde31cfcba94cf27 | refs/heads/master | 2023-08-16T17:23:34.977471 | 2023-08-07T13:14:47 | 2023-08-07T13:14:47 | 110,331,879 | 10 | 8 | null | 2023-06-14T22:25:16 | 2017-11-11T08:59:11 | C | UTF-8 | C++ | false | false | 721 | cpp | /*
@Date : 2018-03-15 13:17:04
@Author : 酸饺子 (changzheng300@foxmail.com)
@Link : https://github.com/SourDumplings
@Version : $Id$
*/
/*
https://pintia.cn/problem-sets/15/problems/865
*/
#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
int main(int argc, char const *argv[])
{
int N, M;
scanf("%d %d", &N, &M);
priority_queue<int> Q;
for (unsigned i = 0; i < N; ++i)
{
int w;
scanf("%d", &w);
Q.push(w);
}
int output = 0;
for (int i = 0; i != N && i != M; ++i)
{
if (output++)
{
putchar(' ');
}
printf("%d", Q.top()); Q.pop();
}
putchar('\n');
return 0;
}
| [
"changzheng300@foxmail.com"
] | changzheng300@foxmail.com |
74ce6499cb401dee8ce258c64138a0f8b764cafb | 19668b1c9f0e6669ba1d59a8158b495792f8687d | /Bolt-Core/src/Graphics/Assets/Meshes/Materials/MaterialGraph/Nodes/MasterNodes/LitMasterNodes.h | f086b9381f8cbc16d2f28fe477e58825eababde3 | [] | no_license | Totomosic/Bolt | a80f50ce2da4cc7dabe92023df9448eb7b57f026 | 3ca257f9f33ef0d04b213365ef42d9a4925b29ef | refs/heads/master | 2021-06-28T19:06:30.656098 | 2020-09-09T13:26:23 | 2020-09-09T13:26:23 | 144,455,421 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 434 | h | #pragma once
#include "../MasterNode.h"
namespace Bolt
{
class BLT_API ShininessNode : public MasterNode
{
public:
ShininessNode();
virtual void ConnectDefaults(MaterialGraph& graph, const MaterialGraphContext& context) override;
};
class BLT_API ShineDamperNode : public MasterNode
{
public:
ShineDamperNode();
virtual void ConnectDefaults(MaterialGraph& graph, const MaterialGraphContext& context) override;
};
} | [
"jordan.thomas.morrison@gmail.com"
] | jordan.thomas.morrison@gmail.com |
6a1b004da1790c64c1e6a71ac7235cb2c6b298c1 | 3a535e6506cff3aa42c993e2ef6cb81bd3169a96 | /src/ofApp.cpp | c543d45c640ef6418aef80ce2ad9729077203175 | [] | no_license | davidruvalcabagonzalez/cs134Project | 47f932e62450342feebdf47954917974007d8a74 | afc7e0b7ee1ce6e4b8936d89d336010ea1b48cfe | refs/heads/master | 2020-03-13T17:51:07.809609 | 2018-05-11T03:56:08 | 2018-05-11T03:56:08 | 131,225,130 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 22,782 | cpp |
//--------------------------------------------------------------
//
// Kevin M. Smith
//
// Mars HiRise Project - startup scene
//
// This is an openFrameworks 3D scene that includes an EasyCam
// and example 3D geometry which I have reconstructed from Mars
// HiRis photographs taken the Mars Reconnaisance Orbiter
//
// You will use this source file (and include file) as a starting point
// to implement assignment 5 (Parts I and II)
//
// Please do not modify any of the keymappings. I would like
// the input interface to be the same for each student's
// work. Please also add your name/date below.
// Please document/comment all of your work !
// Have Fun !!
//
// Student Names:
// Jonathan Su:
// - Provided Octree Solution
// - Found Models
// - Implemented Emmitter
// Yukai Yang
// - Combined Midterm and Octree Solution
// - Wrote Collision detector
// David
// - Provided Midterm Solution
// - Programmed lights and cameras
// Date: 04/19/2018
#include "ofApp.h"
#include "Util.h"
//--------------------------------------------------------------
// setup scene, lighting, state and load geometry
//
void ofApp::setup(){
bWireframe = false;
bDisplayPoints = false;
bAltKeyDown = false;
bCtrlKeyDown = false;
bRoverLoaded = false;
bTerrainSelected = true;
// ofSetWindowShape(1024, 768);
cam.setDistance(10);
cam.setNearClip(.1);
cam.setFov(65.5); // approx equivalent to 28mm in 35mm format
cam.setPosition(ofVec3f(-20,50,50));
ofSetVerticalSync(true);
cam.disableMouseInput();
ofEnableSmoothing();
ofEnableDepthTest();
ofEnableLighting();
// setup rudimentary lighting
//
//initLightingAndMaterials();
//load background image
background.load("geo/background/background.jpg");
//mars.loadModel("geo/mars-low-v2.obj");
mars.loadModel("geo/island2/island.obj");
mars.setScaleNormalization(false);
boundingBox = meshBounds(mars.getMesh(0));
/* Tree Setup */
float treeStart = ofGetElapsedTimeMillis();
//create Octree to x levels
tree.create(mars.getMesh(0),20);
float treeEnd = ofGetElapsedTimeMillis();
cout << "Time creating Octree: " << treeEnd - treeStart << " milliseconds" << endl;
//draw tree to 5 levels
levels = 5;
currLevel = 0;
//gui.setup();
//gui.add(levelSlider.setup("Draw Levels", 5, 0, 15));
/* particle Setup */
p.position = ofVec3f(0,100,0);
p.radius = .5;
particle.add(p);
//create forces
tf = new ThrustForce(ofVec3f(0,0,0));
tf2 = new ThrustForce(ofVec3f(0,0,0));
ipf = new ImpulseRadialForce(100);
gf = new GravityForce(ofVec3f(0,-.1,0));
impulseForce = new ImpulseForce();
restitution = 0.2;
particle.addForce(impulseForce);
particle.addForce(tf);
particle.addForce(gf);
particle.setLifespan(1000000000);
emitter.sys->addForce(tf2);
emitter.sys->addForce(ipf);
emitter.setRandomLife(true);
emitter.setLifespan(10000);
emitter.setLifespanRange(ofVec2f(0.01,.3));
emitter.setPosition(particle.particles[0].position);
emitter.setGroupSize(20);
emitter.setOneShot(false);
emitter.setRate(0);
emitter.start();
burger.model.loadModel("geo/burger/burger.obj");
burger.modelLoaded = true;
burger.sys = particle;
burger.model.setScaleNormalization(false);
burger.model.setScale(.5,.5,.5);
Box b = meshBounds(burger.model.getMesh(0));
burgerBBox = Box(b.min() * .5, b.max() *.5);
thrusterSound.load("sounds/thrusterSound.mp3");
//thrusterSound.setLoop(true);
thrusterSound.setMultiPlay(true);
cam.setTarget(burger.getPosition());
cam.lookAt(burger.getPosition());
trackingpos = mars.getPosition() + ofVec3f(0,50,0);
/* light setup*/
keyLight.setup();
keyLight.enable();
keyLight.setAreaLight(1, 1);
keyLight.setAmbientColor(ofFloatColor(.1, .1, .1));
keyLight.setDiffuseColor(ofFloatColor(1, 1, 1));
keyLight.setSpecularColor(ofFloatColor(1, 1, 1));
keyLight.rotate(45, ofVec3f(0, 1, 0));
keyLight.rotate(-45, ofVec3f(1, 0, 0));
keyLight.setPosition(ofVec3f(-18, 100, -122));
//gui.setup();
//gui.add(keylightpos.setup("KeyLightPosition", ofVec3f(0, 0, 0), ofVec3f(-200, -200, -200), ofVec3f(200, 200, 200)));
fillLight.setup();
fillLight.enable();
fillLight.setSpotlight();
fillLight.setScale(.05);
fillLight.setSpotlightCutOff(15);
fillLight.setAttenuation(2, .001, .001);
fillLight.setAmbientColor(ofFloatColor(0.1, 0.1, 0.1));
fillLight.setDiffuseColor(ofFloatColor(1, 1, 1));
fillLight.setSpecularColor(ofFloatColor(1, 1, 1));
fillLight.rotate(-10, ofVec3f(1, 0, 0));
fillLight.rotate(-45, ofVec3f(0, 1, 0));
fillLight.setPosition(ofVec3f(-81, 81, 94));
//gui.add(filllightpos.setup("FillLightPosition", ofVec3f(0, 0, 0), ofVec3f(-200, -200, -200), ofVec3f(200, 200, 200)));
rimLight.setup();
rimLight.enable();
rimLight.setSpotlight();
rimLight.setScale(.05);
rimLight.setSpotlightCutOff(30);
rimLight.setAttenuation(.2, .001, .001);
rimLight.setAmbientColor(ofFloatColor(.1, 0.1, .1));
rimLight.setDiffuseColor(ofFloatColor(1, 1, 1));
rimLight.setSpecularColor(ofFloatColor(1, 1, 1));
rimLight.rotate(180, ofVec3f(0, 1, 0));
rimLight.setPosition(ofVec3f(-4, 70, -200));
//gui.add(rimLightpos.setup("RimLightPosition", ofVec3f(0, 0, 0), ofVec3f(-200, -200, -200), ofVec3f(200, 200, 200)));
}
//--------------------------------------------------------------
// incrementally update scene (animation)
//
void ofApp::update() {
//levels = levelSlider;
//keyLight.setPosition(keylightpos);
//fillLight.setPosition(filllightpos);
//rimLight.setPosition(rimLightpos);
//particle.update();
emitter.setPosition(burger.sys.particles[0].position);
emitter.update();
burger.update();
collisionDetect();
sidecampos = burger.getPosition() + ofVec3f(0, -3, 0);
topcampos = burger.getPosition() + ofVec3f(0, 4, 0);
if (tracking) {
cam.setTarget(burger.getPosition());
cam.lookAt(burger.getPosition());
}
else if (top) {
cam.setPosition(topcampos);
cam.lookAt(burger.getPosition() + ofVec3f(0, 0, 2));
}
else if (side) {
cam.setPosition(sidecampos);
cam.setTarget(burger.getPosition() + ofVec3f(0,-10,0));
}
else {
cam.lookAt(burger.getPosition());
}
// burgerBBox = meshBounds(burger.model.getMesh(0));
}
//--------------------------------------------------------------
void ofApp::draw(){
// ofBackgroundGradient(ofColor(20), ofColor(0)); // pick your own backgroujnd
ofBackground(ofColor::black);
// cout << ofGetFrameRate() << endl;
ofSetDepthTest(false);
ofSetColor(255,255,255,255);
background.draw(0,0, 1200,1200);
//gui.draw();
ofSetDepthTest(true);
cam.begin();
ofPushMatrix();
//keyLight.draw();
//fillLight.draw();
//rimLight.draw();
if (bWireframe) { // wireframe mode (include axis)
ofDisableLighting();
ofSetColor(ofColor::slateGray);
mars.drawWireframe();
if (bRoverLoaded) {
rover.drawWireframe();
if (!bTerrainSelected) drawAxis(rover.getPosition());
}
if (bTerrainSelected) drawAxis(ofVec3f(0, 0, 0));
}
else {
ofEnableLighting(); // shaded mode
mars.drawFaces();
if (bRoverLoaded) {
rover.drawFaces();
if (!bTerrainSelected) drawAxis(rover.getPosition());
}
if (bTerrainSelected) drawAxis(ofVec3f(0, 0, 0));
}
if (bDisplayPoints) { // display points as an option
glPointSize(3);
ofSetColor(ofColor::green);
mars.drawVertices();
}
/*
// highlight selected point (draw sphere around selected point)
//
if (bPointSelected) {
ofSetColor(ofColor::blue);
ofDrawSphere(selectedPoint, .1);
}
*/
ofNoFill();
ofSetColor(ofColor::white);
drawBox(boundingBox);
//ofVec3f p = burger.model.getPosition();
//Vector3 pos = Vector3(p.x,p.y,p.z);
//drawBox(burgerBBox);
//drawBox(a);
//draw to 5 levels
//tree.draw(levels, currLevel);
//tree.draw(15, currLevel);
burger.draw();
//particle.draw();
emitter.draw();
ofPopMatrix();
cam.end();
}
// Draw an XYZ axis in RGB at world (0,0,0) for reference.
//
void ofApp::drawAxis(ofVec3f location) {
ofPushMatrix();
ofTranslate(location);
ofSetLineWidth(1.0);
// X Axis
ofSetColor(ofColor(255, 0, 0));
ofDrawLine(ofPoint(0, 0, 0), ofPoint(1, 0, 0));
// Y Axis
ofSetColor(ofColor(0, 255, 0));
ofDrawLine(ofPoint(0, 0, 0), ofPoint(0, 1, 0));
// Z Axis
ofSetColor(ofColor(0, 0, 255));
ofDrawLine(ofPoint(0, 0, 0), ofPoint(0, 0, 1));
ofPopMatrix();
}
void ofApp::keyPressed(int key) {
switch (key) {
case 'C':
case 'c':
if (cam.getMouseInputEnabled()) cam.disableMouseInput();
else cam.enableMouseInput();
break;
case 'F':
case 'f':
ofToggleFullscreen();
break;
case 'H':
case 'h':
break;
case '1':
cam.disableMouseInput();
side = false;
top = false;
cam.setPosition(trackingpos);
tracking = true;
break;
case '2':
//top
cam.disableMouseInput();
tracking = false;
side = false;
cam.setPosition(topcampos);
cam.lookAt(mars.getPosition());
top = true;
break;
case '3':
//side
cam.disableMouseInput();
tracking = false;
top = false;
cam.setPosition(sidecampos);
cam.lookAt(cam.getPosition());
side = true;
break;
case '4':
//free
cam.enableMouseInput();
tracking = false;
side = false;
top = false;
cam.setPosition(ofVec3f(50, 50, 50));
cam.lookAt(mars.getPosition());
break;
case 'I':
case 'i':
{
ofVec3f vel = burger.sys.particles[0].velocity;
cout << "velocity: " << vel << endl;
impulseForce->apply(-ofGetFrameRate() * vel);
break;
}
break;
case 'r':
cam.reset();
break;
case 's':
savePicture();
break;
case 't':
setCameraTarget();
break;
case 'u':
break;
case 'v':
togglePointsDisplay();
break;
case 'V':
break;
case 'w':
toggleWireframeMode();
break;
case OF_KEY_ALT:
cam.enableMouseInput();
bAltKeyDown = true;
break;
case OF_KEY_CONTROL:
bCtrlKeyDown = true;
break;
case OF_KEY_SHIFT:
emitter.stop();
break;
case OF_KEY_DEL:
break;
case OF_KEY_UP:
emitter.sys->reset();
emitter.setRate(3);
emitter.setVelocity(ofVec3f(0,-1,0));
tf->add(ofVec3f(0,-.2,0));
tf2->set(ofVec3f(0,10,0));
emitter.start();
if (!thrusterSound.isPlaying())
thrusterSound.play();
break;
case OF_KEY_DOWN:
emitter.sys->reset();
emitter.setRate(3);
emitter.setVelocity(ofVec3f(0,-1,0));
tf->add(ofVec3f(0,.2,0));
tf2->set(ofVec3f(0,-10,0));
emitter.start();
if (!thrusterSound.isPlaying())
thrusterSound.play();
break;
case OF_KEY_LEFT:
emitter.sys->reset();
emitter.setRate(20);
emitter.setVelocity(ofVec3f(-1,-2,0));
tf->add(ofVec3f(.2,0,0));
tf2->set(ofVec3f(-10,0,0));
emitter.start();
if (!thrusterSound.isPlaying())
thrusterSound.play();
break;
case OF_KEY_RIGHT:
emitter.sys->reset();
emitter.setRate(20);
emitter.setVelocity(ofVec3f(1,-2,0));
tf->add(ofVec3f(-.2,0,0));
tf2->set(ofVec3f(10,0,0));
emitter.start();
if (!thrusterSound.isPlaying())
thrusterSound.play();
break;
default:
break;
}
}
void ofApp::toggleWireframeMode() {
bWireframe = !bWireframe;
}
void ofApp::toggleSelectTerrain() {
bTerrainSelected = !bTerrainSelected;
}
void ofApp::togglePointsDisplay() {
bDisplayPoints = !bDisplayPoints;
}
void ofApp::keyReleased(int key) {
switch (key) {
case OF_KEY_ALT:
cam.disableMouseInput();
bAltKeyDown = false;
break;
case OF_KEY_CONTROL:
bCtrlKeyDown = false;
break;
case OF_KEY_SHIFT:
break;
case OF_KEY_UP:
emitter.setRate(0);
emitter.setVelocity(ofVec3f(0,0,0));
tf->set(ofVec3f(0,0,0));
tf2->set(ofVec3f(0,0,0));
thrusterSound.stop();
emitter.sys->reset();
break;
case OF_KEY_DOWN:
emitter.setRate(0);
emitter.setVelocity(ofVec3f(0,0,0));
tf->set(ofVec3f(0,0,0));
tf2->set(ofVec3f(0,0,0));
thrusterSound.stop();
emitter.sys->reset();
break;
case OF_KEY_LEFT:
emitter.setRate(0);
emitter.setVelocity(ofVec3f(0,0,0));
tf->set(ofVec3f(0,0,0));
tf2->set(ofVec3f(0,0,0));
thrusterSound.stop();
emitter.sys->reset();
break;
case OF_KEY_RIGHT:
emitter.setRate(0);
emitter.setVelocity(ofVec3f(0,0,0));
tf->set(ofVec3f(0,0,0));
tf2->set(ofVec3f(0,0,0));
thrusterSound.stop();
emitter.sys->reset();
break;
default:
break;
}
}
//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y ){
}
//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button) {
/*
ofVec3f mouse(mouseX, mouseY);
ofVec3f rayPoint = cam.screenToWorld(mouse);
ofVec3f rayDir = rayPoint - cam.getPosition();
rayDir.normalize();
Ray ray = Ray(Vector3(rayPoint.x, rayPoint.y, rayPoint.z),
Vector3(rayDir.x, rayDir.y, rayDir.z));
TreeNode temp;
float searchStart = ofGetSystemTimeMicros();
if (tree.intersect(ray, tree.root, temp)) {
float searchEnd = ofGetSystemTimeMicros();
cout << "Search Time in Microseconds: " << searchEnd - searchStart<< endl;
selectedPoint= mars.getMesh(0).getVertex(temp.points[0]);
bPointSelected = true;
}
else
bPointSelected = false;
*/
}
//Return an array of points
//Referenced from Kevin Smith 2018 README file
int ofApp::getMeshPointsInBox(const ofMesh &mesh, const vector<int> &points, Box &box, vector<int> &pointsRtn) {
int count = 0;
for (int i = 0; i < points.size(); i++) {
ofVec3f v = mesh.getVertex(points[i]);
if (box.inside(Vector3(v.x, v.y, v.z))) {
//cout << points[i] << endl;
count++;
pointsRtn.push_back(points[i]);
}
}
return count;
}
//draw a box from a "Box" class
//
void ofApp::drawBox(const Box &box) {
Vector3 min = box.parameters[0];
Vector3 max = box.parameters[1];
Vector3 size = max - min;
Vector3 center = size / 2 + min;
ofVec3f p = ofVec3f(center.x(), center.y(), center.z());
float w = size.x();
float h = size.y();
float d = size.z();
ofDrawBox(p, w, h, d);
}
// Subdivide a Box into eight(8) equal size boxes, return them in boxList;
//
void ofApp::subDivideBox8(const Box &box, vector<Box> & boxList) {
Vector3 min = box.parameters[0];
Vector3 max = box.parameters[1];
Vector3 size = max - min;
Vector3 center = size / 2 + min;
float xdist = (max.x() - min.x()) / 2;
float ydist = (max.y() - min.y()) / 2;
float zdist = (max.z() - min.z()) / 2;
Vector3 h = Vector3(0, ydist, 0);
// generate ground floor
//
Box b[8];
b[0] = Box(min, center);
b[1] = Box(b[0].min() + Vector3(xdist, 0, 0), b[0].max() + Vector3(xdist, 0, 0));
b[2] = Box(b[1].min() + Vector3(0, 0, zdist), b[1].max() + Vector3(0, 0, zdist));
b[3] = Box(b[2].min() + Vector3(-xdist, 0, 0), b[2].max() + Vector3(-xdist, 0, 0));
boxList.clear();
for (int i = 0; i < 4; i++)
boxList.push_back(b[i]);
// generate second story
//
for (int i = 4; i < 8; i++) {
b[i] = Box(b[i - 4].min() + h, b[i - 4].max() + h);
boxList.push_back(b[i]);
}
}
//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button) {
//cout << "X: " << x << " Y: " << y << endl;
}
//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button) {
}
//
// Select Target Point on Terrain by comparing distance of mouse to
// vertice points projected onto screenspace.
// if a point is selected, return true, else return false;
//
bool ofApp::doPointSelection() {
ofMesh mesh = mars.getMesh(0);
int n = mesh.getNumVertices();
float nearestDistance = 0;
int nearestIndex = 0;
bPointSelected = false;
ofVec2f mouse(mouseX, mouseY);
vector<ofVec3f> selection;
// We check through the mesh vertices to see which ones
// are "close" to the mouse point in screen space. If we find
// points that are close, we store them in a vector (dynamic array)
//
for (int i = 0; i < n; i++) {
ofVec3f vert = mesh.getVertex(i);
ofVec3f posScreen = cam.worldToScreen(vert);
float distance = posScreen.distance(mouse);
if (distance < selectionRange) {
selection.push_back(vert);
bPointSelected = true;
}
}
// if we found selected points, we need to determine which
// one is closest to the eye (camera). That one is our selected target.
//
if (bPointSelected) {
float distance = 0;
for (int i = 0; i < selection.size(); i++) {
ofVec3f point = cam.worldToCamera(selection[i]);
// In camera space, the camera is at (0,0,0), so distance from
// the camera is simply the length of the point vector
//
float curDist = point.length();
if (i == 0 || curDist < distance) {
distance = curDist;
selectedPoint = selection[i];
}
}
}
return bPointSelected;
}
// Set the camera to use the selected point as it's new target
//
void ofApp::setCameraTarget() {
}
//--------------------------------------------------------------
void ofApp::mouseEntered(int x, int y){
}
//--------------------------------------------------------------
void ofApp::mouseExited(int x, int y){
}
//--------------------------------------------------------------
void ofApp::windowResized(int w, int h){
}
//--------------------------------------------------------------
void ofApp::gotMessage(ofMessage msg){
}
//--------------------------------------------------------------
// setup basic ambient lighting in GL (for now, enable just 1 light)
//
void ofApp::initLightingAndMaterials() {
static float ambient[] =
{ .5f, .5f, .5, 1.0f };
static float diffuse[] =
{ 1.0f, 1.0f, 1.0f, 1.0f };
static float position[] =
{5.0, 5.0, 5.0, 0.0 };
static float lmodel_ambient[] =
{ 1.0f, 1.0f, 1.0f, 1.0f };
static float lmodel_twoside[] =
{ GL_TRUE };
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT1, GL_POSITION, position);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
// glEnable(GL_LIGHT1);
glShadeModel(GL_SMOOTH);
}
void ofApp::savePicture() {
ofImage picture;
picture.grabScreen(0, 0, ofGetWidth(), ofGetHeight());
picture.save("screenshot.png");
cout << "picture saved" << endl;
}
//--------------------------------------------------------------
//
// support drag-and-drop of model (.obj) file loading. when
// model is dropped in viewport, place origin under cursor
//
void ofApp::dragEvent(ofDragInfo dragInfo) {
ofVec3f point;
mouseIntersectPlane(ofVec3f(0, 0, 0), cam.getZAxis(), point);
if (rover.loadModel(dragInfo.files[0])) {
rover.setScaleNormalization(false);
rover.setScale(.005, .005, .005);
rover.setPosition(point.x, point.y, point.z);
bRoverLoaded = true;
}
else cout << "Error: Can't load model" << dragInfo.files[0] << endl;
}
bool ofApp::mouseIntersectPlane(ofVec3f planePoint, ofVec3f planeNorm, ofVec3f &point) {
ofVec2f mouse(mouseX, mouseY);
ofVec3f rayPoint = cam.screenToWorld(mouse);
ofVec3f rayDir = rayPoint - cam.getPosition();
rayDir.normalize();
return (rayIntersectPlane(rayPoint, rayDir, planePoint, planeNorm, point));
}
// return a Mesh Bounding Box for the entire Mesh
//
Box ofApp::meshBounds(const ofMesh & mesh) {
int n = mesh.getNumVertices();
ofVec3f v = mesh.getVertex(0);
ofVec3f max = v;
ofVec3f min = v;
for (int i = 1; i < n; i++) {
ofVec3f v = mesh.getVertex(i);
if (v.x > max.x) max.x = v.x;
else if (v.x < min.x) min.x = v.x;
if (v.y > max.y) max.y = v.y;
else if (v.y < min.y) min.y = v.y;
if (v.z > max.z) max.z = v.z;
else if (v.z < min.z) min.z = v.z;
}
return Box(Vector3(min.x, min.y, min.z), Vector3(max.x, max.y, max.z));
}
// Yukai Yang
// Taken from Kevin Smith's instructional video
void ofApp:: collisionDetect() {
//cout<< "check"<<endl;
Vector3 c = burgerBBox.center();
contactPt = ofVec3f(c.x(),c.y() - burgerBBox.height()/2, c.z()) + burger.getPosition();
ofVec3f vel = burger.sys.particles[0].velocity;
if(vel.y > 0) return;
TreeNode node;
if(vel == ofVec3f(0,0,0)) return;
if(tree.intersect (contactPt,tree.root,node, 2)) {
bCollision = true;
cout << "collision" <<endl;
// Impulse force
ofVec3f norm = ofVec3f(0,1,0);
ofVec3f f = (restitution + 1.0) * ((-vel.dot(norm))*norm);
//impulseForce->apply(ofGetFrameRate() * -vel);
//tf->set(ofVec3f(0,0,0));
//tf2-> set(ofVec3f(0,0,0));
//gf->set(ofVec3f(0,0,0));
//emitter.setVelocity(ofVec3f(0,10,0));
impulseForce->apply(ofGetFrameRate() * f);
emitter.stop();
}
}
| [
"yukaiyang@sjsu.edu"
] | yukaiyang@sjsu.edu |
684c94307e01a5c4f05fbe227b7f1ad6268e8501 | f840958d7a835cfabdeb5f14500b5aab753a0c1c | /src/audio/buffer/SampleBuffer.hpp | 075589ab713b49502c3a8564a1a655c2ec37a3eb | [] | no_license | Bluemi/audio_analyser | f4134d905919701e2a9134c7d92a3b356a6e70ae | f2613a784af0ea55d78d3e1c9901add7e156ae9a | refs/heads/master | 2021-09-11T19:55:42.253298 | 2018-04-11T19:42:03 | 2018-04-11T19:42:03 | 103,429,513 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,041 | hpp | #ifndef __SAMPLE_BUFFER_CLASS__
#define __SAMPLE_BUFFER_CLASS__
#include <sndfile.h>
#include <vector>
#include <buffer/Buffer.hpp>
#include <audio/channel/ChannelIterator.hpp>
namespace analyser {
class Time;
class PartialTime;
class Sample;
class Channel;
class ChannelBlock;
class SampleBufferIterator;
class SampleBuffer
{
public:
static bool load_from_file(const char* path, SampleBuffer* buffer);
~SampleBuffer();
SampleBuffer();
SampleBuffer clone() const;
void clear();
using Iterator = SampleBufferIterator;
Iterator begin() const;
Iterator end() const;
Iterator get_iterator_at(const PartialTime& time) const;
ChannelIterator begin(unsigned int channel_index) const;
ChannelIterator end(unsigned int channel_index) const;
ChannelIterator get_iterator_at(unsigned int channel_index, const PartialTime& time) const;
// stats
unsigned int get_samplerate() const;
unsigned int get_number_of_channels() const;
bool is_empty() const;
// Time
Time get_duration() const;
Time seconds_to_time(double seconds) const;
Time number_of_samples_to_time(size_t number_of_samples) const;
// Sample
bool get_sample_at(const PartialTime& time, Sample* sample) const;
bool get_sample(const size_t sample_offset, Sample* sample) const;
bool get_subsample_at(const PartialTime& time, unsigned int channel_index, float* subsample) const;
// Channel
bool get_channel(unsigned int channel_index, Channel* channel) const;
// Block
size_t get_block(unsigned int channel_index, const PartialTime& begin_time, const PartialTime& end_time, ChannelBlock* block) const;
private:
static size_t loadSamples(SNDFILE *file, float *samples, const sf_count_t frames);
std::vector<Buffer> channels_;
unsigned int samplerate_;
size_t number_of_samples_;
};
// Iterator Functions
SampleBuffer::Iterator operator+(SampleBuffer::Iterator iterator, int step);
SampleBuffer::Iterator operator-(SampleBuffer::Iterator iterator, int step);
}
#endif
| [
"bruno.schilling@protonmail.ch"
] | bruno.schilling@protonmail.ch |
88bce21d6fb4c5e5f758f6391669a1d8a58a2580 | c3063f0b1d20e49a6796ae2f25d2a7327600804c | /SessionLoggerService.h | 78973409c7b7d7d5f769cc52b2a88aedfdff0abb | [
"MIT"
] | permissive | UiPathJapan/SessionLogger | 557a979d936e7ee7a3241bcab12a786aeeba41f1 | 460f2248b06a06c471283960de6b2b985ed06413 | refs/heads/master | 2020-04-22T04:32:33.441727 | 2019-02-11T12:48:06 | 2019-02-11T12:48:06 | 170,126,466 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,743 | h | /*
Copyright (C) 2018-2019 UiPath, All rights reserved.
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.
*/
#pragma once
#include <Windows.h>
#include "LogFile.h"
namespace UiPathTeam
{
class SessionLoggerService
{
public:
static SessionLoggerService& Instance();
SessionLoggerService();
~SessionLoggerService();
bool Install();
bool Uninstall();
bool Start();
void MainLoop();
bool OnStart();
DWORD OnStop();
DWORD OnPause();
DWORD OnContinue();
DWORD OnInterrogate();
DWORD OnShutdown();
DWORD OnSessionChange(DWORD, DWORD);
DWORD OnUnknownRequest(DWORD);
inline PCWSTR GetServiceName() const;
inline PCWSTR GetDisplayName() const;
inline DWORD GetError() const;
inline PCWSTR GetLogFileName();
inline void SetLogFileName(PCWSTR);
private:
SessionLoggerService(const SessionLoggerService&) {}
void operator =(const SessionLoggerService&) {}
static VOID WINAPI ServiceMain(DWORD dwArgc, PWSTR* pszArgv);
static DWORD WINAPI HandlerEx(DWORD dwControl, DWORD dwEventType, LPVOID lpEventData, LPVOID lpContext);
bool SetStatus(DWORD dwState, DWORD dwPreviousStatus = 0, DWORD dwWaitHint = 0);
class Mutex
{
public:
inline Mutex();
inline ~Mutex();
private:
Mutex(const Mutex&) {}
void operator =(const Mutex&) {}
};
static SessionLoggerService* m_pSingleton;
PWSTR m_pszServiceName;
PWSTR m_pszDisplayName;
DWORD m_dwError;
SERVICE_STATUS_HANDLE m_hServiceStatus;
DWORD m_dwCurrentState;
DWORD m_dwCheckPoint;
LONG m_ExclusiveOperation;
HANDLE m_hEventMain;
LogFile m_LogFile;
};
inline PCWSTR SessionLoggerService::GetServiceName() const
{
return m_pszServiceName;
}
inline PCWSTR SessionLoggerService::GetDisplayName() const
{
return m_pszDisplayName;
}
inline DWORD SessionLoggerService::GetError() const
{
return m_dwError;
}
inline SessionLoggerService::Mutex::Mutex()
{
while (InterlockedCompareExchange(&m_pSingleton->m_ExclusiveOperation, 1L, 0L))
{
Sleep(0);
}
}
inline SessionLoggerService::Mutex::~Mutex()
{
InterlockedExchange(&m_pSingleton->m_ExclusiveOperation, 0);
}
inline PCWSTR SessionLoggerService::GetLogFileName()
{
return m_LogFile.GetFileName();
}
inline void SessionLoggerService::SetLogFileName(PCWSTR pszFileName)
{
m_LogFile.SetFileName(pszFileName);
}
}
| [
"hideaki.narita@uipath.com"
] | hideaki.narita@uipath.com |
41603a6ae516a71dd6860b8204f90568876b6560 | 4a51efb5137a2e7015d8e38bbb147aacf119b200 | /include/Pico80/api/IPicoSettings.h | 5339114476ffce420effb74d78a0de32ac8e5c29 | [] | no_license | Snektron/Pico80 | 20104d4b3455f3ff4918cf0941c47501924fdd67 | 3b3c49c4bcbbf9da502ab878d1168cd73e3aaa7e | refs/heads/master | 2021-01-24T10:06:54.147277 | 2017-02-01T22:41:25 | 2017-02-01T22:41:25 | 69,671,957 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 302 | h | #ifndef IPICOSETTINGS_H
#define IPICOSETTINGS_H
#include <QVariant>
class IPicoSettings
{
public:
virtual QVariant value(QString key, QVariant defaultValue = QVariant()) = 0;
virtual void setValue(QString key, QVariant value) = 0;
virtual ~IPicoSettings() = default;
};
#endif // IPICOSETTINGS_H
| [
"voetterrb1a@gmail.com"
] | voetterrb1a@gmail.com |
f2912824a58f144b99e9b22e64110e3edee3ac83 | 880d41f5d95b0df36bd61ec3e5a02f0461396dac | /Server/IOCP공부/오버랩_다른플레이어/GameServer_Chess.cpp | e82de5e8a325081b2e2a68862340e9837f97918b | [] | no_license | kbs5435586/Graduation | 75eebc35896df6433de8a7cf0e3b99054fc3cc94 | 9b024f5a14a408a81a54ac8c84081bb6ab3f7886 | refs/heads/master | 2023-07-31T16:10:16.773038 | 2021-09-24T21:52:22 | 2021-09-24T21:52:22 | 298,283,260 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,091 | cpp | #include "stdafx.h"
#include "GameServer_Chess.h"
#include "protocol.h"
using namespace std;
#define WM_SOCKET (WM_USER+1)
#define MAX_LOADSTRING 100
// 전역 변수:
HINSTANCE hInst; // 현재 인스턴스입니다.
WCHAR szTitle[MAX_LOADSTRING]; // 제목 표시줄 텍스트입니다.
WCHAR szWindowClass[MAX_LOADSTRING]; // 기본 창 클래스 이름입니다.
ClientInfo player;
unordered_map<int, ClientInfo> npcs;
SOCKET c_socket; // 클라이언트와 연결할 소켓
string client_ip;
int g_myid;
int NPC_ID_START = 10000;
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
void err_quit(const char* msg)
{
LPVOID lpMsgBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, WSAGetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&lpMsgBuf, 0, NULL);
MessageBox(NULL, (LPCTSTR)lpMsgBuf, (LPCWSTR)msg, MB_ICONERROR);
LocalFree(lpMsgBuf);
exit(1);
}
void err_display(const char* msg)
{
LPVOID lpMsgBuf;
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, WSAGetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&lpMsgBuf, 0, NULL);
printf("[%s] %s", msg, (char*)lpMsgBuf);
LocalFree(lpMsgBuf);
}
int APIENTRY wWinMain(_In_ HINSTANCE hInstance, // H는 핸들,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPWSTR lpCmdLine,
_In_ int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// TODO: 여기에 코드를 입력합니다.
WSADATA WSAData;
WSAStartup(MAKEWORD(2, 2), &WSAData);
// 전역 문자열을 초기화합니다.
LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadStringW(hInstance, IDC_GAMESERVERCHESS, szWindowClass, MAX_LOADSTRING); // 창 제목
MyRegisterClass(hInstance);
// 애플리케이션 초기화를 수행합니다:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_GAMESERVERCHESS));
MSG msg;
//WPARAM wParam; 키보드 관련 정보
//LPARAM lParam; 마우스 관련 정보
// 기본 메시지 루프입니다:
while (GetMessage(&msg, nullptr, 0, 0)) // while(1) 과 같은 기능
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEXW wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW; // 가로 세로 변화 감지
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_GAMESERVERCHESS));
wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = NULL; //MAKEINTRESOURCEW(IDC_GAMESERVERCHESS); // 상단 메뉴
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
return RegisterClassExW(&wcex);
}
//
// 함수: InitInstance(HINSTANCE, int)
//
// 용도: 인스턴스 핸들을 저장하고 주 창을 만듭니다.
//
// 주석:
//
// 이 함수를 통해 인스턴스 핸들을 전역 변수에 저장하고
// 주 프로그램 창을 만든 다음 표시합니다.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
hInst = hInstance; // 인스턴스 핸들을 전역 변수에 저장합니다.
HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW, // || 이용하여 사용할거 추가
CW_USEDEFAULT, 0, 950, 839, nullptr, nullptr, hInstance, nullptr); // 실제 윈도우 창 만드는 부분
/*
WS_OVERLAPPEDWINDOW = 윈도우창 각종 설정들
앞 CW_USEDEFAULT, 0 = 윈도우 창 생성위치
뒤 CW_USEDEFAULT, 0 = 윈도우 창 크기
*/
if (!hWnd)
{
return FALSE;
}
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
return TRUE;
}
//
// 함수: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// 용도: 주 창의 메시지를 처리합니다.
//
// WM_COMMAND - 애플리케이션 메뉴를 처리합니다.
// WM_PAINT - 주 창을 그립니다.
// WM_DESTROY - 종료 메시지를 게시하고 반환합니다.
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static int PlayerX = 0, PlayerY = 0;
//static int OtherX = 0, OtherY = 0;
switch (message)
{
case WM_CHAR:
if (wParam == VK_RETURN && !client_ip.empty())
{
InitServer(hWnd);
}
else if (wParam == VK_BACK)
{
if (!client_ip.empty())
client_ip.pop_back();
}
else
{
client_ip.push_back(wParam);
}
break;
case WM_SOCKET:
{
SocketEventMessage(hWnd, lParam);
}
case WM_COMMAND:
{
int wmId = LOWORD(wParam);
// 메뉴 선택을 구문 분석합니다:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
break;
case WM_KEYDOWN:
switch (wParam)
{
case VK_UP:
send_move_packet(D_UP);
break;
case VK_DOWN:
send_move_packet(D_DOWN);
break;
case VK_LEFT:
send_move_packet(D_LEFT);
break;
case VK_RIGHT:
send_move_packet(D_RIGHT);
break;
case VK_ESCAPE:
EndSocketConnect(c_socket);
WSACleanup();
PostQuitMessage(0);
break;
}
InvalidateRect(hWnd, NULL, TRUE);
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
// TODO: 여기에 hdc를 사용하는 그리기 코드를 추가합니다...
wstring input_ip = L"Server IP : ";
wstring inpuy_ip2{ client_ip.begin(),client_ip.end() };
wstring textBox = input_ip + inpuy_ip2;
PlayerX = player.m_x * 100;
PlayerY = player.m_y * 100;
HBRUSH nowBrush;
HBRUSH oldBrush;
nowBrush = (HBRUSH)CreateSolidBrush(RGB(128, 64, 0));
oldBrush = (HBRUSH)SelectObject(hdc, nowBrush);
Rectangle(hdc, 0, 0, 800, 800);
nowBrush = (HBRUSH)CreateSolidBrush(RGB(172, 160, 79));
oldBrush = (HBRUSH)SelectObject(hdc, nowBrush);
for (int i = 0; i < 4; ++i)
{
Rectangle(hdc, 0, i * 200, 100, (i * 200) + 100);
Rectangle(hdc, 200, i * 200, 300, (i * 200) + 100);
Rectangle(hdc, 400, i * 200, 500, (i * 200) + 100);
Rectangle(hdc, 600, i * 200, 700, (i * 200) + 100);
Rectangle(hdc, 100, (i * 200) + 100, 200, (i * 200) + 200);
Rectangle(hdc, 300, (i * 200) + 100, 400, (i * 200) + 200);
Rectangle(hdc, 500, (i * 200) + 100, 600, (i * 200) + 200);
Rectangle(hdc, 700, (i * 200) + 100, 800, (i * 200) + 200);
}
nowBrush = (HBRUSH)CreateSolidBrush(RGB(0, 0, 0));
oldBrush = (HBRUSH)SelectObject(hdc, nowBrush);
Ellipse(hdc, 0 + PlayerX, 0 + PlayerY, 100 + PlayerX, 100 + PlayerY);
RECT rt = { 675,0,875,300 };
DrawText(hdc, textBox.c_str(), -1, &rt, DT_RIGHT | DT_WORDBREAK);
nowBrush = (HBRUSH)CreateSolidBrush(RGB(125, 0, 0));
oldBrush = (HBRUSH)SelectObject(hdc, nowBrush);
for (auto& others : npcs)
{
if (true == others.second.showCharacter)
{
int OtherX = others.second.m_x * 100, OtherY = others.second.m_y * 100;
Ellipse(hdc, 0 + OtherX, 0 + OtherY, 100 + OtherX, 100 + OtherY);
}
}
SelectObject(hdc, oldBrush);
DeleteObject(nowBrush);
EndPaint(hWnd, &ps);
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
// 정보 대화 상자의 메시지 처리기입니다.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
switch (message)
{
case WM_INITDIALOG:
return (INT_PTR)TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
}
break;
}
return (INT_PTR)FALSE;
}
BOOL InitServer(HWND hWnd)
{
c_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
int retval = WSAAsyncSelect(c_socket, hWnd, WM_SOCKET, FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE);
if (retval == SOCKET_ERROR)
{
EndSocketConnect(c_socket);
err_quit("WSAAsyncSelect Error\n");
return FALSE;
}
SOCKADDR_IN server_a;
ZeroMemory(&server_a, sizeof(server_a));
server_a.sin_family = AF_INET;
inet_pton(AF_INET, client_ip.c_str(), &server_a.sin_addr);
server_a.sin_port = htons(SERVER_PORT);
retval = connect(c_socket, (SOCKADDR*)&server_a, sizeof(server_a));
if ((retval == SOCKET_ERROR) && (WSAEWOULDBLOCK != WSAGetLastError())) // 비동기 connect는 바로 리턴되면서 WSAEWOULDBLOCK 에러를 발생시킴
{
EndSocketConnect(c_socket);
err_quit("connect Error\n");
return FALSE;
}
cout << "connect complete!\n";
return TRUE;
}
void ProcessPacket(char* ptr)
{
static bool first_time = true;
switch (ptr[1])
{
case SC_PACKET_LOGIN_OK:
{
sc_packet_login_ok* my_packet = reinterpret_cast<sc_packet_login_ok*>(ptr);
g_myid = my_packet->id;
player.m_x = my_packet->x;
player.m_y = my_packet->y;
player.showCharacter = true;
}
break;
case SC_PACKET_ENTER:
{
sc_packet_enter* my_packet = reinterpret_cast<sc_packet_enter*>(ptr);
int id = my_packet->id;
if (id == g_myid) {
player.m_x = my_packet->x;
player.m_y = my_packet->y;
player.showCharacter = true;
}
else {
//if (id < NPC_ID_START)
// npcs[id] = OBJECT{ *pieces, 64, 0, 64, 64 };
//else
// npcs[id] = OBJECT{ *pieces, 0, 0, 64, 64 };
strcpy_s(npcs[id].m_name, my_packet->name);
npcs[id].m_x = my_packet->x;
npcs[id].m_y = my_packet->y;
npcs[id].showCharacter = true;
}
}
break;
case SC_PACKET_MOVE:
{
sc_packet_move* my_packet = reinterpret_cast<sc_packet_move*>(ptr);
int other_id = my_packet->id;
if (other_id == g_myid) {
player.m_x = my_packet->x;
player.m_y = my_packet->y;
}
else {
if (0 != npcs.count(other_id))
{
npcs[other_id].m_x = my_packet->x;
npcs[other_id].m_y = my_packet->y;
}
}
}
break;
case SC_PACKET_LEAVE:
{
sc_packet_leave* my_packet = reinterpret_cast<sc_packet_leave*>(ptr);
int other_id = my_packet->id;
if (other_id == g_myid) {
player.showCharacter = false;
}
else {
if (0 != npcs.count(other_id))
npcs[other_id].showCharacter = false;
}
}
break;
default:
printf("Unknown PACKET type [%d]\n", ptr[1]);
}
}
void process_data(char* net_buf, size_t io_byte)
{
char* ptr = net_buf;
static size_t in_packet_size = 0;
static size_t saved_packet_size = 0;
static char packet_buffer[MAX_BUF_SIZE];
while (0 != io_byte) {
if (0 == in_packet_size) in_packet_size = ptr[0];
if (io_byte + saved_packet_size >= in_packet_size) {
memcpy(packet_buffer + saved_packet_size, ptr, in_packet_size - saved_packet_size);
ProcessPacket(packet_buffer);
ptr += in_packet_size - saved_packet_size;
io_byte -= in_packet_size - saved_packet_size;
in_packet_size = 0;
saved_packet_size = 0;
}
else {
memcpy(packet_buffer + saved_packet_size, ptr, io_byte);
saved_packet_size += io_byte;
io_byte = 0;
}
}
}
void SocketEventMessage(HWND hWnd, LPARAM lParam)
{
static int count = 0;
char TempLog[256];
switch (WSAGETSELECTEVENT(lParam))
{
case FD_CONNECT:
{
player.m_x = 4;
player.m_y = 4;
player.showCharacter = false;
cs_packet_login l_packet;
l_packet.size = sizeof(l_packet);
l_packet.type = CS_PACKET_LOGIN;
int t_id = GetCurrentProcessId();
sprintf_s(l_packet.name, "P%03d", t_id % 1000);
strcpy(player.m_name, l_packet.name);
//avatar.set_name(l_packet.name);
send_packet(&l_packet);
}
break;
case FD_READ:
{
char net_buf[MAX_BUF_SIZE];
auto recv_result = recv(c_socket, net_buf, MAX_BUF_SIZE, 0);
if (recv_result == SOCKET_ERROR)
{
wcout << L"Recv 에러!";
while (true);
}
else if (recv_result == 0)
break;
if (recv_result > 0)
process_data(net_buf, recv_result);
}
// ProcessPacket(char* ptr);
sprintf(TempLog, "gSock FD_READ");
break;
case FD_WRITE:
sprintf(TempLog, "gSock FD_WRITE");
break;
case FD_CLOSE:
EndSocketConnect(c_socket);
sprintf(TempLog, "gSock FD_CLOSE");
break;
default:
sprintf(TempLog, "gSock Unknown event received: %d", WSAGETSELECTEVENT(lParam));
break;
}
}
void send_packet(void* packet)
{
char* p = reinterpret_cast<char*>(packet);
//size_t sent;
send(c_socket, p, p[0], 0);
//g_socket.send(p, p[0], sent);
}
void send_move_packet(unsigned char dir)
{
cs_packet_move m_packet;
m_packet.type = CS_PACKET_MOVE;
m_packet.size = sizeof(m_packet);
m_packet.direction = dir;
send_packet(&m_packet);
}
void EndSocketConnect(SOCKET& socket)
{
if (socket)
{
shutdown(socket, SD_BOTH);
closesocket(socket);
socket = NULL;
}
}
| [
"jumpok821@gmail.com"
] | jumpok821@gmail.com |
750cf8d76a301cf396fe39ac58fbc19b482961fc | c3203a11c0ab4f9e3a853fcd658166990cf8487b | /URI/Level1/1117/ideone_kBCByk.cpp | a6d84fef7d9174f3618717eadb2b3a7cb5c6f0c7 | [] | no_license | betogaona7/CompetitiveProgramming | 3d37688f028593a2314c676f3e01cc0e5b6d1d8e | 5ac5b7bf13941cc56f28e595eeb33acfa98650b3 | refs/heads/master | 2021-01-12T06:09:24.069374 | 2020-04-23T15:02:16 | 2020-04-23T15:02:16 | 77,318,404 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 284 | cpp | #include <stdio.h>
int main() {
float average = 0, score;
int val = 0;
while(val < 2){
scanf("%f", &score);
if(score >= 0 && score <= 10){
average += score;
val += 1;
}else{
printf("nota invalida\n");
}
}
printf("media = %.2f\n", average/2);
return 0;
} | [
"albertoo_3c@hotmail.com"
] | albertoo_3c@hotmail.com |
7062f11ff99f5fb730ccd987d41d9cca2d9a50b3 | 6ceea1c3bb286144bc0a1b319ee84c7d83dbe930 | /lab52/MyClass.cpp | 67e7566e3da0d10aabb85e9ec898a2a6bad15049 | [] | no_license | cclavin/calebclavin-CSCI20-Fall2017 | 37fbaf439f853ce6cd59ea4c1a6f9b065fe93d74 | 08f26c05e320427ad0f7d526b64118fb29644370 | refs/heads/master | 2021-01-19T18:22:21.969953 | 2017-12-13T01:27:15 | 2017-12-13T01:27:15 | 101,127,926 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 244 | cpp | #include <iostream>
#include "MyClass.h"
MyClass::MyClass() : num_(0) {}
void MyClass::Output() {
cout << "My number is: " << num_ << endl;
}
void MyClass::SetNumber(int num){
num_ = num;
}
int MyClass::GetNumber(){
return num_;
} | [
"cclavin001@student.butte.edu"
] | cclavin001@student.butte.edu |
be4338f5216320aaf9938333a895dab3c4f5234c | 367a266c280e43cb99acdf77f5b3ef3adf61a22c | /Arduino/digital_hourglass/digital_hourglass.ino | c0788df799cc97dcdedd18fc428c34a0a789138d | [] | no_license | Idifixsmurfen/Arduino | b82496f18ebb523be3b182cb12e4ef206d4f4282 | ace8b1421bb16c9ba8b129c7ae3ecb90f53ca892 | refs/heads/master | 2022-10-01T12:54:36.440638 | 2020-06-08T17:25:52 | 2020-06-08T17:25:52 | 270,760,311 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 309 | ino |
digitalWrite(led, HIGH);
led++;
if(led == 7){
}
}
switchState = digitalRead(switchPin);
if(switchState != prevSwitchState){
for(int x = 2;x<8++){
digitalWrite(x, LOW);
}
led = 2;
previousTime = currentTime
}
prevSwitchState = switchState
| [
"noreply@github.com"
] | Idifixsmurfen.noreply@github.com |
c52c82692938e854694f539aa8f9e6aac072e91d | f0473ea5206868bd510f6b7008c788ec50c3feef | /812.cpp | e015a716eb677544baf3a8a629ed16a14ccc8e34 | [] | no_license | gary1346aa/Leetcode-Algo-Training | aff8f1281870e74bb04af25b2c047681c5735a5b | 0d379472326307d959b8bc51e42eee69f3e957e4 | refs/heads/master | 2020-03-10T12:19:15.862443 | 2018-04-13T16:16:06 | 2018-04-13T16:16:06 | 129,375,083 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,044 | cpp | #include <cmath>
class Solution {
public:
double largestTriangleArea(vector<vector<int>>& points) {
double a = 0;
for(int i = 0; i < points.size() - 2; i++){
for (int j = i+1; j < points.size() - 1; j++){
for( int k = j + 1; k < points.size() ; k++){
double
tmp = area(points[i],points[j],points[k]) ;
if (tmp > a)
a = tmp;
}
}
}
return a;
}
double pointDistance(vector<int> p1,vector<int> p2)
{
double distance = 0;
distance = sqrt((p1[1]-p2[1])*(p1[1]-p2[1])+(p1[0]-p2[0])*(p1[0]-p2[0]));
return distance;
}
double area(vector<int> p1,vector<int> p2, vector<int> p3)
{
double area = 0;
double a = 0, b = 0, c = 0, s = 0;
a = pointDistance(p1, p2);
b = pointDistance(p2, p3);
c = pointDistance(p1, p3);
s = 0.5*(a+b+c);
area = sqrt(s*(s-a)*(s-b)*(s-c));
return area;
}
}; | [
"gary1346aa@gmail.com"
] | gary1346aa@gmail.com |
1dde03ccacb4f3d920fadb32d367732a214f59e5 | 2d42a50f7f3b4a864ee19a42ea88a79be4320069 | /source/game/data_domain/humans/femaleclass.h | 8281019351a544cd1538dc1370e61ad3eef80e24 | [] | no_license | Mikalai/punk_project_a | 8a4f55e49e2ad478fdeefa68293012af4b64f5d4 | 8829eb077f84d4fd7b476fd951c93377a3073e48 | refs/heads/master | 2016-09-06T05:58:53.039941 | 2015-01-24T11:56:49 | 2015-01-24T11:56:49 | 14,536,431 | 1 | 0 | null | 2014-06-26T06:40:50 | 2013-11-19T20:03:46 | C | UTF-8 | C++ | false | false | 653 | h | #ifdef USE_HUMANS
#ifndef FEMALECLASS_H
#define FEMALECLASS_H
#include "humanclass.h"
namespace Humans
{
class Female;
class FemaleClass final : public HumanClass
{
public:
FemaleClass(const std::string& name = "FemaleClass") : HumanClass(name) {}
Female* Create(const std::string name, int age);
virtual void Register(Entity *value) override;
virtual void Unregister(Entity *value) override;
virtual void Destroy(Entity* value) override;
static void PrintAll();
static std::vector<Female*>& AllFemales();
private:
static std::vector<Female*> m_all_females;
};
}
#endif // FEMALECLASS_H
#endif // USE_HUMANS
| [
"nickolaib2004@gmail.com"
] | nickolaib2004@gmail.com |
8052b378f9d189bca9891148c460d0e8de6d60ff | 43e96cdc66331aa9e760e641cba2c35b2337e19c | /codechef/COOK73/madhat.cpp | 889f6d03ac6ba109edcbaeb2dbe106edbe89ff32 | [] | no_license | abhishek1995/coding | 017c84c507971fcd8e1867294cf6c4c09e444dda | 226bf12cbeae112a407b1db3e9a10d8bdf70add0 | refs/heads/master | 2020-07-05T10:12:24.585562 | 2016-08-25T16:03:39 | 2016-08-25T16:03:39 | 66,573,227 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,495 | cpp | #include <iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<stack>
#include<assert.h>
#include<utility>
using namespace std;
#define mod 1000000007
#define test int t;scanf("%d", &t);while(t--)
#define pb push_back
#define all(x) x.begin(),x.end()
#define mpr make_pair
#define ll long long int
#define ull unsigned long long int
#define db double
#define vi vector<int>
#define vii vector<pair<int,int> >
#define pii pair<int,int>
#define vl vector<ll>
#define vll vector<pair<ll,ll> >
#define pll pair<ll,ll>
#define ub upper_bound
#define lb lower_bound
#define sc(x) scanf("%d",&x)
#define sc2(x,y) scanf("%d%d",&x,&y)
#define sc3(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define sc4(w,x,y,z) scanf("%d%d%d%d",&w,&x,&y,&z)
#define scll(x) scanf("%lld",&x)
#define scll2(x,y) scanf("%lld%lld",&x,&y)
#define scll3(x,y,z) scanf("%lld%lld%lld",&x,&y,&z)
#define scll4(w,x,y,z) scanf("%lld%lld%lld%lld",&w,&x,&y,&z)
#define scdb(x) scanf("%lf",&x)
#define scdb2(x,y) scanf("%lf%lf",&x,&y)
#define scdb3(x,y,z) scanf("%lf%lf%lf",&x,&y,&z)
#define scdb4(w,x,y,z) scanf("%lf%lf%lf%lf",&w,&x,&y,&z)
#define scs(s) scanf("%s", s)
#define pr(x) printf("%d\n",x)
#define pr2(x,y) printf("%d %d\n",x,y)
#define pr3(x,y,z) printf("%d %d %d\n",x,y,z)
#define pr4(w,x,y,z) printf("%d %d %d %d\n",w,x,y,z)
#define prll(x) printf("%lld\n",x)
#define prll2(x,y) printf("%lld %lld\n",x,y)
#define prll3(x,y,z) printf("%lld %lld %lld\n",x,y,z)
#define prll4(w,x,y,z) printf("%lld %lld %lld %lld\n",w,x,y,z)
#define prdb(x) printf("%lf\n",x)
#define prdb2(x,y) printf("%lf %lf\n",x,y)
#define prdb3(x,y,z) printf("%lf %lf %lf\n",x,y,z)
#define prdb4(w,x,y,z) printf("%lf %lf %lf %lf\n",w,x,y,z)
#define prs(s) printf("%s\n", s)
#define prn() printf("\n")
#define prvec(v) for(int i=0;i<v.size();i++) cout << v[i] << " "
#define prpair(p) cout<<p.first<<" "<<p.second<<endl
#define F first
#define S second
#define maxr 100005
vector<int> a;
int n;
ll ans = 1;
ll fac[maxr];
bool valid()
{
stack<int> s;
s.push(n);
for(int i=0;i<n;i++)
{
//if(s.empty()){s.push(i+a[i]+1);continue;}
int top = s.top();
if(top==i)s.pop();
top = s.top();
if(a[i]+i+1>top)return 0;
if(a[i]+i+1!=top)s.push(a[i]+1+i);
}
return 1;
}
ll power(ll a, ll n)
{
if(n==1)return a;
ll ret = power(a,n/2);
ret = (ret*ret)%mod;
if(n%2==1)ret = (ret*a)%mod;
return ret;
}
ll p[maxr];
ll choose(ll n, ll r)
{
assert(n>=r);
if(r==0 || n==0)return 1;
return (fac[n]*((p[r]*p[n-r])%mod))%mod;
}
stack<pair<int,int> > gst;
void solve()
{
while(!gst.empty())
{
pair<int,int> p = gst.top();
gst.pop();
int st = p.F, end = p.S;
if(st>=end)continue;
int ind = st;
ll left = end-st+1;
stack<ll> s;
while(ind<=end)
{
st = ind;
ind = min(ind+a[ind]+1,end+1);
ll bet = ind-st-1;
s.push(bet);
//ans = (ans*choose(left,bet))%mod;
//left -= bet;
gst.push(mpr(st+1,ind-1));
//solve(st+1,ind-1);
}
while(!s.empty())
{
left--;
ans = (ans*choose(left,s.top()))%mod;
left -= s.top();
s.pop();
}
}
}
int main()
{
fac[0] = 1;
p[0] = 1;
for(int i=1;i<maxr;i++)fac[i] = (fac[i-1]*i)%mod;
for(int i=1;i<maxr;i++)p[i] = power(fac[i],mod-2);
test
{
ans = 1;
cin>>n;
a.resize(n);
for(int i=0;i<n;i++)cin>>a[i];
if(!valid()){cout<<0<<endl;continue;}
gst.push(mpr(0,n-1));
solve();
cout<<ans<<endl;
}
return 0;
}
| [
"abhishek19955192@yahoo.com"
] | abhishek19955192@yahoo.com |
903af069c462f974a9fb05b74c0672bea15aa7fd | 182adfdfa907d3efc0395e293dcdbc46898d88eb | /Temp/il2cppOutput/il2cppOutput/AssemblyU2DCSharpU2Dfirstpass_GP_RTM_RoomStatus2051988161.h | e94a44b7708903d65bf4878ea11bafaaa469afe9 | [] | no_license | Launchable/1.1.3New | d1962418cd7fa184300c62ebfd377630a39bd785 | 625374fae90e8339cec0007d4d7202328bfa03d9 | refs/heads/master | 2021-01-19T07:40:29.930695 | 2017-09-15T17:20:45 | 2017-09-15T17:20:45 | 100,642,705 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 966 | h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include "mscorlib_System_Enum2459695545.h"
#include "AssemblyU2DCSharpU2Dfirstpass_GP_RTM_RoomStatus2051988161.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// GP_RTM_RoomStatus
struct GP_RTM_RoomStatus_t2051988161
{
public:
// System.Int32 GP_RTM_RoomStatus::value__
int32_t ___value___1;
public:
inline static int32_t get_offset_of_value___1() { return static_cast<int32_t>(offsetof(GP_RTM_RoomStatus_t2051988161, ___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
| [
"zk.launchable@gmail.com"
] | zk.launchable@gmail.com |
d6a78820d6eb99b155ccfcec05dcdd3c910b56c2 | 7d10e0770abff10bc48de16d743338cb0c6244a9 | /include/hurricane/base/ByteArray.tcc | a4385c1db3c6db9bf54dabb0d0743e70bac579a6 | [
"Apache-2.0"
] | permissive | JianboTang/hurricane | 6b00adbdd11760d01ba69a5f6777d5c1829424de | 65c62829669efcdd17b4675a15f97ffce0d321a6 | refs/heads/master | 2022-11-12T06:08:27.744478 | 2020-06-21T05:50:15 | 2020-06-21T05:50:15 | 270,178,744 | 0 | 0 | NOASSERTION | 2020-06-07T03:22:52 | 2020-06-07T03:22:51 | null | UTF-8 | C++ | false | false | 1,989 | tcc | /**
* licensed to the apache software foundation (asf) under one
* or more contributor license agreements. see the notice file
* distributed with this work for additional information
* regarding copyright ownership. the asf licenses this file
* to you under the apache license, version 2.0 (the
* "license"); you may not use this file except in compliance
* with the license. you may obtain a copy of the license at
*
* http://www.apache.org/licenses/license-2.0
*
* unless required by applicable law or agreed to in writing, software
* distributed under the license is distributed on an "as is" basis,
* without warranties or conditions of any kind, either express or implied.
* see the license for the specific language governing permissions and
* limitations under the license.
*/
namespace hurricane {
namespace base {
template <class T>
int32_t ByteArrayReader::Read(T* buffer, int32_t count) {
if ( _pos >= static_cast<int32_t>(_buffer.size()) ) {
return 0;
}
size_t sizeToRead = sizeof(T) * count;
if ( _pos + sizeToRead > static_cast<int32_t>(_buffer.size()) ) {
sizeToRead = _buffer.size() - _pos;
}
memcpy(buffer, _pos + _buffer.data(), sizeToRead);
_pos += static_cast<int32_t>(sizeToRead);
return static_cast<int32_t>(sizeToRead);
}
template <class T>
T ByteArrayReader::Read() {
T t;
Read(&t, 1);
return t;
}
int32_t ByteArrayReader::Tell() const {
return _pos;
}
template <class T>
int32_t ByteArrayWriter::Write(const T* buffer, int32_t count) {
int32_t sizeToWrite = sizeof(T) * count;
ByteArray buffer2((const char*)(buffer), sizeToWrite);
_buffer.Concat(buffer2);
return sizeToWrite;
}
template <class T>
int32_t ByteArrayWriter::Write(const T& value) {
return Write(&value, 1);
}
const ByteArray& ByteArrayWriter::ToByteArray() const {
return _buffer;
}
int32_t ByteArrayWriter::Tell() const {
return static_cast<int32_t>(_buffer.size());
}
}
}
| [
"kinuxroot@163.com"
] | kinuxroot@163.com |
bb5d1c1bd6c20acf5778a7a098eddad0a7f66c92 | 9c16d6b984c9a22c219bd2a20a02db21a51ba8d7 | /ios/chrome/browser/web_resource/ios_web_resource_service.h | fda5ec968f4a1bc6ab1a734ab4cf17672a675169 | [
"BSD-3-Clause"
] | permissive | nv-chromium/chromium-crosswalk | fc6cc201cb1d6a23d5f52ffd3a553c39acd59fa7 | b21ec2ffe3a13b6a8283a002079ee63b60e1dbc5 | refs/heads/nv-crosswalk-17 | 2022-08-25T01:23:53.343546 | 2019-01-16T21:35:23 | 2019-01-16T21:35:23 | 63,197,891 | 0 | 0 | NOASSERTION | 2019-01-16T21:38:06 | 2016-07-12T22:58:43 | null | UTF-8 | C++ | false | false | 1,591 | h | // Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef IOS_CHROME_BROWSER_WEB_RESOURCE_IOS_WEB_RESOURCE_SERVICE_H_
#define IOS_CHROME_BROWSER_WEB_RESOURCE_IOS_WEB_RESOURCE_SERVICE_H_
#include <string>
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "components/web_resource/web_resource_service.h"
// iOS implementation of WebResourceService.
// IOSWebResourceService does not parses JSON out of process, because of
// platform limitations.
class IOSWebResourceService : public web_resource::WebResourceService {
public:
IOSWebResourceService(PrefService* prefs,
const GURL& web_resource_server,
bool apply_locale_to_url,
const char* last_update_time_pref_name,
int start_fetch_delay_ms,
int cache_update_delay_ms);
protected:
~IOSWebResourceService() override;
private:
// Parses JSON in a background thread.
static base::Closure ParseJSONOnBackgroundThread(
const std::string& data,
const SuccessCallback& success_callback,
const ErrorCallback& error_callback);
// WebResourceService implementation:
void ParseJSON(const std::string& data,
const SuccessCallback& success_callback,
const ErrorCallback& error_callback) override;
DISALLOW_COPY_AND_ASSIGN(IOSWebResourceService);
};
#endif // IOS_CHROME_BROWSER_WEB_RESOURCE_IOS_WEB_RESOURCE_SERVICE_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
c9a5068270ef6c494ba96d9e22947574c22a7ef8 | 52ada127e8ac22173754b1d22db1b805091e7118 | /test/config.t.cpp | 1863c88df408997822b67475bdc699f0abf1627c | [
"MIT"
] | permissive | dgengtek/taskd | a60ed234fff5068df796b4a6fcbe219325007996 | 2f40c1babd7cc8ffdf483da87fd703045d402e87 | refs/heads/master | 2020-03-28T22:03:59.297548 | 2014-01-16T00:23:15 | 2014-01-16T00:23:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,336 | cpp | ////////////////////////////////////////////////////////////////////////////////
// taskd - Taskserver
//
// Copyright 2010 - 2014, Göteborg Bit Factory.
//
// 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.
//
// http://www.opensource.org/licenses/mit-license.php
//
////////////////////////////////////////////////////////////////////////////////
#include <cmake.h>
#include <iostream>
#include <ConfigFile.h>
#include <test.h>
////////////////////////////////////////////////////////////////////////////////
int main (int argc, char** argv)
{
UnitTest t (11);
Config c;
// void set (const std::string&, const std::string&);
// const std::string get (const std::string&);
c.set ("str1", "one");
t.is (c.get ("str1"), "one", "Config::set/get std::string");
c.set ("str1", "");
t.is (c.get ("str1"), "", "Config::set/get std::string");
// void set (const std::string&, const int);
// const int getInteger (const std::string&);
c.set ("int1", 1);
t.is (c.getInteger ("int1"), 1, "Config::set/get int");
c.set ("int2", 3);
t.is (c.getInteger ("int2"), 3, "Config::set/get int");
c.set ("int3", -9);
t.is (c.getInteger ("int3"), -9, "Config::set/get int");
// void set (const std::string&, const double);
// const double getReal (const std::string&);
c.set ("double1", 1.0);
t.is (c.getReal ("double1"), 1.0, "Config::set/get double");
c.set ("double2", 3.0);
t.is (c.getReal ("double2"), 3.0, "Config::set/get double");
c.set ("double3", -9.0);
t.is (c.getReal ("double3"), -9.0, "Config::set/get double");
// void set (const std::string&, const bool);
// const bool getBoolean (const std::string&);
c.set ("bool1", false);
t.is (c.getBoolean ("bool1"), false, "Config::set/get bool");
c.set ("bool1", true);
t.is (c.getBoolean ("bool1"), true, "Config::set/get bool");
// void all (std::vector <std::string>&);
std::vector <std::string> all;
c.all (all);
// 8 created in this test program.
// 22 default report setting created in Config::Config.
t.ok (all.size () >= 8, "Config::all");
// TODO Test includes
// TODO Test included nesting limit
// TODO Test included absolute vs relative
// TODO Test included missing file
return 0;
}
////////////////////////////////////////////////////////////////////////////////
| [
"paul@beckingham.net"
] | paul@beckingham.net |
b77df1416dfb1b980b7a0e57ff8b9d96e2166b09 | 93c961a07769e026f0875428c2232af5cdad5f4b | /stl_src_analysis_06/y_set_algo.h | 29102a6ac0701a727ac33e2ebb2c86bbd8c623a7 | [] | no_license | Yyyyshen/stl_notes | 4a14cb9dac3da1c0584bc59a6169df11d9ef6105 | 0e47735874b62e223ca7dc8602292b8605acfc56 | refs/heads/master | 2023-04-14T06:08:10.237418 | 2021-04-08T08:56:28 | 2021-04-08T08:56:28 | 348,639,203 | 2 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,168 | h | #pragma once
/**
* set相关算法
*/
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator y_set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result) {
//并集
while (first1 != last1 && first2 != last2) {
if (*first1 < *first2)
{
*result = *first1;
++first1;
}
else if (*first2 < *first1)
{
*result = *first2;
++first2;
}
else
{
result = *first1;
++first1;
++first2;
}
}
//序列其一达到尾端，结束循环，将剩余元素拷贝到目的端
return copy(first2, last2, copy(first1, last1, result));
}
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator y_set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result) {
//交集
while (first1 != last1 && first2 != last2) {
if (*first1 < *first2)
++first1;
else if (*first2 < *first1)
++first2;
else {
*result = *first1;
++first1;
++first2;
++result;
}
}
return result;
}
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator y_set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result) {
//差集
while (first1 != last1 && first2 != last2) {
if (*first1 < *first2)
{
*result = *first1;
++first1;
++result;
}
else if (*first2 < *first1)
++first2;
else
{
++first1;
++first2;
}
}
return copy(first1, last1, result);
}
template<class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator y_set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result) {
//对称差集
while (first1 != last1 && first2 != last2) {
if (*first1 < *first2)
{
*result = *first1;
++first1;
++result;
}
else if (*first2 < *first1)
{
*result = *first2;
++first2;
++result;
}
else
{
++first1;
++first2;
}
}
return copy(first2, last2, copy(first1, last1, result));
} | [
"Yyyyshen@gmail.com"
] | Yyyyshen@gmail.com |
463174a265617ce059e4d5e95ad74f57be5a68c1 | f1bd6da6bfc2cb5172cae3057758afd69ed27453 | /ID Mgmt/mgmt_id.cpp | c600fd9ab0fb46a733c07ae796fedaa69307fed6 | [] | no_license | kdas6141/CPP | a4ca0e201bab9ba31d8d107b50259677cf151280 | df961ba3ae7f04b555ab9e2e61623f92880cfb1c | refs/heads/master | 2022-11-18T05:05:06.774118 | 2020-07-26T17:28:44 | 2020-07-26T17:28:44 | 268,903,613 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,088 | cpp | /**
* This file will contain the class implemenation to get and
* return an unique id
*/
#include "mgmt_id.hpp"
#include <iostream>
using namespace std;
/**
* Constructor will intilaze id to 1
*/
mgmt_id::mgmt_id () {
id = 1;
}
/**
* Destructor place holder
*/
mgmt_id::~mgmt_id () {
}
/**
* return the id after deletion of the entry
* in succes return 0 otherwise return -1
*/
int32_t mgmt_id::return_id(uint32_t &id) {
struct ret_id_info rinfo = {id, std::chrono::system_clock::now()};
ret_id.push(rinfo);
return 0;
}
/**
* get id from the pool if sucess return 0
* otherwise return -1
*/
int32_t mgmt_id::get_id(uint32_t &new_id) {
/* check if there is alreay returned id avilable to reuse*/
if (!ret_id.empty()) {
auto cur = std::chrono::system_clock::now();
std::chrono::duration<double> diff = cur - ret_id.front().cur_time;
if (diff.count() >= MGMT_ID_MIN_FREEZE_TIME) {
new_id = ret_id.front().id;
ret_id.pop();
return 0;
}
}
if (id < 0xFFFFFFFF) {
new_id = id++;
return 0;
} else
new_id = 0;
return -1;
}
| [
"noreply@github.com"
] | kdas6141.noreply@github.com |
f6f0a8865db4eac928be02bdcaa4f44709aa812d | 5b87d8332ef549cbba444ad96f72c58e4a621778 | /src/graphics.cpp | f7c71d13f120a48e1a4ef473787d33f525109696 | [] | no_license | staruwos/Rojo | 5291187e7559ff9093fdd7fc57688e140bc4f313 | fdb613f289e7186320ad989809fb417e1ce900f6 | refs/heads/master | 2020-04-18T04:26:52.501116 | 2016-09-01T12:55:17 | 2016-09-01T12:55:17 | 67,131,035 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 801 | cpp | #include "graphics.h"
SDL_Texture* loadTexture( SDL_Renderer* Renderer, std::string path )
{
//The final texture
SDL_Texture* newTexture = NULL;
//Load image at specified path
SDL_Surface* loadedSurface = IMG_Load( path.c_str() );
if( loadedSurface == NULL )
{
printf( "Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() );
}
else
{
//Create texture from surface pixels
newTexture = SDL_CreateTextureFromSurface( Renderer, loadedSurface );
if( newTexture == NULL )
{
printf( "Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError() );
}
//Get rid of old loaded surface
SDL_FreeSurface( loadedSurface );
}
return newTexture;
} | [
"noreply@github.com"
] | staruwos.noreply@github.com |
931d219785a92a078b3616cf625f958646532579 | 5b12760333f6ce9f2c818c9406a788bbdde83cb3 | /dbvisit/Datahelp.cpp | ce31019bb2e0f26e52f2ac3f400306a2eb122d24 | [] | no_license | JoyZou/gameframe | a9476948b86b34d4bb5e8eae47552023c07d7566 | a5db12da016b65033cc088ba3c2a464936b2b942 | refs/heads/master | 2023-08-28T22:18:56.117350 | 2021-11-10T09:04:30 | 2021-11-10T09:04:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,226 | cpp | #include "dbvisit/datahelp.h"
#include "dbvisit/datatimer.h"
#include "dbvisit/datatimermgr.h"
#include "shynet/net/timerreactormgr.h"
#include "shynet/pool/mysqlpool.h"
#include "shynet/utils/stringop.h"
#include <sw/redis++/redis++.h>
namespace redis = sw::redis;
#include <rapidjson/document.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/writer.h>
#include <unordered_set>
namespace dbvisit {
Datahelp::Datahelp()
{
}
Datahelp::ErrorCode Datahelp::getdata_from_db(const std::string& tablename,
const std::string& key, std::unordered_map<std::string, std::string>& out,
const std::string& where)
{
pool::MysqlPool& mysql = shynet::utils::Singleton<pool::MysqlPool>::get_instance();
std::string sql = shynet::utils::StringOp::str_format("_id='%s'", key.c_str());
std::string condition = sql;
if (key.empty()) {
condition = where;
}
mysqlx::DocResult docs = mysql.fetch()->getDefaultSchema().createCollection(tablename, true).find(condition).execute();
if (docs.count() == 1) {
mysqlx::DbDoc doc = docs.fetchOne();
//填充数据
for (auto&& [key, value] : out) {
if (doc.hasField(key)) {
value = doc[key].operator std::string();
}
}
} else if (docs.count() > 1) {
LOG_WARN << "db数据不唯一 tablename:" << tablename << " key:" << key << " where:" + where;
} else {
return ErrorCode::NOT_DATA;
}
return ErrorCode::OK;
}
Datahelp::ErrorCode Datahelp::getdata_from_cache(const std::string& cachekey,
std::unordered_map<std::string, std::string>& out,
std::chrono::seconds seconds)
{
redis::Redis& redis = shynet::utils::Singleton<redis::Redis>::instance(std::string());
if (redis.exists(cachekey) == 1) {
std::vector<std::string> out_key;
for (auto&& [key, value] : out) {
out_key.push_back(key);
}
std::vector<redis::OptionalString> out_value;
redis.hmget(cachekey, out_key.begin(), out_key.end(), std::back_inserter(out_value));
for (size_t i = 0; i < out_key.size(); ++i) {
const redis::OptionalString& value = out_value[i];
if (value) {
out[out_key[i]] = *value;
}
}
if (seconds.count() != 0) {
redis.expire(cachekey, seconds);
}
} else {
return ErrorCode::NOT_DATA;
}
return ErrorCode::OK;
}
Datahelp::ErrorCode Datahelp::getdata(const std::string& cachekey,
std::unordered_map<std::string, std::string>& out,
OperType opertype,
bool updatacache,
std::chrono::seconds seconds)
{
ErrorCode error = ErrorCode::OK;
if (opertype == OperType::ALL) {
error = getdata_from_cache(cachekey, out);
if (error == ErrorCode::NOT_DATA) {
db_label:
const auto temp = shynet::utils::StringOp::split(cachekey, "_");
if (temp.size() < 2) {
THROW_EXCEPTION("解析错误 cachekey:" + cachekey);
}
error = getdata_from_db(temp[0], temp[1], out);
if (error == ErrorCode::OK) {
if (updatacache) {
redis::Redis& redis = shynet::utils::Singleton<redis::Redis>::instance(std::string());
redis.hset(cachekey, out.begin(), out.end());
if (seconds.count() != 0) {
redis.expire(cachekey, seconds);
}
}
}
}
return error;
} else if (opertype == OperType::CACHE) {
return getdata_from_cache(cachekey, out);
} else if (opertype == OperType::DB) {
goto db_label;
}
return ErrorCode::NOT_DATA;
}
moredataptr Datahelp::getdata_more_db(const std::string& tablename,
const std::string& condition,
std::unordered_map<std::string, std::string>& out,
std::string sort,
int32_t limit)
{
moredataptr datalist = std::make_shared<moredata>();
pool::MysqlPool& mysql = shynet::utils::Singleton<pool::MysqlPool>::get_instance();
auto tt = mysql.fetch()->getDefaultSchema().createCollection(tablename, true).find(condition);
if (sort.empty() == false) {
tt = tt.sort(sort);
}
mysqlx::DocResult docs;
if (limit == 0) {
docs = tt.execute();
} else {
docs = tt.limit(limit).execute();
}
for (mysqlx::DbDoc doc : docs.fetchAll()) {
//填充数据
for (auto&& [key, value] : out) {
if (doc.hasField(key)) {
value = doc[key].operator std::string();
}
}
datalist->push_back(out);
}
return datalist;
}
moredataptr Datahelp::getdata_more_cache(const std::string& condition,
std::unordered_map<std::string, std::string>& out,
std::string sort,
int32_t limit)
{
moredataptr datalist = std::make_shared<moredata>();
redis::Redis& redis = shynet::utils::Singleton<redis::Redis>::instance(std::string());
auto cursor = 0LL;
std::unordered_set<std::string> keys;
while (true) {
cursor = redis.scan(cursor, condition, 50, std::inserter(keys, keys.begin()));
if (cursor == 0) {
break;
}
}
for (auto& key : keys) {
ErrorCode err = getdata_from_cache(key, out);
if (err == ErrorCode::OK) {
datalist->push_back(out);
}
}
if (sort.empty() == false) {
const auto temp = shynet::utils::StringOp::split(sort, " ");
if (temp.size() < 2) {
THROW_EXCEPTION("解析错误 sort:" + sort);
}
datalist->sort([&temp, &sort](const std::unordered_map<std::string, std::string>& t1, std::unordered_map<std::string, std::string>& t2) {
auto it1 = t1.find(temp[0]);
auto it2 = t2.find(temp[0]);
if (it1 == t1.end() || it2 == t2.end()) {
THROW_EXCEPTION("解析错误 sort key:" + sort);
}
if (temp[1] == "asc") {
return it1->second < it2->second;
} else {
return it1->second > it2->second;
}
});
}
if (limit != 0) {
while (datalist->size() > size_t(limit)) {
datalist->erase(--datalist->end());
}
}
return datalist;
}
moredataptr Datahelp::getdata_more(const std::string& condition,
std::unordered_map<std::string, std::string>& out,
std::string sort,
int32_t limit,
OperType opertype,
bool updatacache,
std::chrono::seconds seconds)
{
moredataptr datalist;
if (opertype == OperType::ALL) {
datalist = getdata_more_cache(condition, out, sort, limit);
if (datalist->empty()) {
db_label:
auto vect = shynet::utils::StringOp::split(condition, "_");
if (vect.size() < 3) {
THROW_EXCEPTION("解析错误 condition:" + condition);
}
auto where = shynet::utils::StringOp::str_format("roleid='%s'", vect[2].c_str());
datalist = getdata_more_db(vect[0], where, out, sort, limit);
if (updatacache) {
for (auto& it : *datalist) {
std::string cache_key = condition;
auto pos = cache_key.find("*");
if (pos == std::string::npos)
THROW_EXCEPTION("找不到* condition:" + condition);
cache_key.replace(pos, 1, it["_id"]);
redis::Redis& redis = shynet::utils::Singleton<redis::Redis>::instance(std::string());
redis.hmset(cache_key, it.begin(), it.end());
if (seconds.count() != 0) {
redis.expire(cache_key, seconds);
}
}
}
}
} else if (opertype == OperType::CACHE) {
datalist = getdata_more_cache(condition, out, sort, limit);
} else if (opertype == OperType::DB) {
goto db_label;
}
return datalist;
}
void Datahelp::insert_db(const std::string& tablename, const std::string& key,
const std::unordered_map<std::string, std::string>& fields)
{
pool::MysqlPool& mysql = shynet::utils::Singleton<pool::MysqlPool>::get_instance();
mysqlx::Schema sch = mysql.fetch()->getDefaultSchema();
rapidjson::Document doc;
rapidjson::Value& data = doc.SetObject();
for (auto&& [key, value] : fields) {
data.AddMember(rapidjson::StringRef(key.c_str()),
rapidjson::StringRef(value.c_str()),
doc.GetAllocator());
}
rapidjson::StringBuffer buffer;
rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
data.Accept(writer);
if (sch.createCollection(tablename, true).add(buffer.GetString()).execute().getAffectedItemsCount() == 0) {
LOG_WARN << "数据插入失败 tablename:" << tablename << " key:" << key;
}
}
void Datahelp::insert_cache(const std::string& cachekey, const std::unordered_map<std::string, std::string>& fields, std::chrono::seconds seconds)
{
redis::Redis& redis = shynet::utils::Singleton<redis::Redis>::instance(std::string());
redis.hmset(cachekey, fields.begin(), fields.end());
if (seconds.count() != 0) {
redis.expire(cachekey, seconds);
}
}
void Datahelp::insertdata(const std::string& cachekey,
const std::unordered_map<std::string, std::string>& fields,
OperType opertype,
std::chrono::seconds seconds)
{
if (opertype == OperType::ALL) {
insert_cache(cachekey, fields, seconds);
db_label:
std::vector<std::string> temp = shynet::utils::StringOp::split(cachekey, "_");
if (temp.size() < 2) {
THROW_EXCEPTION("解析错误 cachekey:" + cachekey);
return;
}
return insert_db(temp[0], temp[1], fields);
} else if (opertype == OperType::CACHE) {
insert_cache(cachekey, fields, seconds);
} else if (opertype == OperType::DB) {
goto db_label;
}
}
void Datahelp::delete_db(const std::string& tablename, const std::string& key)
{
pool::MysqlPool& mysql = shynet::utils::Singleton<pool::MysqlPool>::get_instance();
mysqlx::Schema sch = mysql.fetch()->getDefaultSchema();
std::string sql = shynet::utils::StringOp::str_format("_id='%s'", key.c_str());
if (sch.createCollection(tablename, true).remove(sql).execute().getAffectedItemsCount() == 0) {
LOG_WARN << "数据删除失败 tablename:" << tablename << " key:" << key;
}
}
void Datahelp::delete_cache(const std::string& cachekey)
{
redis::Redis& redis = shynet::utils::Singleton<redis::Redis>::instance(std::string());
long long ret = redis.del(cachekey);
if (ret == 0) {
LOG_WARN << "cachekey数据删除失败 cachekey:" << cachekey;
}
}
void Datahelp::deletedata(const std::string& cachekey, OperType opertype)
{
if (opertype == OperType::ALL) {
delete_cache(cachekey);
db_label:
std::vector<std::string> temp = shynet::utils::StringOp::split(cachekey, "_");
if (temp.size() < 2) {
THROW_EXCEPTION("解析错误 cachekey:" + cachekey);
return;
}
delete_db(temp[0], temp[1]);
} else if (opertype == OperType::CACHE) {
delete_cache(cachekey);
} else if (opertype == OperType::DB) {
goto db_label;
}
}
void Datahelp::updata_db(const std::string& tablename, const std::string& key, const std::unordered_map<std::string, std::string>& fields)
{
pool::MysqlPool& mysql = shynet::utils::Singleton<pool::MysqlPool>::get_instance();
mysqlx::Schema sch = mysql.fetch()->getDefaultSchema();
std::string where = shynet::utils::StringOp::str_format("_id='%s'", key.c_str());
mysqlx::CollectionModify md = sch.createCollection(tablename, true).modify(where);
for (auto&& [key, value] : fields) {
if (key != "_id") {
md.set(key, value);
}
}
if (md.execute().getAffectedItemsCount() == 0) {
LOG_WARN << "数据更新失败 tablename:" << tablename << " key:" << key;
}
}
void Datahelp::updata_cache(const std::string& cachekey,
const std::unordered_map<std::string, std::string>& fields,
std::chrono::seconds seconds)
{
redis::Redis& redis = shynet::utils::Singleton<redis::Redis>::instance(std::string());
redis.hmset(cachekey, fields.begin(), fields.end());
if (seconds.count() != 0) {
redis.expire(cachekey, seconds);
}
}
void Datahelp::updata(const std::string& cachekey,
const std::unordered_map<std::string, std::string>& fields,
OperType opertype,
bool immediately,
const timeval val,
std::chrono::seconds seconds)
{
if (opertype == OperType::ALL) {
updata_cache(cachekey, fields, seconds);
db_label:
std::vector<std::string> temp = shynet::utils::StringOp::split(cachekey, "_");
if (temp.size() < 2) {
THROW_EXCEPTION("解析错误 cachekey:" + cachekey);
return;
}
if (immediately) {
//立即写库
return updata_db(temp[0], temp[1], fields);
} else {
//延时排队写库
auto timerid = shynet::utils::Singleton<DataTimerMgr>::instance().find(cachekey);
if (timerid == 0) {
//创建写库计时器
std::shared_ptr<DataTimer> dt = std::make_shared<DataTimer>(cachekey, val);
dt->modify_cache_fields(fields);
shynet::utils::Singleton<DataTimerMgr>::instance().add(cachekey,
shynet::utils::Singleton<shynet::net::TimerReactorMgr>::instance().add(dt));
} else {
//延迟写库计时器执行时间
std::shared_ptr<DataTimer> dt = std::dynamic_pointer_cast<DataTimer>(
shynet::utils::Singleton<shynet::net::TimerReactorMgr>::instance().find(timerid));
if (dt) {
dt->set_val(val);
dt->modify_cache_fields(fields);
}
}
}
} else if (opertype == OperType::CACHE) {
updata_cache(cachekey, fields, seconds);
} else {
goto db_label;
}
}
}
| [
"54823051@qq.com"
] | 54823051@qq.com |
cb31d49a3ff3f45fa08b7c2a96728fa4d8bd7761 | b319a671ff5804b5f3f61b427bb5c0ce3063e9f3 | /build/modules/features2d/sift.simd_declarations.hpp | 2cf212efc5ab52d4c36384925c5e3ea32230d343 | [
"MIT"
] | permissive | kanishksh4rma/Self-Driving-Car | 3daafbb2484ddfe8430b76d55cc9d4ab986fd82c | 919c88171716a9faf9fd7214b2afc3308ca6a489 | refs/heads/main | 2023-02-17T07:24:50.124403 | 2021-01-15T20:58:17 | 2021-01-15T20:58:17 | 330,017,258 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 525 | hpp | #define CV_CPU_SIMD_FILENAME "/home/kanishk/Desktop/Autopilot/opencv/modules/features2d/src/sift.simd.hpp"
#define CV_CPU_DISPATCH_MODE SSE4_1
#include "opencv2/core/private/cv_cpu_include_simd_declarations.hpp"
#define CV_CPU_DISPATCH_MODE AVX2
#include "opencv2/core/private/cv_cpu_include_simd_declarations.hpp"
#define CV_CPU_DISPATCH_MODE AVX512_SKX
#include "opencv2/core/private/cv_cpu_include_simd_declarations.hpp"
#define CV_CPU_DISPATCH_MODES_ALL AVX512_SKX, AVX2, SSE4_1, BASELINE
#undef CV_CPU_SIMD_FILENAME
| [
"ancientvedicverse@gmail.com"
] | ancientvedicverse@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.