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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
35a413e62a8ef0a31ff5f88d8d59586f8547b3a0
|
330aa8230d648b8c9f6f6ec6e73b99236c2e17ba
|
/main.cpp
|
c5a1ea86689314dff1aa2b5aed1e61501f6763ff
|
[] |
no_license
|
khloud19/BankingSystem
|
b6264f56c4c5995b05f0d308ff26cbbce8d8dac1
|
64a55d81096d628f4e1c66fc40a00a6cc2798b75
|
refs/heads/master
| 2020-04-07T03:35:08.114512
| 2018-11-17T20:21:38
| 2018-11-17T20:21:38
| 158,021,515
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,620
|
cpp
|
#include<iostream>
#include<fstream>
#include<cctype>
#include<iomanip>
using namespace std;
class acc
{
int ano;
char name[100];
int dep;
char type;
char address[100];
int phone;
public:
void create_acc(); //function to create a new account
void show_acc() const; //function to show account details
void adep(int); //function to accept deposit amount
void draw(int); //function to subtract withdrawal amount
void report() const; //function to show data in tabular format
int retano() const; //For returning account number
int retbal() const; //For returning balance amount
char qtype() const; //For returning type of account
int retph() const;
};
void acc::create_acc()
{
cout<<"\nEnter The Account Number :";
cin>>ano;
cout<<"\n\nEnter client name : ";
cin.ignore();
cin.getline(name,100);
cout<<"\nEnter client address: ";
cin.ignore();
cin.getline(address,100);
cout<<"\nEnter your phone number: ";
cin>>phone;
cout<<"\nEnter Type of Account(Current/Savings) : ";
cin>>type;
cout<<"\nEnter The Initial amount(>=500 for Saving and >=1000 for current ) : ";
cin>>dep; //We have set the minimum initial amount for savings be 500 & for current be 1000
cout<<"\n\nYour account has been created..";
}
void acc::show_acc() const
{
cout<<"\nAccount Number : "<<ano;
cout<<"\nAccount Holder Name : ";
cout<<name;
cout<<"\nType of Account : "<<type;
cout<<"\nBalance amount : "<<dep;
}
void acc::adep(int x)
{
dep+=x;
}
void acc::draw(int x)
{
dep-=x;
}
void acc::report() const
{
cout<<ano<<setw(10)<<" "<<name<<setw(10)<<" "<<type<<setw(6)<<dep<<endl;
}
int acc::retph()const //to return phone number
{
return phone;
}
int acc::retano() const
{
return ano;
}
int acc::retbal() const
{
return dep;
}
char acc::qtype() const
{
return type;
}
void write_acc(); //function to write record in binary file
void display_all(); //function to display all account details
void dep_withdraw(int, int); // function to desposit/withdraw amount for given account
int main()
{
char ch;
int num;
do
{
cout<<"\nWelcom to FCI Banking System";
cout<<"\n1.Create a New Account";
cout<<"\n2.Deposit";
cout<<"\n3.Withdraw";
cout<<"\n4.List Clients and Accounts";
cout<<"\n5.EXIT";
cout<<"\n\nPlease enter Choice: ";
cin>>ch;
switch(ch)
{
case '1':
write_acc();
break;
case '2':
cout<<"\n\n\tEnter The Account Number : "; cin>>num;
dep_withdraw(num, 1);
break;
case '3':
cout<<"\n\n\tEnter The Account Number : "; cin>>num;
dep_withdraw(num, 2);
break;
case '4':
display_all();
break;
case '5':
cout<<"\n\nThanks For Your Visiting!";
break;
}
cin.ignore();
cin.get();
}while(ch!='5');
return 0;
}// Function To write the account data to .dat file
void write_acc()
{
acc ac;
ofstream x;
x.open("info.dat",ios::binary|ios::app);
ac.create_acc();
x.write(reinterpret_cast<char *> (&ac), sizeof(acc));
x.close();
}
// function to display account details from the stored file*/
void display_all()
{
acc ac;
ifstream x;
x.open("info.dat",ios::binary);
if(!x)
{
cout<<"File could not be open !! Press any Key...";
return;
}
cout<<"\n\n\t\tACCOUNT HOLDER LIST\n\n";
cout<<"====================================================\n";
cout<<"A/c no. NAME Type Balance\n";
cout<<"====================================================\n";
while(x.read(reinterpret_cast<char *> (&ac), sizeof(acc)))
{
ac.report();
}
x.close();
}// function to withdraw amout from the account
void dep_withdraw(int n, int option)
{
int amt;
bool found=false;
acc ac;
fstream x;
x.open("info.dat", ios::binary|ios::in|ios::out);
if(!x)
{
cout<<"File could not be open !! Press any Key...";
return;
}
while(!x.eof() && found==false)
{
x.read(reinterpret_cast<char *> (&ac), sizeof(acc));
if(ac.retano()==n)
{
ac.show_acc();
if(option==1)
{
cout<<"\n\n\tTO DEPOSITE AMOUNT ";
cout<<"\n\nEnter The amount to be deposited: ";
cin>>amt;
ac.adep(amt);
}
if(option==2)
{
cout<<"\n\n\tTO WITHDRAW AMOUNT ";
cout<<"\n\nEnter The amount to be withdraw: ";
cin>>amt;
int bal=ac.retbal()-amt;
if((bal<500 && ac.qtype()=='S') || (bal<1000 && ac.qtype()=='C'))
cout<<"Insufficience balance";
else
ac.draw(amt);
}
/* int pos=(-1)*static_cast<int>(sizeof(ac));
x.seekp(pos,ios::cur);*/
x.write(reinterpret_cast<char *> (&ac), sizeof(acc));
cout<<"\n\n\t Record Updated";
found=true;
}
}
x.close();
if(found==false)
cout<<"\n\n Record Not Found ";
}
|
[
"noreply@github.com"
] |
khloud19.noreply@github.com
|
d4414eb6491194d84a6d9763e494a76d36a91bd9
|
fe92a722db8bdba378cc8747895f99bd2c209634
|
/NOPAT-26.cpp
|
0fd86695410562cc227c45ffce87ab696509c060
|
[] |
no_license
|
bnblzq/algo-practice
|
00292fd79c4c56edda01c5c4b2922cc00cbd1d57
|
8b9126ecabf61b1d1fdd86207798fd5bdf05c5b4
|
refs/heads/master
| 2020-04-14T05:05:03.724096
| 2019-03-22T08:29:11
| 2019-03-22T08:29:11
| 163,652,209
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,240
|
cpp
|
/*
* ๆไธ็พคไบบ๏ผๆไนไน็ๆฏ่ต๏ผไธคไธคๆๅฏนๆๆ๏ผๆฏไธคไธชไบบไน้ดๆๅคๆไธๅบๆฏ่ตใ
็่ต็่งๅๅฆไธ๏ผๅฆๆ A ๆ่ดฅไบ B๏ผB ๅๆ่ดฅไบ C๏ผ่ A ไธ C ไน้ดๆฒกๆ่ฟ
่ก่ฟๆฏ่ต๏ผ้ฃไนๅฐฑ่ฎคๅฎ๏ผA ไธๅฎ่ฝๆ่ดฅ Cใ
ๅฆๆ A ๆ่ดฅไบ B๏ผB ๅๆ่ดฅไบ C๏ผ่ไธ๏ผC ๅๆ่ดฅไบ A๏ผ้ฃไน AใBใC ไธ
่
้ฝไธๅฏ่ฝๆไธบๅ ๅใ
ๆ นๆฎ่ฟไธช่งๅ๏ผๆ ้ๅพช็ฏ่พ้๏ผๆ่ฎธๅฐฑ่ฝ็กฎๅฎๅ ๅใไฝ ็ไปปๅกๅฐฑๆฏ้ขๅฏนไธ็พค
ๆฏ่ต้ๆ๏ผๅจ็ป่ฟไบ่ฅๅนฒๅบๆๆไนๅ๏ผ็กฎๅฎๆฏๅฆๅทฒ็ปๅฎ้
ไธไบง็ไบๅ ๅใ
่พๅ
ฅๅซๆไธไบ้ๆ็พค๏ผๆฏ็พค้ๆ้ฝไปฅไธไธชๆดๆฐ n(n<1000)ๅผๅคด๏ผๅ่ท n ๅฏน้
ๆ็ๆฏ่ต็ปๆ๏ผๆฏ่ต็ปๆไปฅไธๅฏน้ๆๅๅญ๏ผไธญ้ด้ไธ็ฉบๆ ผ๏ผ่กจ็คบ๏ผๅ่
ๆ่ๅ่
ใ
ๅฆๆ n ไธบ 0๏ผๅ่กจ็คบ่พๅ
ฅ็ปๆใ
ๅฏนไบๆฏไธช้ๆ็พค๏ผ่ฅไฝ ๅคๆญๅบไบง็ไบๅ ๅ๏ผๅๅจไธ่กไธญ่พๅบโYesโ๏ผๅฆๅๅจ
ไธ่กไธญ่พๅบโNoโใ
sample in:
3
Alice Bob
Smith John
Alice Smith
5
ac
cd
de
be
ad
0
sample out:
Yes
NO
*/
#include "stdio.h"
#include "string"
#include "map"
int in [2002];
using namespace std;
map<string,int> M;
void clear(){
for (int i = 0; i < 2002; ++i) {
in[i] = 0;
}
M.clear();
}
int main(){
int num;
char s1[10],s2[10];
while (scanf("%d",&num) !=EOF && num !=0){
clear();
int idx =0;
for (int i = 0; i < num; ++i){
scanf("%s %s", s1, s2);
string str1 = s1;
string str2 = s2;
if(M.find(str1) == M.end()){
//not exist
M[str1] = idx ++;
}
int idx2 = 0;
if(M.find(str2) == M.end()){
idx2 = idx;
M[str2] = idx++;
}else idx2 = M[str2];
in[idx2] ++; //DAG 's end point means lose. so ++ means lost to someone ,number means times
}
int count = 0;
for (int j = 0; j < idx; ++j) {
if( !in[j]) count ++; //if the factor =0,it is always the winner,but we wannan to find the unique
}
printf("%s", count==1? "YES":"NO");
printf("\n");
}
return 0;
}
|
[
"328397315@qq.com"
] |
328397315@qq.com
|
b4ed4774432be06a428b43c938ee6e93ebb63587
|
f1e3b4751f3d74cfd19528f6890f2095e2cd4147
|
/tools/Wix/sdk/inc/dutil.h
|
9f98883f802d1836abbea9a3c6c74a342ad0cff5
|
[
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference",
"CPL-1.0"
] |
permissive
|
matteobruni/NLog
|
703dd690b7026a3fb3a04b84b59900667281920f
|
07a4f0db752a4127586a13127d1021b4eb2b9155
|
refs/heads/master
| 2023-04-11T22:38:55.720947
| 2015-09-30T08:34:48
| 2015-09-30T08:34:48
| 29,958,899
| 1
| 0
|
BSD-3-Clause
| 2023-04-03T23:57:38
| 2015-01-28T09:02:50
|
C#
|
UTF-8
|
C++
| false
| false
| 11,505
|
h
|
#pragma once
//-------------------------------------------------------------------------------------------------
// <copyright file="dutil.h" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// <summary>
// Header for utility layer that provides standard support for asserts, exit macros
// </summary>
//-------------------------------------------------------------------------------------------------
#define DAPI __stdcall
#define DAPIV __cdecl // used only for functions taking variable length arguments
#define DAPI_(type) EXTERN_C type DAPI
#define DAPIV_(type) EXTERN_C type DAPIV
// enums
enum REPORT_LEVEL
{
REPORT_NONE, // turns off report (only valid for XXXSetLevel())
REPORT_STANDARD, // written if reporting is on
REPORT_VERBOSE, // written only if verbose reporting is on
REPORT_DEBUG, // reporting useful when debugging code
REPORT_ERROR, // always gets reported, but can never be specified
};
// asserts and traces
#ifdef DEBUG
typedef BOOL (DAPI *DUTIL_ASSERTDISPLAYFUNCTION)(LPCSTR sz);
extern "C" void DAPI Dutil_SetAssertModule(__in HMODULE hAssertModule);
extern "C" void DAPI Dutil_SetAssertDisplayFunction(__in DUTIL_ASSERTDISPLAYFUNCTION pfn);
extern "C" void DAPI Dutil_Assert(const CHAR* szFile, int iLine);
extern "C" void DAPI Dutil_AssertSz(const CHAR* szFile, int iLine, const CHAR *szMsg);
extern "C" void DAPI Dutil_TraceSetLevel(__in REPORT_LEVEL ll, __in BOOL fTraceFilenames);
extern "C" REPORT_LEVEL DAPI Dutil_TraceGetLevel();
extern "C" void __cdecl Dutil_Trace(__in LPCSTR szFile, __in int iLine, __in REPORT_LEVEL rl, __in LPCSTR szMessage, ...);
extern "C" void __cdecl Dutil_TraceError(__in LPCSTR szFile, __in int iLine, __in REPORT_LEVEL rl, __in HRESULT hr, __in LPCSTR szMessage, ...);
#endif
extern "C" void DAPI Dutil_RootFailure(__in LPCSTR szFile, __in int iLine, __in HRESULT hrError);
#ifdef DEBUG
#define AssertSetModule(m) (void)Dutil_SetAssertModule(m)
#define AssertSetDisplayFunction(pfn) (void)Dutil_SetAssertDisplayFunction(pfn)
#define Assert(f) ((f) ? (void)0 : (void)Dutil_Assert(__FILE__, __LINE__))
#define AssertSz(f, sz) ((f) ? (void)0 : (void)Dutil_AssertSz(__FILE__, __LINE__, sz))
#define TraceSetLevel(l, f) (void)Dutil_TraceSetLevel(l, f)
#define TraceGetLevel() (REPORT_LEVEL)Dutil_TraceGetLevel()
#define Trace(l, f) (void)Dutil_Trace(__FILE__, __LINE__, l, f, NULL)
#define Trace1(l, f, s) (void)Dutil_Trace(__FILE__, __LINE__, l, f, s)
#define Trace2(l, f, s, t) (void)Dutil_Trace(__FILE__, __LINE__, l, f, s, t)
#define Trace3(l, f, s, t, u) (void)Dutil_Trace(__FILE__, __LINE__, l, f, s, t, u)
#define TraceError(x, f) (void)Dutil_TraceError(__FILE__, __LINE__, REPORT_ERROR, x, f, NULL)
#define TraceError1(x, f, s) (void)Dutil_TraceError(__FILE__, __LINE__, REPORT_ERROR, x, f, s)
#define TraceError2(x, f, s, t) (void)Dutil_TraceError(__FILE__, __LINE__, REPORT_ERROR, x, f, s, t)
#define TraceError3(x, f, s, t, u) (void)Dutil_TraceError(__FILE__, __LINE__, REPORT_ERROR, x, f, s, t, u)
#define TraceErrorDebug(x, f) (void)Dutil_TraceError(__FILE__, __LINE__, REPORT_DEBUG, x, f, NULL)
#define TraceErrorDebug1(x, f, s) (void)Dutil_TraceError(__FILE__, __LINE__, REPORT_DEBUG, x, f, s)
#define TraceErrorDebug2(x, f, s, t) (void)Dutil_TraceError(__FILE__, __LINE__, REPORT_DEBUG, x, f, s, t)
#define TraceErrorDebug3(x, f, s, t, u) (void)Dutil_TraceError(__FILE__, __LINE__, REPORT_DEBUG, x, f, s, t, u)
#else // !DEBUG
#define AssertSetModule(m)
#define AssertSetDisplayFunction(pfn)
#define Assert(f)
#define AssertSz(f, sz)
#define TraceSetLevel(l, f)
#define Trace(l, f)
#define Trace1(l, f, s)
#define Trace2(l, f, s, t)
#define Trace3(l, f, s, t, u)
#define TraceError(x, f)
#define TraceError1(x, f, s)
#define TraceError2(x, f, s, t)
#define TraceError3(x, f, s, t, u)
#define TraceErrorDebug(x, f)
#define TraceErrorDebug1(x, f, s)
#define TraceErrorDebug2(x, f, s, t)
#define TraceErrorDebug3(x, f, s, t, u)
#endif // DEBUG
// ExitTrace can be overriden
#ifndef ExitTrace
#define ExitTrace TraceError
#endif
#ifndef ExitTrace1
#define ExitTrace1 TraceError1
#endif
#ifndef ExitTrace2
#define ExitTrace2 TraceError2
#endif
#ifndef ExitTrace3
#define ExitTrace3 TraceError3
#endif
// Exit macros
#define ExitFunction() { goto LExit; }
#define ExitFunction1(x) { x; goto LExit; }
#define ExitOnLastError(x, s) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace(x, s); goto LExit; } }
#define ExitOnLastError1(x, f, s) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace1(x, f, s); goto LExit; } }
#define ExitOnLastError2(x, f, s, t) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace2(x, f, s, t); goto LExit; } }
#define ExitOnLastErrorDebugTrace(x, s) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); TraceErrorDebug(x, s); goto LExit; } }
#define ExitOnLastErrorDebugTrace1(x, f, s) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); TraceErrorDebug1(x, f, s); goto LExit; } }
#define ExitOnLastErrorDebugTrace2(x, f, s, t) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); TraceErrorDebug2(x, f, s, t); goto LExit; } }
#define ExitWithLastError(x, s) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace(x, s); goto LExit; }
#define ExitWithLastError1(x, f, s) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace1(x, f, s); goto LExit; }
#define ExitWithLastError2(x, f, s, t) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace2(x, f, s, t); goto LExit; }
#define ExitWithLastError3(x, f, s, t, u) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace3(x, f, s, t, u); goto LExit; }
#define ExitOnFailure(x, s) if (FAILED(x)) { ExitTrace(x, s); goto LExit; }
#define ExitOnFailure1(x, f, s) if (FAILED(x)) { ExitTrace1(x, f, s); goto LExit; }
#define ExitOnFailure2(x, f, s, t) if (FAILED(x)) { ExitTrace2(x, f, s, t); goto LExit; }
#define ExitOnFailure3(x, f, s, t, u) if (FAILED(x)) { ExitTrace3(x, f, s, t, u); goto LExit; }
#define ExitOnRootFailure(x, s) if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace(x, s); goto LExit; }
#define ExitOnRootFailure1(x, f, s) if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace1(x, f, s); goto LExit; }
#define ExitOnRootFailure2(x, f, s, t) if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace2(x, f, s, t); goto LExit; }
#define ExitOnRootFailure3(x, f, s, t, u) if (FAILED(x)) { Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace3(x, f, s, t, u); goto LExit; }
#define ExitOnFailureDebugTrace(x, s) if (FAILED(x)) { TraceErrorDebug(x, s); goto LExit; }
#define ExitOnFailureDebugTrace1(x, f, s) if (FAILED(x)) { TraceErrorDebug1(x, f, s); goto LExit; }
#define ExitOnFailureDebugTrace2(x, f, s, t) if (FAILED(x)) { TraceErrorDebug2(x, f, s, t); goto LExit; }
#define ExitOnFailureDebugTrace3(x, f, s, t, u) if (FAILED(x)) { TraceErrorDebug3(x, f, s, t, u); goto LExit; }
#define ExitOnNull(p, x, e, s) if (NULL == p) { x = e; Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace(x, s); goto LExit; }
#define ExitOnNull1(p, x, e, f, s) if (NULL == p) { x = e; Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace1(x, f, s); goto LExit; }
#define ExitOnNull2(p, x, e, f, s, t) if (NULL == p) { x = e; Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace2(x, f, s, t); goto LExit; }
#define ExitOnNullWithLastError(p, x, s) if (NULL == p) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace(x, s); goto LExit; }
#define ExitOnNullWithLastError1(p, x, f, s) if (NULL == p) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace1(x, f, s); goto LExit; }
#define ExitOnNullDebugTrace(p, x, e, s) if (NULL == p) { x = e; Dutil_RootFailure(__FILE__, __LINE__, x); TraceErrorDebug(x, s); goto LExit; }
#define ExitOnNullDebugTrace1(p, x, e, f, s) if (NULL == p) { x = e; Dutil_RootFailure(__FILE__, __LINE__, x); TraceErrorDebug1(x, f, s); goto LExit; }
#define ExitOnInvalidHandleWithLastError(p, x, s) if (INVALID_HANDLE_VALUE == p) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace(x, s); goto LExit; }
#define ExitOnInvalidHandleWithLastError1(p, x, f, s) if (INVALID_HANDLE_VALUE == p) { x = ::GetLastError(); x = HRESULT_FROM_WIN32(x); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace1(x, f, s); goto LExit; }
#define ExitOnWin32Error(e, x, s) if (ERROR_SUCCESS != e) { x = HRESULT_FROM_WIN32(e); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace(x, s); goto LExit; }
#define ExitOnWin32Error1(e, x, f, s) if (ERROR_SUCCESS != e) { x = HRESULT_FROM_WIN32(e); if (!FAILED(x)) { x = E_FAIL; } Dutil_RootFailure(__FILE__, __LINE__, x); ExitTrace1(x, f, s); goto LExit; }
// release macros
#define ReleaseObject(x) if (x) { x->Release(); }
#define ReleaseObjectArray(prg, cel) if (prg) { for (DWORD Dutil_ReleaseObjectArrayIndex = 0; Dutil_ReleaseObjectArrayIndex < cel; ++Dutil_ReleaseObjectArrayIndex) { ReleaseObject(prg[Dutil_ReleaseObjectArrayIndex]); } ReleaseMem(prg); }
#define ReleaseVariant(x) { ::VariantClear(&x); }
#define ReleaseNullObject(x) if (x) { (x)->Release(); x = NULL; }
#define ReleaseCertificate(x) if (x) { ::CertFreeCertificateContext(x); x=NULL; }
#define ReleaseHandle(x) if (x) { ::CloseHandle(x); x = NULL; }
// useful defines and macros
#define Unused(x) ((void)x)
#ifndef countof
#if 1
#define countof(ary) (sizeof(ary) / sizeof(ary[0]))
#else
#ifndef __cplusplus
#define countof(ary) (sizeof(ary) / sizeof(ary[0]))
#else
template<typename T> static char countofVerify(void const *, T) throw() { return 0; }
template<typename T> static void countofVerify(T *const, T *const *) throw() {};
#define countof(arr) (sizeof(countofVerify(arr,&(arr))) * sizeof(arr)/sizeof(*(arr)))
#endif
#endif
#endif
#define roundup(x, n) roundup_typed(x, n, DWORD)
#define roundup_typed(x, n, t) (((t)(x) + ((t)(n) - 1)) & ~((t)(n) - 1))
#define HRESULT_FROM_RPC(x) ((HRESULT) ((x) | FACILITY_RPC))
#ifndef MAXSIZE_T
#define MAXSIZE_T ((SIZE_T)~((SIZE_T)0))
#endif
typedef const BYTE* LPCBYTE;
#define E_FILENOTFOUND HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)
#define E_INVALIDSTATE HRESULT_FROM_WIN32(ERROR_INVALID_STATE)
#define E_MOREDATA HRESULT_FROM_WIN32(ERROR_MORE_DATA)
#define E_NOMOREITEMS HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS)
#define E_NOTFOUND HRESULT_FROM_WIN32(ERROR_NOT_FOUND)
#define AddRefAndRelease(x) { x->AddRef(); x->Release(); }
#define MAKEQWORDVERSION(mj, mi, b, r) (((DWORD64)MAKELONG(r, b)) | (((DWORD64)MAKELONG(mi, mj)) << 32))
|
[
"jaak@jkowalski.net"
] |
jaak@jkowalski.net
|
6a8bf5dc055f21e485e532bf8ed285f2a35bc73a
|
6204178b1026c73f06673ff6f7d9a3bce205f784
|
/CPP_Exercises/09_Pointers/05_NameofArray.cpp
|
89662789265e394114615eb7254a6b5249744789
|
[] |
no_license
|
B-Rie/CPP_UdemyCourse
|
410686fe4f1fa695527414a7e9441eee574f7029
|
5126a23310f9d08193a79394d680755512e68aee
|
refs/heads/main
| 2023-02-20T11:03:42.552112
| 2021-01-25T19:50:08
| 2021-01-25T19:50:08
| 321,382,707
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 605
|
cpp
|
/*
Exercise 1:
Declare 5 element array of integers and a pointer to the first element of the array.
Use the pointer and its incrementation instead of array notation, fill the array with
any integer numbers. Print all of the elements out in the console.
*/
#include <iostream>
using namespace std;
int main(){
int arr[5];
int *p = arr;
for (int i=0; i<5; i++){
cout <<"Enter the an input for element arr[" << i << "] : ";
cin >> *(p++); // - pointer incrementation
}
for (int i=0; i<5; i++){
cout <<"Number " << i+1 << " : " <<arr[i]<< endl;
}
return 0;
}
|
[
"noreply@github.com"
] |
B-Rie.noreply@github.com
|
0cc7887022472ea1ebfe252123113f63c504c82f
|
40983fab9dffef97d61730310632f96356112ad3
|
/CSC8503/CSC8503/GameTech/NetworkedGame.h
|
2293443af0159cbe177f0425a6c138a8f3add8df
|
[] |
no_license
|
tywhite123/GameTech
|
4e310d2a063519ba9f0e1f15dd75ccc6eea852c1
|
c4c3b72da0b93e667f32d806847b04b78710f367
|
refs/heads/master
| 2020-04-08T08:00:24.790502
| 2018-12-13T23:05:37
| 2018-12-13T23:05:37
| 159,160,914
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,227
|
h
|
#pragma once
#include "TutorialGame.h"
#include "../CSC8503Common/GameServer.h"
#include "PacketReceiver.h"
#include "../CSC8503Common/PlayerObject.h"
#include "../CSC8503Common/StateMachine.h"
//TODO: Somehow sort this out
struct PlayerBall
{
int playerToUpdate;
Vector3 ballForce;
Vector3 collidedAt;
};
class NetworkGame
{
public:
NetworkGame();
~NetworkGame();
virtual void UpdateServer(float dt);
void LoadLevel(string name);
void InitialiseAssets();
void InitCamera();
void InitWorld();
GameObject* AddPlayerToWorld(int objID, const Vector3& position, float radius, float inverseMass = 10.0f);
GameObject* AddWallToWorld(int objID, const Vector3& position, Vector3 dimensions, float inverseMass = 10.0f);
GameObject* AddGoalToWorld(int objID, const Vector3& position, Vector3 dimensions, float inverseMass = 10.0f);
GameObject* AddMovingToWorld(int objID, const Vector3& position, Vector3 dimensions, float inverseMass = 10.0f);
GameObject* AddRobotToWorld(int objID, const Vector3& position, Vector3 dimensions, float inverseMass = 10.0f);
GameObject* AddSpinnerToWorld(int objID, const Vector3&position, Vector3 dimensions, float inverseMass = 10.0f, float spinVal = 10.0f);
GameObject* AddFloorToWorld(int objID, const Vector3 & position, Vector3 dimensions);
protected:
GameServer* server;
StringPacketReceiver stringReceiver;
PlayerConnectedPacketReceiver playerReceiver;
ScorePacketReceiver scoreReceiver;
BallForcePacketReceiver ballForceReceiver;
ReadyPlayerPacketReceiver readyPlayerReceiver;
//Player
vector<int> playerIDs;
std::map<int, string> players;
std::map<int, int> scores;
std::map<int, bool> readyPlayers;
std::vector<GameObject*> dynamicObjects;
std::vector<BallData*> ballData;
std::map<int, PlayerObject*> playerBalls;
std::map<int, bool> finishedLevel;
GameWorld* world;
PhysicsSystem* physics;
GameTechRenderer* renderer;
bool newPlayer = false;
string level;
Vector3 startingPos;
int sendUpdate;
vector<StateMachine*> stateMachines;
int stateID;
NCL::OGLMesh* cubeMesh = nullptr;
NCL::OGLMesh* sphereMesh = nullptr;
NCL::OGLTexture* basicTex = nullptr;
NCL::OGLShader* basicShader = nullptr;
Level* lvl;
bool finished;
};
|
[
"tywhitehead@hotmail.co.uk"
] |
tywhitehead@hotmail.co.uk
|
fc5c4d825bf43d2d7bce12ec036ec5a6826f0a85
|
1a7574ab447c4a12f9b93e6bf4783914f3ed6706
|
/WickedEngine/EnvProbeWindow.cpp
|
ac104d86b30a186ef973ec0958eb13fc9e1f68eb
|
[
"MIT",
"Zlib"
] |
permissive
|
cappah/WickedEngine
|
dfa9aecd7820129ff10f9cfb9d90e368eac53349
|
bf92cbda40a6ac514428a3af43764536d333fdf2
|
refs/heads/master
| 2021-01-12T15:05:44.637974
| 2016-10-22T11:38:23
| 2016-10-22T11:38:23
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,341
|
cpp
|
#include "stdafx.h"
#include "EnvProbeWindow.h"
int resolution = 256;
EnvProbeWindow::EnvProbeWindow(wiGUI* gui) : GUI(gui)
{
assert(GUI && "Invalid GUI!");
float screenW = (float)wiRenderer::GetDevice()->GetScreenWidth();
float screenH = (float)wiRenderer::GetDevice()->GetScreenHeight();
envProbeWindow = new wiWindow(GUI, "Environment Probe Window");
envProbeWindow->SetSize(XMFLOAT2(600, 400));
envProbeWindow->SetEnabled(true);
GUI->AddWidget(envProbeWindow);
float x = 250, y = 0, step = 45;
resolutionSlider = new wiSlider(1, 4096, 256, 4096, "Resolution");
resolutionSlider->SetPos(XMFLOAT2(x, y += step));
resolutionSlider->OnSlide([](wiEventArgs args) {
resolution = (int)args.fValue;
});
envProbeWindow->AddWidget(resolutionSlider);
generateButton = new wiButton("Put");
generateButton->SetPos(XMFLOAT2(x, y += step));
generateButton->OnClick([](wiEventArgs args) {
XMFLOAT3 pos;
XMStoreFloat3(&pos, XMVectorAdd(wiRenderer::getCamera()->GetEye(), wiRenderer::getCamera()->GetAt()*4));
wiRenderer::PutEnvProbe(pos, resolution);
});
envProbeWindow->AddWidget(generateButton);
envProbeWindow->Translate(XMFLOAT3(30, 30, 0));
envProbeWindow->SetVisible(false);
}
EnvProbeWindow::~EnvProbeWindow()
{
SAFE_DELETE(envProbeWindow);
SAFE_DELETE(resolutionSlider);
SAFE_DELETE(generateButton);
}
|
[
"turanszkij@gmail.com"
] |
turanszkij@gmail.com
|
536ce871b2b7638985d229e16b779df093ac3c2c
|
64d0ac5b23aea2dd1ec50d34ef59edd023f77326
|
/src/onePole.cpp
|
f6cdab05fdf3b75101b913b45699b8c911d4936b
|
[] |
no_license
|
Dante2/AVP
|
32fedff2a17fb127a0410872f405cd2417189ed4
|
156800f83812222f03a55fcd2704ada00784912c
|
refs/heads/master
| 2021-05-13T14:28:04.511307
| 2018-01-08T23:46:17
| 2018-01-08T23:46:17
| 116,741,603
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,314
|
cpp
|
//
// onePole.cpp
// mySketch
//
// Created by Jools on 08/01/2018.
//
#include "onePole.hpp"
// One Pole constructor ----------------------------------
// Initialise its variables
OnePole::OnePole(){
z = 0;
b = 0.99;
a = 1 - b;
}
// -----------------------------------------------------------
// One Pole Process function ---------------------------------
// This takes all the coefficients and applies the folloeing mathematical operation to them. 1 is the normalised maximum value of the process. 1 minus b gives us a very small
// number which is then multiplied by our incoming signal (the 2d vector array) and then added to b to calculate the difference between
// the vector's initial state and its changed one. It is all then multiplied by z to modify our original z signal by the newly updated z signal.
float OnePole::Process(float sig){
z = a * sig + b * z;
return z;
}
// One Pole setCoefficients function ---------------------------------
// Calculates the coefficients of a and b relative to the time domain and sample rate
// I have tried messing around with the exponent in variable b a little to see what sort of data smoothing effects I get
void OnePole::SetCoefficients(float time, int sampleRate){
b = exp(-0.5/(time * sampleRate));
a = 1.0 - b;
}
|
[
"jools@Joolss-MacBook-Pro.local"
] |
jools@Joolss-MacBook-Pro.local
|
af105e3635b248e4b394de2ee69316651a81c4dc
|
c776476e9d06b3779d744641e758ac3a2c15cddc
|
/examples/litmus/c/run-scripts/tmp_1/IRIW+poacquireacquire+fencembonceonce+OnceRelease.c.cbmc_out.cpp
|
dc9af5dc7ac78a980af4f6db92b55c9d9a32b3d8
|
[] |
no_license
|
ashutosh0gupta/llvm_bmc
|
aaac7961c723ba6f7ffd77a39559e0e52432eade
|
0287c4fb180244e6b3c599a9902507f05c8a7234
|
refs/heads/master
| 2023-08-02T17:14:06.178723
| 2023-07-31T10:46:53
| 2023-07-31T10:46:53
| 143,100,825
| 3
| 4
| null | 2023-05-25T05:50:55
| 2018-08-01T03:47:00
|
C++
|
UTF-8
|
C++
| false
| false
| 53,442
|
cpp
|
// 0:vars:2
// 5:atom_3_X2_0:1
// 2:atom_1_X0_1:1
// 3:atom_1_X2_0:1
// 4:atom_3_X0_1:1
// 6:thr0:1
// 7:thr1:1
// 8:thr2:1
// 9:thr3:1
#define ADDRSIZE 10
#define NPROC 5
#define NCONTEXT 1
#define ASSUME(stmt) __CPROVER_assume(stmt)
#define ASSERT(stmt) __CPROVER_assert(stmt, "error")
#define max(a,b) (a>b?a:b)
char __get_rng();
char get_rng( char from, char to ) {
char ret = __get_rng();
ASSUME(ret >= from && ret <= to);
return ret;
}
char get_rng_th( char from, char to ) {
char ret = __get_rng();
ASSUME(ret >= from && ret <= to);
return ret;
}
int main(int argc, char **argv) {
// declare arrays for intial value version in contexts
int meminit_[ADDRSIZE*NCONTEXT];
#define meminit(x,k) meminit_[(x)*NCONTEXT+k]
int coinit_[ADDRSIZE*NCONTEXT];
#define coinit(x,k) coinit_[(x)*NCONTEXT+k]
int deltainit_[ADDRSIZE*NCONTEXT];
#define deltainit(x,k) deltainit_[(x)*NCONTEXT+k]
// declare arrays for running value version in contexts
int mem_[ADDRSIZE*NCONTEXT];
#define mem(x,k) mem_[(x)*NCONTEXT+k]
int co_[ADDRSIZE*NCONTEXT];
#define co(x,k) co_[(x)*NCONTEXT+k]
int delta_[ADDRSIZE*NCONTEXT];
#define delta(x,k) delta_[(x)*NCONTEXT+k]
// declare arrays for local buffer and observed writes
int buff_[NPROC*ADDRSIZE];
#define buff(x,k) buff_[(x)*ADDRSIZE+k]
int pw_[NPROC*ADDRSIZE];
#define pw(x,k) pw_[(x)*ADDRSIZE+k]
// declare arrays for context stamps
char cr_[NPROC*ADDRSIZE];
#define cr(x,k) cr_[(x)*ADDRSIZE+k]
char iw_[NPROC*ADDRSIZE];
#define iw(x,k) iw_[(x)*ADDRSIZE+k]
char cw_[NPROC*ADDRSIZE];
#define cw(x,k) cw_[(x)*ADDRSIZE+k]
char cx_[NPROC*ADDRSIZE];
#define cx(x,k) cx_[(x)*ADDRSIZE+k]
char is_[NPROC*ADDRSIZE];
#define is(x,k) is_[(x)*ADDRSIZE+k]
char cs_[NPROC*ADDRSIZE];
#define cs(x,k) cs_[(x)*ADDRSIZE+k]
char crmax_[NPROC*ADDRSIZE];
#define crmax(x,k) crmax_[(x)*ADDRSIZE+k]
char sforbid_[ADDRSIZE*NCONTEXT];
#define sforbid(x,k) sforbid_[(x)*NCONTEXT+k]
// declare arrays for synchronizations
int cl[NPROC];
int cdy[NPROC];
int cds[NPROC];
int cdl[NPROC];
int cisb[NPROC];
int caddr[NPROC];
int cctrl[NPROC];
int cstart[NPROC];
int creturn[NPROC];
// declare arrays for contexts activity
int active[NCONTEXT];
int ctx_used[NCONTEXT];
int r0= 0;
char creg_r0;
int r1= 0;
char creg_r1;
int r2= 0;
char creg_r2;
int r3= 0;
char creg_r3;
int r4= 0;
char creg_r4;
int r5= 0;
char creg_r5;
int r6= 0;
char creg_r6;
int r7= 0;
char creg_r7;
int r8= 0;
char creg_r8;
int r9= 0;
char creg_r9;
int r10= 0;
char creg_r10;
int r11= 0;
char creg_r11;
int r12= 0;
char creg_r12;
int r13= 0;
char creg_r13;
int r14= 0;
char creg_r14;
int r15= 0;
char creg_r15;
int r16= 0;
char creg_r16;
char old_cctrl= 0;
char old_cr= 0;
char old_cdy= 0;
char old_cw= 0;
char new_creg= 0;
buff(0,0) = 0;
pw(0,0) = 0;
cr(0,0) = 0;
iw(0,0) = 0;
cw(0,0) = 0;
cx(0,0) = 0;
is(0,0) = 0;
cs(0,0) = 0;
crmax(0,0) = 0;
buff(0,1) = 0;
pw(0,1) = 0;
cr(0,1) = 0;
iw(0,1) = 0;
cw(0,1) = 0;
cx(0,1) = 0;
is(0,1) = 0;
cs(0,1) = 0;
crmax(0,1) = 0;
buff(0,2) = 0;
pw(0,2) = 0;
cr(0,2) = 0;
iw(0,2) = 0;
cw(0,2) = 0;
cx(0,2) = 0;
is(0,2) = 0;
cs(0,2) = 0;
crmax(0,2) = 0;
buff(0,3) = 0;
pw(0,3) = 0;
cr(0,3) = 0;
iw(0,3) = 0;
cw(0,3) = 0;
cx(0,3) = 0;
is(0,3) = 0;
cs(0,3) = 0;
crmax(0,3) = 0;
buff(0,4) = 0;
pw(0,4) = 0;
cr(0,4) = 0;
iw(0,4) = 0;
cw(0,4) = 0;
cx(0,4) = 0;
is(0,4) = 0;
cs(0,4) = 0;
crmax(0,4) = 0;
buff(0,5) = 0;
pw(0,5) = 0;
cr(0,5) = 0;
iw(0,5) = 0;
cw(0,5) = 0;
cx(0,5) = 0;
is(0,5) = 0;
cs(0,5) = 0;
crmax(0,5) = 0;
buff(0,6) = 0;
pw(0,6) = 0;
cr(0,6) = 0;
iw(0,6) = 0;
cw(0,6) = 0;
cx(0,6) = 0;
is(0,6) = 0;
cs(0,6) = 0;
crmax(0,6) = 0;
buff(0,7) = 0;
pw(0,7) = 0;
cr(0,7) = 0;
iw(0,7) = 0;
cw(0,7) = 0;
cx(0,7) = 0;
is(0,7) = 0;
cs(0,7) = 0;
crmax(0,7) = 0;
buff(0,8) = 0;
pw(0,8) = 0;
cr(0,8) = 0;
iw(0,8) = 0;
cw(0,8) = 0;
cx(0,8) = 0;
is(0,8) = 0;
cs(0,8) = 0;
crmax(0,8) = 0;
buff(0,9) = 0;
pw(0,9) = 0;
cr(0,9) = 0;
iw(0,9) = 0;
cw(0,9) = 0;
cx(0,9) = 0;
is(0,9) = 0;
cs(0,9) = 0;
crmax(0,9) = 0;
cl[0] = 0;
cdy[0] = 0;
cds[0] = 0;
cdl[0] = 0;
cisb[0] = 0;
caddr[0] = 0;
cctrl[0] = 0;
cstart[0] = get_rng(0,NCONTEXT-1);
creturn[0] = get_rng(0,NCONTEXT-1);
buff(1,0) = 0;
pw(1,0) = 0;
cr(1,0) = 0;
iw(1,0) = 0;
cw(1,0) = 0;
cx(1,0) = 0;
is(1,0) = 0;
cs(1,0) = 0;
crmax(1,0) = 0;
buff(1,1) = 0;
pw(1,1) = 0;
cr(1,1) = 0;
iw(1,1) = 0;
cw(1,1) = 0;
cx(1,1) = 0;
is(1,1) = 0;
cs(1,1) = 0;
crmax(1,1) = 0;
buff(1,2) = 0;
pw(1,2) = 0;
cr(1,2) = 0;
iw(1,2) = 0;
cw(1,2) = 0;
cx(1,2) = 0;
is(1,2) = 0;
cs(1,2) = 0;
crmax(1,2) = 0;
buff(1,3) = 0;
pw(1,3) = 0;
cr(1,3) = 0;
iw(1,3) = 0;
cw(1,3) = 0;
cx(1,3) = 0;
is(1,3) = 0;
cs(1,3) = 0;
crmax(1,3) = 0;
buff(1,4) = 0;
pw(1,4) = 0;
cr(1,4) = 0;
iw(1,4) = 0;
cw(1,4) = 0;
cx(1,4) = 0;
is(1,4) = 0;
cs(1,4) = 0;
crmax(1,4) = 0;
buff(1,5) = 0;
pw(1,5) = 0;
cr(1,5) = 0;
iw(1,5) = 0;
cw(1,5) = 0;
cx(1,5) = 0;
is(1,5) = 0;
cs(1,5) = 0;
crmax(1,5) = 0;
buff(1,6) = 0;
pw(1,6) = 0;
cr(1,6) = 0;
iw(1,6) = 0;
cw(1,6) = 0;
cx(1,6) = 0;
is(1,6) = 0;
cs(1,6) = 0;
crmax(1,6) = 0;
buff(1,7) = 0;
pw(1,7) = 0;
cr(1,7) = 0;
iw(1,7) = 0;
cw(1,7) = 0;
cx(1,7) = 0;
is(1,7) = 0;
cs(1,7) = 0;
crmax(1,7) = 0;
buff(1,8) = 0;
pw(1,8) = 0;
cr(1,8) = 0;
iw(1,8) = 0;
cw(1,8) = 0;
cx(1,8) = 0;
is(1,8) = 0;
cs(1,8) = 0;
crmax(1,8) = 0;
buff(1,9) = 0;
pw(1,9) = 0;
cr(1,9) = 0;
iw(1,9) = 0;
cw(1,9) = 0;
cx(1,9) = 0;
is(1,9) = 0;
cs(1,9) = 0;
crmax(1,9) = 0;
cl[1] = 0;
cdy[1] = 0;
cds[1] = 0;
cdl[1] = 0;
cisb[1] = 0;
caddr[1] = 0;
cctrl[1] = 0;
cstart[1] = get_rng(0,NCONTEXT-1);
creturn[1] = get_rng(0,NCONTEXT-1);
buff(2,0) = 0;
pw(2,0) = 0;
cr(2,0) = 0;
iw(2,0) = 0;
cw(2,0) = 0;
cx(2,0) = 0;
is(2,0) = 0;
cs(2,0) = 0;
crmax(2,0) = 0;
buff(2,1) = 0;
pw(2,1) = 0;
cr(2,1) = 0;
iw(2,1) = 0;
cw(2,1) = 0;
cx(2,1) = 0;
is(2,1) = 0;
cs(2,1) = 0;
crmax(2,1) = 0;
buff(2,2) = 0;
pw(2,2) = 0;
cr(2,2) = 0;
iw(2,2) = 0;
cw(2,2) = 0;
cx(2,2) = 0;
is(2,2) = 0;
cs(2,2) = 0;
crmax(2,2) = 0;
buff(2,3) = 0;
pw(2,3) = 0;
cr(2,3) = 0;
iw(2,3) = 0;
cw(2,3) = 0;
cx(2,3) = 0;
is(2,3) = 0;
cs(2,3) = 0;
crmax(2,3) = 0;
buff(2,4) = 0;
pw(2,4) = 0;
cr(2,4) = 0;
iw(2,4) = 0;
cw(2,4) = 0;
cx(2,4) = 0;
is(2,4) = 0;
cs(2,4) = 0;
crmax(2,4) = 0;
buff(2,5) = 0;
pw(2,5) = 0;
cr(2,5) = 0;
iw(2,5) = 0;
cw(2,5) = 0;
cx(2,5) = 0;
is(2,5) = 0;
cs(2,5) = 0;
crmax(2,5) = 0;
buff(2,6) = 0;
pw(2,6) = 0;
cr(2,6) = 0;
iw(2,6) = 0;
cw(2,6) = 0;
cx(2,6) = 0;
is(2,6) = 0;
cs(2,6) = 0;
crmax(2,6) = 0;
buff(2,7) = 0;
pw(2,7) = 0;
cr(2,7) = 0;
iw(2,7) = 0;
cw(2,7) = 0;
cx(2,7) = 0;
is(2,7) = 0;
cs(2,7) = 0;
crmax(2,7) = 0;
buff(2,8) = 0;
pw(2,8) = 0;
cr(2,8) = 0;
iw(2,8) = 0;
cw(2,8) = 0;
cx(2,8) = 0;
is(2,8) = 0;
cs(2,8) = 0;
crmax(2,8) = 0;
buff(2,9) = 0;
pw(2,9) = 0;
cr(2,9) = 0;
iw(2,9) = 0;
cw(2,9) = 0;
cx(2,9) = 0;
is(2,9) = 0;
cs(2,9) = 0;
crmax(2,9) = 0;
cl[2] = 0;
cdy[2] = 0;
cds[2] = 0;
cdl[2] = 0;
cisb[2] = 0;
caddr[2] = 0;
cctrl[2] = 0;
cstart[2] = get_rng(0,NCONTEXT-1);
creturn[2] = get_rng(0,NCONTEXT-1);
buff(3,0) = 0;
pw(3,0) = 0;
cr(3,0) = 0;
iw(3,0) = 0;
cw(3,0) = 0;
cx(3,0) = 0;
is(3,0) = 0;
cs(3,0) = 0;
crmax(3,0) = 0;
buff(3,1) = 0;
pw(3,1) = 0;
cr(3,1) = 0;
iw(3,1) = 0;
cw(3,1) = 0;
cx(3,1) = 0;
is(3,1) = 0;
cs(3,1) = 0;
crmax(3,1) = 0;
buff(3,2) = 0;
pw(3,2) = 0;
cr(3,2) = 0;
iw(3,2) = 0;
cw(3,2) = 0;
cx(3,2) = 0;
is(3,2) = 0;
cs(3,2) = 0;
crmax(3,2) = 0;
buff(3,3) = 0;
pw(3,3) = 0;
cr(3,3) = 0;
iw(3,3) = 0;
cw(3,3) = 0;
cx(3,3) = 0;
is(3,3) = 0;
cs(3,3) = 0;
crmax(3,3) = 0;
buff(3,4) = 0;
pw(3,4) = 0;
cr(3,4) = 0;
iw(3,4) = 0;
cw(3,4) = 0;
cx(3,4) = 0;
is(3,4) = 0;
cs(3,4) = 0;
crmax(3,4) = 0;
buff(3,5) = 0;
pw(3,5) = 0;
cr(3,5) = 0;
iw(3,5) = 0;
cw(3,5) = 0;
cx(3,5) = 0;
is(3,5) = 0;
cs(3,5) = 0;
crmax(3,5) = 0;
buff(3,6) = 0;
pw(3,6) = 0;
cr(3,6) = 0;
iw(3,6) = 0;
cw(3,6) = 0;
cx(3,6) = 0;
is(3,6) = 0;
cs(3,6) = 0;
crmax(3,6) = 0;
buff(3,7) = 0;
pw(3,7) = 0;
cr(3,7) = 0;
iw(3,7) = 0;
cw(3,7) = 0;
cx(3,7) = 0;
is(3,7) = 0;
cs(3,7) = 0;
crmax(3,7) = 0;
buff(3,8) = 0;
pw(3,8) = 0;
cr(3,8) = 0;
iw(3,8) = 0;
cw(3,8) = 0;
cx(3,8) = 0;
is(3,8) = 0;
cs(3,8) = 0;
crmax(3,8) = 0;
buff(3,9) = 0;
pw(3,9) = 0;
cr(3,9) = 0;
iw(3,9) = 0;
cw(3,9) = 0;
cx(3,9) = 0;
is(3,9) = 0;
cs(3,9) = 0;
crmax(3,9) = 0;
cl[3] = 0;
cdy[3] = 0;
cds[3] = 0;
cdl[3] = 0;
cisb[3] = 0;
caddr[3] = 0;
cctrl[3] = 0;
cstart[3] = get_rng(0,NCONTEXT-1);
creturn[3] = get_rng(0,NCONTEXT-1);
buff(4,0) = 0;
pw(4,0) = 0;
cr(4,0) = 0;
iw(4,0) = 0;
cw(4,0) = 0;
cx(4,0) = 0;
is(4,0) = 0;
cs(4,0) = 0;
crmax(4,0) = 0;
buff(4,1) = 0;
pw(4,1) = 0;
cr(4,1) = 0;
iw(4,1) = 0;
cw(4,1) = 0;
cx(4,1) = 0;
is(4,1) = 0;
cs(4,1) = 0;
crmax(4,1) = 0;
buff(4,2) = 0;
pw(4,2) = 0;
cr(4,2) = 0;
iw(4,2) = 0;
cw(4,2) = 0;
cx(4,2) = 0;
is(4,2) = 0;
cs(4,2) = 0;
crmax(4,2) = 0;
buff(4,3) = 0;
pw(4,3) = 0;
cr(4,3) = 0;
iw(4,3) = 0;
cw(4,3) = 0;
cx(4,3) = 0;
is(4,3) = 0;
cs(4,3) = 0;
crmax(4,3) = 0;
buff(4,4) = 0;
pw(4,4) = 0;
cr(4,4) = 0;
iw(4,4) = 0;
cw(4,4) = 0;
cx(4,4) = 0;
is(4,4) = 0;
cs(4,4) = 0;
crmax(4,4) = 0;
buff(4,5) = 0;
pw(4,5) = 0;
cr(4,5) = 0;
iw(4,5) = 0;
cw(4,5) = 0;
cx(4,5) = 0;
is(4,5) = 0;
cs(4,5) = 0;
crmax(4,5) = 0;
buff(4,6) = 0;
pw(4,6) = 0;
cr(4,6) = 0;
iw(4,6) = 0;
cw(4,6) = 0;
cx(4,6) = 0;
is(4,6) = 0;
cs(4,6) = 0;
crmax(4,6) = 0;
buff(4,7) = 0;
pw(4,7) = 0;
cr(4,7) = 0;
iw(4,7) = 0;
cw(4,7) = 0;
cx(4,7) = 0;
is(4,7) = 0;
cs(4,7) = 0;
crmax(4,7) = 0;
buff(4,8) = 0;
pw(4,8) = 0;
cr(4,8) = 0;
iw(4,8) = 0;
cw(4,8) = 0;
cx(4,8) = 0;
is(4,8) = 0;
cs(4,8) = 0;
crmax(4,8) = 0;
buff(4,9) = 0;
pw(4,9) = 0;
cr(4,9) = 0;
iw(4,9) = 0;
cw(4,9) = 0;
cx(4,9) = 0;
is(4,9) = 0;
cs(4,9) = 0;
crmax(4,9) = 0;
cl[4] = 0;
cdy[4] = 0;
cds[4] = 0;
cdl[4] = 0;
cisb[4] = 0;
caddr[4] = 0;
cctrl[4] = 0;
cstart[4] = get_rng(0,NCONTEXT-1);
creturn[4] = get_rng(0,NCONTEXT-1);
// Dumping initializations
mem(0+0,0) = 0;
mem(0+1,0) = 0;
mem(5+0,0) = 0;
mem(2+0,0) = 0;
mem(3+0,0) = 0;
mem(4+0,0) = 0;
mem(6+0,0) = 0;
mem(7+0,0) = 0;
mem(8+0,0) = 0;
mem(9+0,0) = 0;
// Dumping context matching equalities
co(0,0) = 0;
delta(0,0) = -1;
co(1,0) = 0;
delta(1,0) = -1;
co(2,0) = 0;
delta(2,0) = -1;
co(3,0) = 0;
delta(3,0) = -1;
co(4,0) = 0;
delta(4,0) = -1;
co(5,0) = 0;
delta(5,0) = -1;
co(6,0) = 0;
delta(6,0) = -1;
co(7,0) = 0;
delta(7,0) = -1;
co(8,0) = 0;
delta(8,0) = -1;
co(9,0) = 0;
delta(9,0) = -1;
// Dumping thread 1
int ret_thread_1 = 0;
cdy[1] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[1] >= cstart[1]);
T1BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !39, metadata !DIExpression()), !dbg !45
// br label %label_1, !dbg !46
goto T1BLOCK1;
T1BLOCK1:
// call void @llvm.dbg.label(metadata !44), !dbg !47
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !40, metadata !DIExpression()), !dbg !48
// call void @llvm.dbg.value(metadata i64 1, metadata !43, metadata !DIExpression()), !dbg !48
// store atomic i64 1, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !49
// ST: Guess
iw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STIW
old_cw = cw(1,0);
cw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STCOM
// Check
ASSUME(active[iw(1,0)] == 1);
ASSUME(active[cw(1,0)] == 1);
ASSUME(sforbid(0,cw(1,0))== 0);
ASSUME(iw(1,0) >= 0);
ASSUME(iw(1,0) >= 0);
ASSUME(cw(1,0) >= iw(1,0));
ASSUME(cw(1,0) >= old_cw);
ASSUME(cw(1,0) >= cr(1,0));
ASSUME(cw(1,0) >= cl[1]);
ASSUME(cw(1,0) >= cisb[1]);
ASSUME(cw(1,0) >= cdy[1]);
ASSUME(cw(1,0) >= cdl[1]);
ASSUME(cw(1,0) >= cds[1]);
ASSUME(cw(1,0) >= cctrl[1]);
ASSUME(cw(1,0) >= caddr[1]);
// Update
caddr[1] = max(caddr[1],0);
buff(1,0) = 1;
mem(0,cw(1,0)) = 1;
co(0,cw(1,0))+=1;
delta(0,cw(1,0)) = -1;
ASSUME(creturn[1] >= cw(1,0));
// ret i8* null, !dbg !50
ret_thread_1 = (- 1);
// Dumping thread 2
int ret_thread_2 = 0;
cdy[2] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[2] >= cstart[2]);
T2BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !53, metadata !DIExpression()), !dbg !72
// br label %label_2, !dbg !60
goto T2BLOCK1;
T2BLOCK1:
// call void @llvm.dbg.label(metadata !71), !dbg !74
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !56, metadata !DIExpression()), !dbg !75
// %0 = load atomic i64, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) acquire, align 8, !dbg !63
// LD: Guess
// : Acquire
old_cr = cr(2,0);
cr(2,0) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM
// Check
ASSUME(active[cr(2,0)] == 2);
ASSUME(cr(2,0) >= iw(2,0));
ASSUME(cr(2,0) >= 0);
ASSUME(cr(2,0) >= cdy[2]);
ASSUME(cr(2,0) >= cisb[2]);
ASSUME(cr(2,0) >= cdl[2]);
ASSUME(cr(2,0) >= cl[2]);
ASSUME(cr(2,0) >= cx(2,0));
ASSUME(cr(2,0) >= cs(2,0+0));
ASSUME(cr(2,0) >= cs(2,0+1));
ASSUME(cr(2,0) >= cs(2,5+0));
ASSUME(cr(2,0) >= cs(2,2+0));
ASSUME(cr(2,0) >= cs(2,3+0));
ASSUME(cr(2,0) >= cs(2,4+0));
ASSUME(cr(2,0) >= cs(2,6+0));
ASSUME(cr(2,0) >= cs(2,7+0));
ASSUME(cr(2,0) >= cs(2,8+0));
ASSUME(cr(2,0) >= cs(2,9+0));
// Update
creg_r0 = cr(2,0);
crmax(2,0) = max(crmax(2,0),cr(2,0));
caddr[2] = max(caddr[2],0);
if(cr(2,0) < cw(2,0)) {
r0 = buff(2,0);
} else {
if(pw(2,0) != co(0,cr(2,0))) {
ASSUME(cr(2,0) >= old_cr);
}
pw(2,0) = co(0,cr(2,0));
r0 = mem(0,cr(2,0));
}
cl[2] = max(cl[2],cr(2,0));
ASSUME(creturn[2] >= cr(2,0));
// call void @llvm.dbg.value(metadata i64 %0, metadata !58, metadata !DIExpression()), !dbg !75
// %conv = trunc i64 %0 to i32, !dbg !64
// call void @llvm.dbg.value(metadata i32 %conv, metadata !54, metadata !DIExpression()), !dbg !72
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1), metadata !60, metadata !DIExpression()), !dbg !78
// %1 = load atomic i64, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1) acquire, align 8, !dbg !66
// LD: Guess
// : Acquire
old_cr = cr(2,0+1*1);
cr(2,0+1*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM
// Check
ASSUME(active[cr(2,0+1*1)] == 2);
ASSUME(cr(2,0+1*1) >= iw(2,0+1*1));
ASSUME(cr(2,0+1*1) >= 0);
ASSUME(cr(2,0+1*1) >= cdy[2]);
ASSUME(cr(2,0+1*1) >= cisb[2]);
ASSUME(cr(2,0+1*1) >= cdl[2]);
ASSUME(cr(2,0+1*1) >= cl[2]);
ASSUME(cr(2,0+1*1) >= cx(2,0+1*1));
ASSUME(cr(2,0+1*1) >= cs(2,0+0));
ASSUME(cr(2,0+1*1) >= cs(2,0+1));
ASSUME(cr(2,0+1*1) >= cs(2,5+0));
ASSUME(cr(2,0+1*1) >= cs(2,2+0));
ASSUME(cr(2,0+1*1) >= cs(2,3+0));
ASSUME(cr(2,0+1*1) >= cs(2,4+0));
ASSUME(cr(2,0+1*1) >= cs(2,6+0));
ASSUME(cr(2,0+1*1) >= cs(2,7+0));
ASSUME(cr(2,0+1*1) >= cs(2,8+0));
ASSUME(cr(2,0+1*1) >= cs(2,9+0));
// Update
creg_r1 = cr(2,0+1*1);
crmax(2,0+1*1) = max(crmax(2,0+1*1),cr(2,0+1*1));
caddr[2] = max(caddr[2],0);
if(cr(2,0+1*1) < cw(2,0+1*1)) {
r1 = buff(2,0+1*1);
} else {
if(pw(2,0+1*1) != co(0+1*1,cr(2,0+1*1))) {
ASSUME(cr(2,0+1*1) >= old_cr);
}
pw(2,0+1*1) = co(0+1*1,cr(2,0+1*1));
r1 = mem(0+1*1,cr(2,0+1*1));
}
cl[2] = max(cl[2],cr(2,0+1*1));
ASSUME(creturn[2] >= cr(2,0+1*1));
// call void @llvm.dbg.value(metadata i64 %1, metadata !62, metadata !DIExpression()), !dbg !78
// %conv4 = trunc i64 %1 to i32, !dbg !67
// call void @llvm.dbg.value(metadata i32 %conv4, metadata !59, metadata !DIExpression()), !dbg !72
// %cmp = icmp eq i32 %conv, 1, !dbg !68
// %conv5 = zext i1 %cmp to i32, !dbg !68
// call void @llvm.dbg.value(metadata i32 %conv5, metadata !63, metadata !DIExpression()), !dbg !72
// call void @llvm.dbg.value(metadata i64* @atom_1_X0_1, metadata !64, metadata !DIExpression()), !dbg !82
// %2 = zext i32 %conv5 to i64
// call void @llvm.dbg.value(metadata i64 %2, metadata !66, metadata !DIExpression()), !dbg !82
// store atomic i64 %2, i64* @atom_1_X0_1 seq_cst, align 8, !dbg !70
// ST: Guess
iw(2,2) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW
old_cw = cw(2,2);
cw(2,2) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM
// Check
ASSUME(active[iw(2,2)] == 2);
ASSUME(active[cw(2,2)] == 2);
ASSUME(sforbid(2,cw(2,2))== 0);
ASSUME(iw(2,2) >= max(creg_r0,0));
ASSUME(iw(2,2) >= 0);
ASSUME(cw(2,2) >= iw(2,2));
ASSUME(cw(2,2) >= old_cw);
ASSUME(cw(2,2) >= cr(2,2));
ASSUME(cw(2,2) >= cl[2]);
ASSUME(cw(2,2) >= cisb[2]);
ASSUME(cw(2,2) >= cdy[2]);
ASSUME(cw(2,2) >= cdl[2]);
ASSUME(cw(2,2) >= cds[2]);
ASSUME(cw(2,2) >= cctrl[2]);
ASSUME(cw(2,2) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,2) = (r0==1);
mem(2,cw(2,2)) = (r0==1);
co(2,cw(2,2))+=1;
delta(2,cw(2,2)) = -1;
ASSUME(creturn[2] >= cw(2,2));
// %cmp7 = icmp eq i32 %conv4, 0, !dbg !71
// %conv8 = zext i1 %cmp7 to i32, !dbg !71
// call void @llvm.dbg.value(metadata i32 %conv8, metadata !67, metadata !DIExpression()), !dbg !72
// call void @llvm.dbg.value(metadata i64* @atom_1_X2_0, metadata !68, metadata !DIExpression()), !dbg !85
// %3 = zext i32 %conv8 to i64
// call void @llvm.dbg.value(metadata i64 %3, metadata !70, metadata !DIExpression()), !dbg !85
// store atomic i64 %3, i64* @atom_1_X2_0 seq_cst, align 8, !dbg !73
// ST: Guess
iw(2,3) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW
old_cw = cw(2,3);
cw(2,3) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM
// Check
ASSUME(active[iw(2,3)] == 2);
ASSUME(active[cw(2,3)] == 2);
ASSUME(sforbid(3,cw(2,3))== 0);
ASSUME(iw(2,3) >= max(creg_r1,0));
ASSUME(iw(2,3) >= 0);
ASSUME(cw(2,3) >= iw(2,3));
ASSUME(cw(2,3) >= old_cw);
ASSUME(cw(2,3) >= cr(2,3));
ASSUME(cw(2,3) >= cl[2]);
ASSUME(cw(2,3) >= cisb[2]);
ASSUME(cw(2,3) >= cdy[2]);
ASSUME(cw(2,3) >= cdl[2]);
ASSUME(cw(2,3) >= cds[2]);
ASSUME(cw(2,3) >= cctrl[2]);
ASSUME(cw(2,3) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,3) = (r1==0);
mem(3,cw(2,3)) = (r1==0);
co(3,cw(2,3))+=1;
delta(3,cw(2,3)) = -1;
ASSUME(creturn[2] >= cw(2,3));
// ret i8* null, !dbg !74
ret_thread_2 = (- 1);
// Dumping thread 3
int ret_thread_3 = 0;
cdy[3] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[3] >= cstart[3]);
T3BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !90, metadata !DIExpression()), !dbg !95
// br label %label_3, !dbg !46
goto T3BLOCK1;
T3BLOCK1:
// call void @llvm.dbg.label(metadata !94), !dbg !97
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1), metadata !91, metadata !DIExpression()), !dbg !98
// call void @llvm.dbg.value(metadata i64 1, metadata !93, metadata !DIExpression()), !dbg !98
// store atomic i64 1, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1) release, align 8, !dbg !49
// ST: Guess
// : Release
iw(3,0+1*1) = get_rng(0,NCONTEXT-1);// 3 ASSIGN STIW
old_cw = cw(3,0+1*1);
cw(3,0+1*1) = get_rng(0,NCONTEXT-1);// 3 ASSIGN STCOM
// Check
ASSUME(active[iw(3,0+1*1)] == 3);
ASSUME(active[cw(3,0+1*1)] == 3);
ASSUME(sforbid(0+1*1,cw(3,0+1*1))== 0);
ASSUME(iw(3,0+1*1) >= 0);
ASSUME(iw(3,0+1*1) >= 0);
ASSUME(cw(3,0+1*1) >= iw(3,0+1*1));
ASSUME(cw(3,0+1*1) >= old_cw);
ASSUME(cw(3,0+1*1) >= cr(3,0+1*1));
ASSUME(cw(3,0+1*1) >= cl[3]);
ASSUME(cw(3,0+1*1) >= cisb[3]);
ASSUME(cw(3,0+1*1) >= cdy[3]);
ASSUME(cw(3,0+1*1) >= cdl[3]);
ASSUME(cw(3,0+1*1) >= cds[3]);
ASSUME(cw(3,0+1*1) >= cctrl[3]);
ASSUME(cw(3,0+1*1) >= caddr[3]);
ASSUME(cw(3,0+1*1) >= cr(3,0+0));
ASSUME(cw(3,0+1*1) >= cr(3,0+1));
ASSUME(cw(3,0+1*1) >= cr(3,5+0));
ASSUME(cw(3,0+1*1) >= cr(3,2+0));
ASSUME(cw(3,0+1*1) >= cr(3,3+0));
ASSUME(cw(3,0+1*1) >= cr(3,4+0));
ASSUME(cw(3,0+1*1) >= cr(3,6+0));
ASSUME(cw(3,0+1*1) >= cr(3,7+0));
ASSUME(cw(3,0+1*1) >= cr(3,8+0));
ASSUME(cw(3,0+1*1) >= cr(3,9+0));
ASSUME(cw(3,0+1*1) >= cw(3,0+0));
ASSUME(cw(3,0+1*1) >= cw(3,0+1));
ASSUME(cw(3,0+1*1) >= cw(3,5+0));
ASSUME(cw(3,0+1*1) >= cw(3,2+0));
ASSUME(cw(3,0+1*1) >= cw(3,3+0));
ASSUME(cw(3,0+1*1) >= cw(3,4+0));
ASSUME(cw(3,0+1*1) >= cw(3,6+0));
ASSUME(cw(3,0+1*1) >= cw(3,7+0));
ASSUME(cw(3,0+1*1) >= cw(3,8+0));
ASSUME(cw(3,0+1*1) >= cw(3,9+0));
// Update
caddr[3] = max(caddr[3],0);
buff(3,0+1*1) = 1;
mem(0+1*1,cw(3,0+1*1)) = 1;
co(0+1*1,cw(3,0+1*1))+=1;
delta(0+1*1,cw(3,0+1*1)) = -1;
is(3,0+1*1) = iw(3,0+1*1);
cs(3,0+1*1) = cw(3,0+1*1);
ASSUME(creturn[3] >= cw(3,0+1*1));
// ret i8* null, !dbg !50
ret_thread_3 = (- 1);
// Dumping thread 4
int ret_thread_4 = 0;
cdy[4] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[4] >= cstart[4]);
T4BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !103, metadata !DIExpression()), !dbg !121
// br label %label_4, !dbg !60
goto T4BLOCK1;
T4BLOCK1:
// call void @llvm.dbg.label(metadata !120), !dbg !123
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1), metadata !105, metadata !DIExpression()), !dbg !124
// %0 = load atomic i64, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !63
// LD: Guess
old_cr = cr(4,0+1*1);
cr(4,0+1*1) = get_rng(0,NCONTEXT-1);// 4 ASSIGN LDCOM
// Check
ASSUME(active[cr(4,0+1*1)] == 4);
ASSUME(cr(4,0+1*1) >= iw(4,0+1*1));
ASSUME(cr(4,0+1*1) >= 0);
ASSUME(cr(4,0+1*1) >= cdy[4]);
ASSUME(cr(4,0+1*1) >= cisb[4]);
ASSUME(cr(4,0+1*1) >= cdl[4]);
ASSUME(cr(4,0+1*1) >= cl[4]);
// Update
creg_r2 = cr(4,0+1*1);
crmax(4,0+1*1) = max(crmax(4,0+1*1),cr(4,0+1*1));
caddr[4] = max(caddr[4],0);
if(cr(4,0+1*1) < cw(4,0+1*1)) {
r2 = buff(4,0+1*1);
} else {
if(pw(4,0+1*1) != co(0+1*1,cr(4,0+1*1))) {
ASSUME(cr(4,0+1*1) >= old_cr);
}
pw(4,0+1*1) = co(0+1*1,cr(4,0+1*1));
r2 = mem(0+1*1,cr(4,0+1*1));
}
ASSUME(creturn[4] >= cr(4,0+1*1));
// call void @llvm.dbg.value(metadata i64 %0, metadata !107, metadata !DIExpression()), !dbg !124
// %conv = trunc i64 %0 to i32, !dbg !64
// call void @llvm.dbg.value(metadata i32 %conv, metadata !104, metadata !DIExpression()), !dbg !121
// call void (...) @dmbsy(), !dbg !65
// dumbsy: Guess
old_cdy = cdy[4];
cdy[4] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[4] >= old_cdy);
ASSUME(cdy[4] >= cisb[4]);
ASSUME(cdy[4] >= cdl[4]);
ASSUME(cdy[4] >= cds[4]);
ASSUME(cdy[4] >= cctrl[4]);
ASSUME(cdy[4] >= cw(4,0+0));
ASSUME(cdy[4] >= cw(4,0+1));
ASSUME(cdy[4] >= cw(4,5+0));
ASSUME(cdy[4] >= cw(4,2+0));
ASSUME(cdy[4] >= cw(4,3+0));
ASSUME(cdy[4] >= cw(4,4+0));
ASSUME(cdy[4] >= cw(4,6+0));
ASSUME(cdy[4] >= cw(4,7+0));
ASSUME(cdy[4] >= cw(4,8+0));
ASSUME(cdy[4] >= cw(4,9+0));
ASSUME(cdy[4] >= cr(4,0+0));
ASSUME(cdy[4] >= cr(4,0+1));
ASSUME(cdy[4] >= cr(4,5+0));
ASSUME(cdy[4] >= cr(4,2+0));
ASSUME(cdy[4] >= cr(4,3+0));
ASSUME(cdy[4] >= cr(4,4+0));
ASSUME(cdy[4] >= cr(4,6+0));
ASSUME(cdy[4] >= cr(4,7+0));
ASSUME(cdy[4] >= cr(4,8+0));
ASSUME(cdy[4] >= cr(4,9+0));
ASSUME(creturn[4] >= cdy[4]);
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !109, metadata !DIExpression()), !dbg !128
// %1 = load atomic i64, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !67
// LD: Guess
old_cr = cr(4,0);
cr(4,0) = get_rng(0,NCONTEXT-1);// 4 ASSIGN LDCOM
// Check
ASSUME(active[cr(4,0)] == 4);
ASSUME(cr(4,0) >= iw(4,0));
ASSUME(cr(4,0) >= 0);
ASSUME(cr(4,0) >= cdy[4]);
ASSUME(cr(4,0) >= cisb[4]);
ASSUME(cr(4,0) >= cdl[4]);
ASSUME(cr(4,0) >= cl[4]);
// Update
creg_r3 = cr(4,0);
crmax(4,0) = max(crmax(4,0),cr(4,0));
caddr[4] = max(caddr[4],0);
if(cr(4,0) < cw(4,0)) {
r3 = buff(4,0);
} else {
if(pw(4,0) != co(0,cr(4,0))) {
ASSUME(cr(4,0) >= old_cr);
}
pw(4,0) = co(0,cr(4,0));
r3 = mem(0,cr(4,0));
}
ASSUME(creturn[4] >= cr(4,0));
// call void @llvm.dbg.value(metadata i64 %1, metadata !111, metadata !DIExpression()), !dbg !128
// %conv4 = trunc i64 %1 to i32, !dbg !68
// call void @llvm.dbg.value(metadata i32 %conv4, metadata !108, metadata !DIExpression()), !dbg !121
// %cmp = icmp eq i32 %conv, 1, !dbg !69
// %conv5 = zext i1 %cmp to i32, !dbg !69
// call void @llvm.dbg.value(metadata i32 %conv5, metadata !112, metadata !DIExpression()), !dbg !121
// call void @llvm.dbg.value(metadata i64* @atom_3_X0_1, metadata !113, metadata !DIExpression()), !dbg !132
// %2 = zext i32 %conv5 to i64
// call void @llvm.dbg.value(metadata i64 %2, metadata !115, metadata !DIExpression()), !dbg !132
// store atomic i64 %2, i64* @atom_3_X0_1 seq_cst, align 8, !dbg !71
// ST: Guess
iw(4,4) = get_rng(0,NCONTEXT-1);// 4 ASSIGN STIW
old_cw = cw(4,4);
cw(4,4) = get_rng(0,NCONTEXT-1);// 4 ASSIGN STCOM
// Check
ASSUME(active[iw(4,4)] == 4);
ASSUME(active[cw(4,4)] == 4);
ASSUME(sforbid(4,cw(4,4))== 0);
ASSUME(iw(4,4) >= max(creg_r2,0));
ASSUME(iw(4,4) >= 0);
ASSUME(cw(4,4) >= iw(4,4));
ASSUME(cw(4,4) >= old_cw);
ASSUME(cw(4,4) >= cr(4,4));
ASSUME(cw(4,4) >= cl[4]);
ASSUME(cw(4,4) >= cisb[4]);
ASSUME(cw(4,4) >= cdy[4]);
ASSUME(cw(4,4) >= cdl[4]);
ASSUME(cw(4,4) >= cds[4]);
ASSUME(cw(4,4) >= cctrl[4]);
ASSUME(cw(4,4) >= caddr[4]);
// Update
caddr[4] = max(caddr[4],0);
buff(4,4) = (r2==1);
mem(4,cw(4,4)) = (r2==1);
co(4,cw(4,4))+=1;
delta(4,cw(4,4)) = -1;
ASSUME(creturn[4] >= cw(4,4));
// %cmp7 = icmp eq i32 %conv4, 0, !dbg !72
// %conv8 = zext i1 %cmp7 to i32, !dbg !72
// call void @llvm.dbg.value(metadata i32 %conv8, metadata !116, metadata !DIExpression()), !dbg !121
// call void @llvm.dbg.value(metadata i64* @atom_3_X2_0, metadata !117, metadata !DIExpression()), !dbg !135
// %3 = zext i32 %conv8 to i64
// call void @llvm.dbg.value(metadata i64 %3, metadata !119, metadata !DIExpression()), !dbg !135
// store atomic i64 %3, i64* @atom_3_X2_0 seq_cst, align 8, !dbg !74
// ST: Guess
iw(4,5) = get_rng(0,NCONTEXT-1);// 4 ASSIGN STIW
old_cw = cw(4,5);
cw(4,5) = get_rng(0,NCONTEXT-1);// 4 ASSIGN STCOM
// Check
ASSUME(active[iw(4,5)] == 4);
ASSUME(active[cw(4,5)] == 4);
ASSUME(sforbid(5,cw(4,5))== 0);
ASSUME(iw(4,5) >= max(creg_r3,0));
ASSUME(iw(4,5) >= 0);
ASSUME(cw(4,5) >= iw(4,5));
ASSUME(cw(4,5) >= old_cw);
ASSUME(cw(4,5) >= cr(4,5));
ASSUME(cw(4,5) >= cl[4]);
ASSUME(cw(4,5) >= cisb[4]);
ASSUME(cw(4,5) >= cdy[4]);
ASSUME(cw(4,5) >= cdl[4]);
ASSUME(cw(4,5) >= cds[4]);
ASSUME(cw(4,5) >= cctrl[4]);
ASSUME(cw(4,5) >= caddr[4]);
// Update
caddr[4] = max(caddr[4],0);
buff(4,5) = (r3==0);
mem(5,cw(4,5)) = (r3==0);
co(5,cw(4,5))+=1;
delta(5,cw(4,5)) = -1;
ASSUME(creturn[4] >= cw(4,5));
// ret i8* null, !dbg !75
ret_thread_4 = (- 1);
// Dumping thread 0
int ret_thread_0 = 0;
cdy[0] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[0] >= cstart[0]);
T0BLOCK0:
// %thr0 = alloca i64, align 8
// %thr1 = alloca i64, align 8
// %thr2 = alloca i64, align 8
// %thr3 = alloca i64, align 8
// call void @llvm.dbg.value(metadata i32 %argc, metadata !145, metadata !DIExpression()), !dbg !191
// call void @llvm.dbg.value(metadata i8** %argv, metadata !146, metadata !DIExpression()), !dbg !191
// %0 = bitcast i64* %thr0 to i8*, !dbg !91
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %0) #7, !dbg !91
// call void @llvm.dbg.declare(metadata i64* %thr0, metadata !147, metadata !DIExpression()), !dbg !193
// %1 = bitcast i64* %thr1 to i8*, !dbg !93
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %1) #7, !dbg !93
// call void @llvm.dbg.declare(metadata i64* %thr1, metadata !151, metadata !DIExpression()), !dbg !195
// %2 = bitcast i64* %thr2 to i8*, !dbg !95
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %2) #7, !dbg !95
// call void @llvm.dbg.declare(metadata i64* %thr2, metadata !152, metadata !DIExpression()), !dbg !197
// %3 = bitcast i64* %thr3 to i8*, !dbg !97
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %3) #7, !dbg !97
// call void @llvm.dbg.declare(metadata i64* %thr3, metadata !153, metadata !DIExpression()), !dbg !199
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1), metadata !154, metadata !DIExpression()), !dbg !200
// call void @llvm.dbg.value(metadata i64 0, metadata !156, metadata !DIExpression()), !dbg !200
// store atomic i64 0, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !100
// ST: Guess
iw(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,0+1*1);
cw(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,0+1*1)] == 0);
ASSUME(active[cw(0,0+1*1)] == 0);
ASSUME(sforbid(0+1*1,cw(0,0+1*1))== 0);
ASSUME(iw(0,0+1*1) >= 0);
ASSUME(iw(0,0+1*1) >= 0);
ASSUME(cw(0,0+1*1) >= iw(0,0+1*1));
ASSUME(cw(0,0+1*1) >= old_cw);
ASSUME(cw(0,0+1*1) >= cr(0,0+1*1));
ASSUME(cw(0,0+1*1) >= cl[0]);
ASSUME(cw(0,0+1*1) >= cisb[0]);
ASSUME(cw(0,0+1*1) >= cdy[0]);
ASSUME(cw(0,0+1*1) >= cdl[0]);
ASSUME(cw(0,0+1*1) >= cds[0]);
ASSUME(cw(0,0+1*1) >= cctrl[0]);
ASSUME(cw(0,0+1*1) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0+1*1) = 0;
mem(0+1*1,cw(0,0+1*1)) = 0;
co(0+1*1,cw(0,0+1*1))+=1;
delta(0+1*1,cw(0,0+1*1)) = -1;
ASSUME(creturn[0] >= cw(0,0+1*1));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0), metadata !157, metadata !DIExpression()), !dbg !202
// call void @llvm.dbg.value(metadata i64 0, metadata !159, metadata !DIExpression()), !dbg !202
// store atomic i64 0, i64* getelementptr inbounds ([2 x i64], [2 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !102
// ST: Guess
iw(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,0);
cw(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,0)] == 0);
ASSUME(active[cw(0,0)] == 0);
ASSUME(sforbid(0,cw(0,0))== 0);
ASSUME(iw(0,0) >= 0);
ASSUME(iw(0,0) >= 0);
ASSUME(cw(0,0) >= iw(0,0));
ASSUME(cw(0,0) >= old_cw);
ASSUME(cw(0,0) >= cr(0,0));
ASSUME(cw(0,0) >= cl[0]);
ASSUME(cw(0,0) >= cisb[0]);
ASSUME(cw(0,0) >= cdy[0]);
ASSUME(cw(0,0) >= cdl[0]);
ASSUME(cw(0,0) >= cds[0]);
ASSUME(cw(0,0) >= cctrl[0]);
ASSUME(cw(0,0) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0) = 0;
mem(0,cw(0,0)) = 0;
co(0,cw(0,0))+=1;
delta(0,cw(0,0)) = -1;
ASSUME(creturn[0] >= cw(0,0));
// call void @llvm.dbg.value(metadata i64* @atom_1_X0_1, metadata !160, metadata !DIExpression()), !dbg !204
// call void @llvm.dbg.value(metadata i64 0, metadata !162, metadata !DIExpression()), !dbg !204
// store atomic i64 0, i64* @atom_1_X0_1 monotonic, align 8, !dbg !104
// ST: Guess
iw(0,2) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,2);
cw(0,2) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,2)] == 0);
ASSUME(active[cw(0,2)] == 0);
ASSUME(sforbid(2,cw(0,2))== 0);
ASSUME(iw(0,2) >= 0);
ASSUME(iw(0,2) >= 0);
ASSUME(cw(0,2) >= iw(0,2));
ASSUME(cw(0,2) >= old_cw);
ASSUME(cw(0,2) >= cr(0,2));
ASSUME(cw(0,2) >= cl[0]);
ASSUME(cw(0,2) >= cisb[0]);
ASSUME(cw(0,2) >= cdy[0]);
ASSUME(cw(0,2) >= cdl[0]);
ASSUME(cw(0,2) >= cds[0]);
ASSUME(cw(0,2) >= cctrl[0]);
ASSUME(cw(0,2) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,2) = 0;
mem(2,cw(0,2)) = 0;
co(2,cw(0,2))+=1;
delta(2,cw(0,2)) = -1;
ASSUME(creturn[0] >= cw(0,2));
// call void @llvm.dbg.value(metadata i64* @atom_1_X2_0, metadata !163, metadata !DIExpression()), !dbg !206
// call void @llvm.dbg.value(metadata i64 0, metadata !165, metadata !DIExpression()), !dbg !206
// store atomic i64 0, i64* @atom_1_X2_0 monotonic, align 8, !dbg !106
// ST: Guess
iw(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,3);
cw(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,3)] == 0);
ASSUME(active[cw(0,3)] == 0);
ASSUME(sforbid(3,cw(0,3))== 0);
ASSUME(iw(0,3) >= 0);
ASSUME(iw(0,3) >= 0);
ASSUME(cw(0,3) >= iw(0,3));
ASSUME(cw(0,3) >= old_cw);
ASSUME(cw(0,3) >= cr(0,3));
ASSUME(cw(0,3) >= cl[0]);
ASSUME(cw(0,3) >= cisb[0]);
ASSUME(cw(0,3) >= cdy[0]);
ASSUME(cw(0,3) >= cdl[0]);
ASSUME(cw(0,3) >= cds[0]);
ASSUME(cw(0,3) >= cctrl[0]);
ASSUME(cw(0,3) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,3) = 0;
mem(3,cw(0,3)) = 0;
co(3,cw(0,3))+=1;
delta(3,cw(0,3)) = -1;
ASSUME(creturn[0] >= cw(0,3));
// call void @llvm.dbg.value(metadata i64* @atom_3_X0_1, metadata !166, metadata !DIExpression()), !dbg !208
// call void @llvm.dbg.value(metadata i64 0, metadata !168, metadata !DIExpression()), !dbg !208
// store atomic i64 0, i64* @atom_3_X0_1 monotonic, align 8, !dbg !108
// ST: Guess
iw(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,4);
cw(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,4)] == 0);
ASSUME(active[cw(0,4)] == 0);
ASSUME(sforbid(4,cw(0,4))== 0);
ASSUME(iw(0,4) >= 0);
ASSUME(iw(0,4) >= 0);
ASSUME(cw(0,4) >= iw(0,4));
ASSUME(cw(0,4) >= old_cw);
ASSUME(cw(0,4) >= cr(0,4));
ASSUME(cw(0,4) >= cl[0]);
ASSUME(cw(0,4) >= cisb[0]);
ASSUME(cw(0,4) >= cdy[0]);
ASSUME(cw(0,4) >= cdl[0]);
ASSUME(cw(0,4) >= cds[0]);
ASSUME(cw(0,4) >= cctrl[0]);
ASSUME(cw(0,4) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,4) = 0;
mem(4,cw(0,4)) = 0;
co(4,cw(0,4))+=1;
delta(4,cw(0,4)) = -1;
ASSUME(creturn[0] >= cw(0,4));
// call void @llvm.dbg.value(metadata i64* @atom_3_X2_0, metadata !169, metadata !DIExpression()), !dbg !210
// call void @llvm.dbg.value(metadata i64 0, metadata !171, metadata !DIExpression()), !dbg !210
// store atomic i64 0, i64* @atom_3_X2_0 monotonic, align 8, !dbg !110
// ST: Guess
iw(0,5) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,5);
cw(0,5) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,5)] == 0);
ASSUME(active[cw(0,5)] == 0);
ASSUME(sforbid(5,cw(0,5))== 0);
ASSUME(iw(0,5) >= 0);
ASSUME(iw(0,5) >= 0);
ASSUME(cw(0,5) >= iw(0,5));
ASSUME(cw(0,5) >= old_cw);
ASSUME(cw(0,5) >= cr(0,5));
ASSUME(cw(0,5) >= cl[0]);
ASSUME(cw(0,5) >= cisb[0]);
ASSUME(cw(0,5) >= cdy[0]);
ASSUME(cw(0,5) >= cdl[0]);
ASSUME(cw(0,5) >= cds[0]);
ASSUME(cw(0,5) >= cctrl[0]);
ASSUME(cw(0,5) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,5) = 0;
mem(5,cw(0,5)) = 0;
co(5,cw(0,5))+=1;
delta(5,cw(0,5)) = -1;
ASSUME(creturn[0] >= cw(0,5));
// %call = call i32 @pthread_create(i64* noundef %thr0, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t0, i8* noundef null) #7, !dbg !111
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cw(0,8+0));
ASSUME(cdy[0] >= cw(0,9+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(cdy[0] >= cr(0,8+0));
ASSUME(cdy[0] >= cr(0,9+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[1] >= cdy[0]);
// %call11 = call i32 @pthread_create(i64* noundef %thr1, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t1, i8* noundef null) #7, !dbg !112
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cw(0,8+0));
ASSUME(cdy[0] >= cw(0,9+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(cdy[0] >= cr(0,8+0));
ASSUME(cdy[0] >= cr(0,9+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[2] >= cdy[0]);
// %call12 = call i32 @pthread_create(i64* noundef %thr2, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t2, i8* noundef null) #7, !dbg !113
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cw(0,8+0));
ASSUME(cdy[0] >= cw(0,9+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(cdy[0] >= cr(0,8+0));
ASSUME(cdy[0] >= cr(0,9+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[3] >= cdy[0]);
// %call13 = call i32 @pthread_create(i64* noundef %thr3, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t3, i8* noundef null) #7, !dbg !114
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cw(0,8+0));
ASSUME(cdy[0] >= cw(0,9+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(cdy[0] >= cr(0,8+0));
ASSUME(cdy[0] >= cr(0,9+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[4] >= cdy[0]);
// %4 = load i64, i64* %thr0, align 8, !dbg !115, !tbaa !116
// LD: Guess
old_cr = cr(0,6);
cr(0,6) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,6)] == 0);
ASSUME(cr(0,6) >= iw(0,6));
ASSUME(cr(0,6) >= 0);
ASSUME(cr(0,6) >= cdy[0]);
ASSUME(cr(0,6) >= cisb[0]);
ASSUME(cr(0,6) >= cdl[0]);
ASSUME(cr(0,6) >= cl[0]);
// Update
creg_r5 = cr(0,6);
crmax(0,6) = max(crmax(0,6),cr(0,6));
caddr[0] = max(caddr[0],0);
if(cr(0,6) < cw(0,6)) {
r5 = buff(0,6);
} else {
if(pw(0,6) != co(6,cr(0,6))) {
ASSUME(cr(0,6) >= old_cr);
}
pw(0,6) = co(6,cr(0,6));
r5 = mem(6,cr(0,6));
}
ASSUME(creturn[0] >= cr(0,6));
// %call14 = call i32 @pthread_join(i64 noundef %4, i8** noundef null), !dbg !120
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cw(0,8+0));
ASSUME(cdy[0] >= cw(0,9+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(cdy[0] >= cr(0,8+0));
ASSUME(cdy[0] >= cr(0,9+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[1]);
// %5 = load i64, i64* %thr1, align 8, !dbg !121, !tbaa !116
// LD: Guess
old_cr = cr(0,7);
cr(0,7) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,7)] == 0);
ASSUME(cr(0,7) >= iw(0,7));
ASSUME(cr(0,7) >= 0);
ASSUME(cr(0,7) >= cdy[0]);
ASSUME(cr(0,7) >= cisb[0]);
ASSUME(cr(0,7) >= cdl[0]);
ASSUME(cr(0,7) >= cl[0]);
// Update
creg_r6 = cr(0,7);
crmax(0,7) = max(crmax(0,7),cr(0,7));
caddr[0] = max(caddr[0],0);
if(cr(0,7) < cw(0,7)) {
r6 = buff(0,7);
} else {
if(pw(0,7) != co(7,cr(0,7))) {
ASSUME(cr(0,7) >= old_cr);
}
pw(0,7) = co(7,cr(0,7));
r6 = mem(7,cr(0,7));
}
ASSUME(creturn[0] >= cr(0,7));
// %call15 = call i32 @pthread_join(i64 noundef %5, i8** noundef null), !dbg !122
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cw(0,8+0));
ASSUME(cdy[0] >= cw(0,9+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(cdy[0] >= cr(0,8+0));
ASSUME(cdy[0] >= cr(0,9+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[2]);
// %6 = load i64, i64* %thr2, align 8, !dbg !123, !tbaa !116
// LD: Guess
old_cr = cr(0,8);
cr(0,8) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,8)] == 0);
ASSUME(cr(0,8) >= iw(0,8));
ASSUME(cr(0,8) >= 0);
ASSUME(cr(0,8) >= cdy[0]);
ASSUME(cr(0,8) >= cisb[0]);
ASSUME(cr(0,8) >= cdl[0]);
ASSUME(cr(0,8) >= cl[0]);
// Update
creg_r7 = cr(0,8);
crmax(0,8) = max(crmax(0,8),cr(0,8));
caddr[0] = max(caddr[0],0);
if(cr(0,8) < cw(0,8)) {
r7 = buff(0,8);
} else {
if(pw(0,8) != co(8,cr(0,8))) {
ASSUME(cr(0,8) >= old_cr);
}
pw(0,8) = co(8,cr(0,8));
r7 = mem(8,cr(0,8));
}
ASSUME(creturn[0] >= cr(0,8));
// %call16 = call i32 @pthread_join(i64 noundef %6, i8** noundef null), !dbg !124
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cw(0,8+0));
ASSUME(cdy[0] >= cw(0,9+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(cdy[0] >= cr(0,8+0));
ASSUME(cdy[0] >= cr(0,9+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[3]);
// %7 = load i64, i64* %thr3, align 8, !dbg !125, !tbaa !116
// LD: Guess
old_cr = cr(0,9);
cr(0,9) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,9)] == 0);
ASSUME(cr(0,9) >= iw(0,9));
ASSUME(cr(0,9) >= 0);
ASSUME(cr(0,9) >= cdy[0]);
ASSUME(cr(0,9) >= cisb[0]);
ASSUME(cr(0,9) >= cdl[0]);
ASSUME(cr(0,9) >= cl[0]);
// Update
creg_r8 = cr(0,9);
crmax(0,9) = max(crmax(0,9),cr(0,9));
caddr[0] = max(caddr[0],0);
if(cr(0,9) < cw(0,9)) {
r8 = buff(0,9);
} else {
if(pw(0,9) != co(9,cr(0,9))) {
ASSUME(cr(0,9) >= old_cr);
}
pw(0,9) = co(9,cr(0,9));
r8 = mem(9,cr(0,9));
}
ASSUME(creturn[0] >= cr(0,9));
// %call17 = call i32 @pthread_join(i64 noundef %7, i8** noundef null), !dbg !126
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,2+0));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cw(0,8+0));
ASSUME(cdy[0] >= cw(0,9+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,2+0));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(cdy[0] >= cr(0,8+0));
ASSUME(cdy[0] >= cr(0,9+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[4]);
// call void @llvm.dbg.value(metadata i64* @atom_1_X0_1, metadata !173, metadata !DIExpression()), !dbg !228
// %8 = load atomic i64, i64* @atom_1_X0_1 seq_cst, align 8, !dbg !128
// LD: Guess
old_cr = cr(0,2);
cr(0,2) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,2)] == 0);
ASSUME(cr(0,2) >= iw(0,2));
ASSUME(cr(0,2) >= 0);
ASSUME(cr(0,2) >= cdy[0]);
ASSUME(cr(0,2) >= cisb[0]);
ASSUME(cr(0,2) >= cdl[0]);
ASSUME(cr(0,2) >= cl[0]);
// Update
creg_r9 = cr(0,2);
crmax(0,2) = max(crmax(0,2),cr(0,2));
caddr[0] = max(caddr[0],0);
if(cr(0,2) < cw(0,2)) {
r9 = buff(0,2);
} else {
if(pw(0,2) != co(2,cr(0,2))) {
ASSUME(cr(0,2) >= old_cr);
}
pw(0,2) = co(2,cr(0,2));
r9 = mem(2,cr(0,2));
}
ASSUME(creturn[0] >= cr(0,2));
// call void @llvm.dbg.value(metadata i64 %8, metadata !175, metadata !DIExpression()), !dbg !228
// %conv = trunc i64 %8 to i32, !dbg !129
// call void @llvm.dbg.value(metadata i32 %conv, metadata !172, metadata !DIExpression()), !dbg !191
// call void @llvm.dbg.value(metadata i64* @atom_1_X2_0, metadata !177, metadata !DIExpression()), !dbg !231
// %9 = load atomic i64, i64* @atom_1_X2_0 seq_cst, align 8, !dbg !131
// LD: Guess
old_cr = cr(0,3);
cr(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,3)] == 0);
ASSUME(cr(0,3) >= iw(0,3));
ASSUME(cr(0,3) >= 0);
ASSUME(cr(0,3) >= cdy[0]);
ASSUME(cr(0,3) >= cisb[0]);
ASSUME(cr(0,3) >= cdl[0]);
ASSUME(cr(0,3) >= cl[0]);
// Update
creg_r10 = cr(0,3);
crmax(0,3) = max(crmax(0,3),cr(0,3));
caddr[0] = max(caddr[0],0);
if(cr(0,3) < cw(0,3)) {
r10 = buff(0,3);
} else {
if(pw(0,3) != co(3,cr(0,3))) {
ASSUME(cr(0,3) >= old_cr);
}
pw(0,3) = co(3,cr(0,3));
r10 = mem(3,cr(0,3));
}
ASSUME(creturn[0] >= cr(0,3));
// call void @llvm.dbg.value(metadata i64 %9, metadata !179, metadata !DIExpression()), !dbg !231
// %conv21 = trunc i64 %9 to i32, !dbg !132
// call void @llvm.dbg.value(metadata i32 %conv21, metadata !176, metadata !DIExpression()), !dbg !191
// call void @llvm.dbg.value(metadata i64* @atom_3_X0_1, metadata !181, metadata !DIExpression()), !dbg !234
// %10 = load atomic i64, i64* @atom_3_X0_1 seq_cst, align 8, !dbg !134
// LD: Guess
old_cr = cr(0,4);
cr(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,4)] == 0);
ASSUME(cr(0,4) >= iw(0,4));
ASSUME(cr(0,4) >= 0);
ASSUME(cr(0,4) >= cdy[0]);
ASSUME(cr(0,4) >= cisb[0]);
ASSUME(cr(0,4) >= cdl[0]);
ASSUME(cr(0,4) >= cl[0]);
// Update
creg_r11 = cr(0,4);
crmax(0,4) = max(crmax(0,4),cr(0,4));
caddr[0] = max(caddr[0],0);
if(cr(0,4) < cw(0,4)) {
r11 = buff(0,4);
} else {
if(pw(0,4) != co(4,cr(0,4))) {
ASSUME(cr(0,4) >= old_cr);
}
pw(0,4) = co(4,cr(0,4));
r11 = mem(4,cr(0,4));
}
ASSUME(creturn[0] >= cr(0,4));
// call void @llvm.dbg.value(metadata i64 %10, metadata !183, metadata !DIExpression()), !dbg !234
// %conv25 = trunc i64 %10 to i32, !dbg !135
// call void @llvm.dbg.value(metadata i32 %conv25, metadata !180, metadata !DIExpression()), !dbg !191
// call void @llvm.dbg.value(metadata i64* @atom_3_X2_0, metadata !185, metadata !DIExpression()), !dbg !237
// %11 = load atomic i64, i64* @atom_3_X2_0 seq_cst, align 8, !dbg !137
// LD: Guess
old_cr = cr(0,5);
cr(0,5) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,5)] == 0);
ASSUME(cr(0,5) >= iw(0,5));
ASSUME(cr(0,5) >= 0);
ASSUME(cr(0,5) >= cdy[0]);
ASSUME(cr(0,5) >= cisb[0]);
ASSUME(cr(0,5) >= cdl[0]);
ASSUME(cr(0,5) >= cl[0]);
// Update
creg_r12 = cr(0,5);
crmax(0,5) = max(crmax(0,5),cr(0,5));
caddr[0] = max(caddr[0],0);
if(cr(0,5) < cw(0,5)) {
r12 = buff(0,5);
} else {
if(pw(0,5) != co(5,cr(0,5))) {
ASSUME(cr(0,5) >= old_cr);
}
pw(0,5) = co(5,cr(0,5));
r12 = mem(5,cr(0,5));
}
ASSUME(creturn[0] >= cr(0,5));
// call void @llvm.dbg.value(metadata i64 %11, metadata !187, metadata !DIExpression()), !dbg !237
// %conv29 = trunc i64 %11 to i32, !dbg !138
// call void @llvm.dbg.value(metadata i32 %conv29, metadata !184, metadata !DIExpression()), !dbg !191
// %and = and i32 %conv25, %conv29, !dbg !139
creg_r13 = max(creg_r11,creg_r12);
ASSUME(active[creg_r13] == 0);
r13 = r11 & r12;
// call void @llvm.dbg.value(metadata i32 %and, metadata !188, metadata !DIExpression()), !dbg !191
// %and30 = and i32 %conv21, %and, !dbg !140
creg_r14 = max(creg_r10,creg_r13);
ASSUME(active[creg_r14] == 0);
r14 = r10 & r13;
// call void @llvm.dbg.value(metadata i32 %and30, metadata !189, metadata !DIExpression()), !dbg !191
// %and31 = and i32 %conv, %and30, !dbg !141
creg_r15 = max(creg_r9,creg_r14);
ASSUME(active[creg_r15] == 0);
r15 = r9 & r14;
// call void @llvm.dbg.value(metadata i32 %and31, metadata !190, metadata !DIExpression()), !dbg !191
// %cmp = icmp eq i32 %and31, 1, !dbg !142
// br i1 %cmp, label %if.then, label %if.end, !dbg !144
old_cctrl = cctrl[0];
cctrl[0] = get_rng(0,NCONTEXT-1);
ASSUME(cctrl[0] >= old_cctrl);
ASSUME(cctrl[0] >= creg_r15);
ASSUME(cctrl[0] >= 0);
if((r15==1)) {
goto T0BLOCK1;
} else {
goto T0BLOCK2;
}
T0BLOCK1:
// call void @__assert_fail(i8* noundef getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8* noundef getelementptr inbounds ([134 x i8], [134 x i8]* @.str.1, i64 0, i64 0), i32 noundef 85, i8* noundef getelementptr inbounds ([23 x i8], [23 x i8]* @__PRETTY_FUNCTION__.main, i64 0, i64 0)) #8, !dbg !145
// unreachable, !dbg !145
r16 = 1;
T0BLOCK2:
// %12 = bitcast i64* %thr3 to i8*, !dbg !148
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %12) #7, !dbg !148
// %13 = bitcast i64* %thr2 to i8*, !dbg !148
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %13) #7, !dbg !148
// %14 = bitcast i64* %thr1 to i8*, !dbg !148
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %14) #7, !dbg !148
// %15 = bitcast i64* %thr0 to i8*, !dbg !148
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %15) #7, !dbg !148
// ret i32 0, !dbg !149
ret_thread_0 = 0;
ASSERT(r16== 0);
}
|
[
"tuan-phong.ngo@it.uu.se"
] |
tuan-phong.ngo@it.uu.se
|
3922dbce1469c11fc5b8a3eae9d4de33a807ad3a
|
95d0de25a793dcdcb27ac5c8804ccda6088f6480
|
/src/rpcmining.cpp
|
279986b20b4e41154b6416d686e6c990aa1dc85a
|
[
"MIT"
] |
permissive
|
HOANGHAI6876/CrimsonCoin1
|
738e5e9b3222e0b66d0c4888c175d6f85decdb74
|
0a15ffca478cd87670859ae7e1e3cd99dd7b76e3
|
refs/heads/master
| 2020-03-23T07:39:03.382693
| 2017-07-13T11:52:04
| 2017-07-13T11:52:04
| 141,283,508
| 0
| 1
| null | 2018-07-17T11:59:03
| 2018-07-17T11:59:02
| null |
UTF-8
|
C++
| false
| false
| 19,231
|
cpp
|
// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "main.h"
#include "db.h"
#include "txdb.h"
#include "init.h"
#include "miner.h"
#include "bitcoinrpc.h"
using namespace json_spirit;
using namespace std;
extern unsigned int nTargetSpacing;
Value getsubsidy(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
throw runtime_error(
"getsubsidy [nTarget]\n"
"Returns proof-of-work subsidy value for the specified value of target.");
return (uint64_t)GetProofOfWorkReward(0);
}
Value getmininginfo(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
throw runtime_error(
"getmininginfo\n"
"Returns an object containing mining-related information.");
uint64_t nMinWeight = 0, nMaxWeight = 0, nWeight = 0;
pwalletMain->GetStakeWeight(*pwalletMain, nMinWeight, nMaxWeight, nWeight);
Object obj, diff, weight;
obj.push_back(Pair("blocks", (int)nBestHeight));
obj.push_back(Pair("currentblocksize",(uint64_t)nLastBlockSize));
obj.push_back(Pair("currentblocktx",(uint64_t)nLastBlockTx));
diff.push_back(Pair("proof-of-work", GetDifficulty()));
diff.push_back(Pair("proof-of-stake", GetDifficulty(GetLastBlockIndex(pindexBest, true))));
diff.push_back(Pair("search-interval", (int)nLastCoinStakeSearchInterval));
obj.push_back(Pair("difficulty", diff));
obj.push_back(Pair("blockvalue", (uint64_t)GetProofOfWorkReward(0)));
obj.push_back(Pair("netmhashps", GetPoWMHashPS()));
obj.push_back(Pair("netstakeweight", GetPoSKernelPS()));
obj.push_back(Pair("errors", GetWarnings("statusbar")));
obj.push_back(Pair("pooledtx", (uint64_t)mempool.size()));
weight.push_back(Pair("minimum", (uint64_t)nMinWeight));
weight.push_back(Pair("maximum", (uint64_t)nMaxWeight));
weight.push_back(Pair("combined", (uint64_t)nWeight));
obj.push_back(Pair("stakeweight", weight));
obj.push_back(Pair("stakeinterest", (uint64_t)COIN_YEAR_REWARD));
obj.push_back(Pair("testnet", fTestNet));
return obj;
}
Value getstakinginfo(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 0)
throw runtime_error(
"getstakinginfo\n"
"Returns an object containing staking-related information.");
uint64_t nMinWeight = 0, nMaxWeight = 0, nWeight = 0;
pwalletMain->GetStakeWeight(*pwalletMain, nMinWeight, nMaxWeight, nWeight);
uint64_t nNetworkWeight = GetPoSKernelPS();
bool staking = nLastCoinStakeSearchInterval && nWeight;
int nExpectedTime = staking ? (nTargetSpacing * nNetworkWeight / nWeight) : -1;
Object obj;
obj.push_back(Pair("enabled", GetBoolArg("-staking", true)));
obj.push_back(Pair("staking", staking));
obj.push_back(Pair("errors", GetWarnings("statusbar")));
obj.push_back(Pair("currentblocksize", (uint64_t)nLastBlockSize));
obj.push_back(Pair("currentblocktx", (uint64_t)nLastBlockTx));
obj.push_back(Pair("pooledtx", (uint64_t)mempool.size()));
obj.push_back(Pair("difficulty", GetDifficulty(GetLastBlockIndex(pindexBest, true))));
obj.push_back(Pair("search-interval", (int)nLastCoinStakeSearchInterval));
obj.push_back(Pair("weight", (uint64_t)nWeight));
obj.push_back(Pair("netstakeweight", (uint64_t)nNetworkWeight));
obj.push_back(Pair("expectedtime", nExpectedTime));
return obj;
}
Value getworkex(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 2)
throw runtime_error(
"getworkex [data, coinbase]\n"
"If [data, coinbase] is not specified, returns extended work data.\n"
);
if (vNodes.empty())
throw JSONRPCError(-9, "CrimsonCoin is not connected!");
if (IsInitialBlockDownload())
throw JSONRPCError(-10, "CrimsonCoin is downloading blocks...");
if (pindexBest->nHeight >= LAST_POW_BLOCK)
throw JSONRPCError(RPC_MISC_ERROR, "No more PoW blocks");
typedef map<uint256, pair<CBlock*, CScript> > mapNewBlock_t;
static mapNewBlock_t mapNewBlock;
static vector<CBlock*> vNewBlock;
static CReserveKey reservekey(pwalletMain);
if (params.size() == 0)
{
// Update block
static unsigned int nTransactionsUpdatedLast;
static CBlockIndex* pindexPrev;
static int64_t nStart;
static CBlock* pblock;
if (pindexPrev != pindexBest ||
(nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60))
{
if (pindexPrev != pindexBest)
{
// Deallocate old blocks since they're obsolete now
mapNewBlock.clear();
BOOST_FOREACH(CBlock* pblock, vNewBlock)
delete pblock;
vNewBlock.clear();
}
nTransactionsUpdatedLast = nTransactionsUpdated;
pindexPrev = pindexBest;
nStart = GetTime();
// Create new block
pblock = CreateNewBlock(pwalletMain);
if (!pblock)
throw JSONRPCError(-7, "Out of memory");
vNewBlock.push_back(pblock);
}
// Update nTime
pblock->nTime = max(pindexPrev->GetPastTimeLimit()+1, GetAdjustedTime());
pblock->nNonce = 0;
// Update nExtraNonce
static unsigned int nExtraNonce = 0;
IncrementExtraNonce(pblock, pindexPrev, nExtraNonce);
// Save
mapNewBlock[pblock->hashMerkleRoot] = make_pair(pblock, pblock->vtx[0].vin[0].scriptSig);
// Prebuild hash buffers
char pmidstate[32];
char pdata[128];
char phash1[64];
FormatHashBuffers(pblock, pmidstate, pdata, phash1);
uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
CTransaction coinbaseTx = pblock->vtx[0];
std::vector<uint256> merkle = pblock->GetMerkleBranch(0);
Object result;
result.push_back(Pair("data", HexStr(BEGIN(pdata), END(pdata))));
result.push_back(Pair("target", HexStr(BEGIN(hashTarget), END(hashTarget))));
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
ssTx << coinbaseTx;
result.push_back(Pair("coinbase", HexStr(ssTx.begin(), ssTx.end())));
Array merkle_arr;
BOOST_FOREACH(uint256 merkleh, merkle) {
merkle_arr.push_back(HexStr(BEGIN(merkleh), END(merkleh)));
}
result.push_back(Pair("merkle", merkle_arr));
return result;
}
else
{
// Parse parameters
vector<unsigned char> vchData = ParseHex(params[0].get_str());
vector<unsigned char> coinbase;
if(params.size() == 2)
coinbase = ParseHex(params[1].get_str());
if (vchData.size() != 128)
throw JSONRPCError(-8, "Invalid parameter");
CBlock* pdata = (CBlock*)&vchData[0];
// Byte reverse
for (int i = 0; i < 128/4; i++)
((unsigned int*)pdata)[i] = ByteReverse(((unsigned int*)pdata)[i]);
// Get saved block
if (!mapNewBlock.count(pdata->hashMerkleRoot))
return false;
CBlock* pblock = mapNewBlock[pdata->hashMerkleRoot].first;
pblock->nTime = pdata->nTime;
pblock->nNonce = pdata->nNonce;
if(coinbase.size() == 0)
pblock->vtx[0].vin[0].scriptSig = mapNewBlock[pdata->hashMerkleRoot].second;
else
CDataStream(coinbase, SER_NETWORK, PROTOCOL_VERSION) >> pblock->vtx[0]; // FIXME
pblock->hashMerkleRoot = pblock->BuildMerkleTree();
return CheckWork(pblock, *pwalletMain, reservekey);
}
}
Value getwork(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
throw runtime_error(
"getwork [data]\n"
"If [data] is not specified, returns formatted hash data to work on:\n"
" \"midstate\" : precomputed hash state after hashing the first half of the data (DEPRECATED)\n" // deprecated
" \"data\" : block data\n"
" \"hash1\" : formatted hash buffer for second hash (DEPRECATED)\n" // deprecated
" \"target\" : little endian hash target\n"
"If [data] is specified, tries to solve the block and returns true if it was successful.");
if (vNodes.empty())
throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "CrimsonCoin is not connected!");
if (IsInitialBlockDownload())
throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "CrimsonCoin is downloading blocks...");
if (pindexBest->nHeight >= LAST_POW_BLOCK)
throw JSONRPCError(RPC_MISC_ERROR, "No more PoW blocks");
typedef map<uint256, pair<CBlock*, CScript> > mapNewBlock_t;
static mapNewBlock_t mapNewBlock; // FIXME: thread safety
static vector<CBlock*> vNewBlock;
static CReserveKey reservekey(pwalletMain);
if (params.size() == 0)
{
// Update block
static unsigned int nTransactionsUpdatedLast;
static CBlockIndex* pindexPrev;
static int64_t nStart;
static CBlock* pblock;
if (pindexPrev != pindexBest ||
(nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60))
{
if (pindexPrev != pindexBest)
{
// Deallocate old blocks since they're obsolete now
mapNewBlock.clear();
BOOST_FOREACH(CBlock* pblock, vNewBlock)
delete pblock;
vNewBlock.clear();
}
// Clear pindexPrev so future getworks make a new block, despite any failures from here on
pindexPrev = NULL;
// Store the pindexBest used before CreateNewBlock, to avoid races
nTransactionsUpdatedLast = nTransactionsUpdated;
CBlockIndex* pindexPrevNew = pindexBest;
nStart = GetTime();
// Create new block
pblock = CreateNewBlock(pwalletMain);
if (!pblock)
throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
vNewBlock.push_back(pblock);
// Need to update only after we know CreateNewBlock succeeded
pindexPrev = pindexPrevNew;
}
// Update nTime
pblock->UpdateTime(pindexPrev);
pblock->nNonce = 0;
// Update nExtraNonce
static unsigned int nExtraNonce = 0;
IncrementExtraNonce(pblock, pindexPrev, nExtraNonce);
// Save
mapNewBlock[pblock->hashMerkleRoot] = make_pair(pblock, pblock->vtx[0].vin[0].scriptSig);
// Pre-build hash buffers
char pmidstate[32];
char pdata[128];
char phash1[64];
FormatHashBuffers(pblock, pmidstate, pdata, phash1);
uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
Object result;
result.push_back(Pair("midstate", HexStr(BEGIN(pmidstate), END(pmidstate)))); // deprecated
result.push_back(Pair("data", HexStr(BEGIN(pdata), END(pdata))));
result.push_back(Pair("hash1", HexStr(BEGIN(phash1), END(phash1)))); // deprecated
result.push_back(Pair("target", HexStr(BEGIN(hashTarget), END(hashTarget))));
return result;
}
else
{
// Parse parameters
vector<unsigned char> vchData = ParseHex(params[0].get_str());
if (vchData.size() != 128)
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter");
CBlock* pdata = (CBlock*)&vchData[0];
// Byte reverse
for (int i = 0; i < 128/4; i++)
((unsigned int*)pdata)[i] = ByteReverse(((unsigned int*)pdata)[i]);
// Get saved block
if (!mapNewBlock.count(pdata->hashMerkleRoot))
return false;
CBlock* pblock = mapNewBlock[pdata->hashMerkleRoot].first;
pblock->nTime = pdata->nTime;
pblock->nNonce = pdata->nNonce;
pblock->vtx[0].vin[0].scriptSig = mapNewBlock[pdata->hashMerkleRoot].second;
pblock->hashMerkleRoot = pblock->BuildMerkleTree();
return CheckWork(pblock, *pwalletMain, reservekey);
}
}
Value getblocktemplate(const Array& params, bool fHelp)
{
if (fHelp || params.size() > 1)
throw runtime_error(
"getblocktemplate [params]\n"
"Returns data needed to construct a block to work on:\n"
" \"version\" : block version\n"
" \"previousblockhash\" : hash of current highest block\n"
" \"transactions\" : contents of non-coinbase transactions that should be included in the next block\n"
" \"coinbaseaux\" : data that should be included in coinbase\n"
" \"coinbasevalue\" : maximum allowable input to coinbase transaction, including the generation award and transaction fees\n"
" \"target\" : hash target\n"
" \"mintime\" : minimum timestamp appropriate for next block\n"
" \"curtime\" : current timestamp\n"
" \"mutable\" : list of ways the block template may be changed\n"
" \"noncerange\" : range of valid nonces\n"
" \"sigoplimit\" : limit of sigops in blocks\n"
" \"sizelimit\" : limit of block size\n"
" \"bits\" : compressed target of next block\n"
" \"height\" : height of the next block\n"
"See https://en.bitcoin.it/wiki/BIP_0022 for full specification.");
std::string strMode = "template";
if (params.size() > 0)
{
const Object& oparam = params[0].get_obj();
const Value& modeval = find_value(oparam, "mode");
if (modeval.type() == str_type)
strMode = modeval.get_str();
else if (modeval.type() == null_type)
{
/* Do nothing */
}
else
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
}
if (strMode != "template")
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid mode");
if (vNodes.empty())
throw JSONRPCError(RPC_CLIENT_NOT_CONNECTED, "CrimsonCoin is not connected!");
if (IsInitialBlockDownload())
throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "CrimsonCoin is downloading blocks...");
if (pindexBest->nHeight >= LAST_POW_BLOCK)
throw JSONRPCError(RPC_MISC_ERROR, "No more PoW blocks");
static CReserveKey reservekey(pwalletMain);
// Update block
static unsigned int nTransactionsUpdatedLast;
static CBlockIndex* pindexPrev;
static int64_t nStart;
static CBlock* pblock;
if (pindexPrev != pindexBest ||
(nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 5))
{
// Clear pindexPrev so future calls make a new block, despite any failures from here on
pindexPrev = NULL;
// Store the pindexBest used before CreateNewBlock, to avoid races
nTransactionsUpdatedLast = nTransactionsUpdated;
CBlockIndex* pindexPrevNew = pindexBest;
nStart = GetTime();
// Create new block
if(pblock)
{
delete pblock;
pblock = NULL;
}
pblock = CreateNewBlock(pwalletMain);
if (!pblock)
throw JSONRPCError(RPC_OUT_OF_MEMORY, "Out of memory");
// Need to update only after we know CreateNewBlock succeeded
pindexPrev = pindexPrevNew;
}
// Update nTime
pblock->UpdateTime(pindexPrev);
pblock->nNonce = 0;
Array transactions;
map<uint256, int64_t> setTxIndex;
int i = 0;
CTxDB txdb("r");
BOOST_FOREACH (CTransaction& tx, pblock->vtx)
{
uint256 txHash = tx.GetHash();
setTxIndex[txHash] = i++;
if (tx.IsCoinBase() || tx.IsCoinStake())
continue;
Object entry;
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
ssTx << tx;
entry.push_back(Pair("data", HexStr(ssTx.begin(), ssTx.end())));
entry.push_back(Pair("hash", txHash.GetHex()));
MapPrevTx mapInputs;
map<uint256, CTxIndex> mapUnused;
bool fInvalid = false;
if (tx.FetchInputs(txdb, mapUnused, false, false, mapInputs, fInvalid))
{
entry.push_back(Pair("fee", (int64_t)(tx.GetValueIn(mapInputs) - tx.GetValueOut())));
Array deps;
BOOST_FOREACH (MapPrevTx::value_type& inp, mapInputs)
{
if (setTxIndex.count(inp.first))
deps.push_back(setTxIndex[inp.first]);
}
entry.push_back(Pair("depends", deps));
int64_t nSigOps = tx.GetLegacySigOpCount();
nSigOps += tx.GetP2SHSigOpCount(mapInputs);
entry.push_back(Pair("sigops", nSigOps));
}
transactions.push_back(entry);
}
Object aux;
aux.push_back(Pair("flags", HexStr(COINBASE_FLAGS.begin(), COINBASE_FLAGS.end())));
uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
static Array aMutable;
if (aMutable.empty())
{
aMutable.push_back("time");
aMutable.push_back("transactions");
aMutable.push_back("prevblock");
}
Object result;
result.push_back(Pair("version", pblock->nVersion));
result.push_back(Pair("previousblockhash", pblock->hashPrevBlock.GetHex()));
result.push_back(Pair("transactions", transactions));
result.push_back(Pair("coinbaseaux", aux));
result.push_back(Pair("coinbasevalue", (int64_t)pblock->vtx[0].vout[0].nValue));
result.push_back(Pair("target", hashTarget.GetHex()));
result.push_back(Pair("mintime", (int64_t)pindexPrev->GetPastTimeLimit()+1));
result.push_back(Pair("mutable", aMutable));
result.push_back(Pair("noncerange", "00000000ffffffff"));
result.push_back(Pair("sigoplimit", (int64_t)MAX_BLOCK_SIGOPS));
result.push_back(Pair("sizelimit", (int64_t)MAX_BLOCK_SIZE));
result.push_back(Pair("curtime", (int64_t)pblock->nTime));
result.push_back(Pair("bits", HexBits(pblock->nBits)));
result.push_back(Pair("height", (int64_t)(pindexPrev->nHeight+1)));
return result;
}
Value submitblock(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 2)
throw runtime_error(
"submitblock <hex data> [optional-params-obj]\n"
"[optional-params-obj] parameter is currently ignored.\n"
"Attempts to submit new block to network.\n"
"See https://en.bitcoin.it/wiki/BIP_0022 for full specification.");
vector<unsigned char> blockData(ParseHex(params[0].get_str()));
CDataStream ssBlock(blockData, SER_NETWORK, PROTOCOL_VERSION);
CBlock block;
try {
ssBlock >> block;
}
catch (std::exception &e) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Block decode failed");
}
bool fAccepted = ProcessBlock(NULL, &block);
if (!fAccepted)
return "rejected";
return Value::null;
}
|
[
"takobrooks@dr.com"
] |
takobrooks@dr.com
|
82da019a6a10c288e472ce5f42a52887fb10b406
|
2cae54fe441ad0e84b8df6917153bbe3c81ae986
|
/alphabetspam/alphabetspam.cpp
|
b826442abb0ba4130e1875b55473a8ea53559520
|
[
"MIT"
] |
permissive
|
omarchehab98/open.kattis.com-problems
|
3cb08a475ca4fb156462904a221362b98c2813c9
|
0523e2e641151dad719ef05cc9811a8ef5c6a278
|
refs/heads/master
| 2020-03-31T04:23:06.415280
| 2019-10-29T00:50:08
| 2019-10-29T00:50:08
| 151,903,075
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 620
|
cpp
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string input;
cin >> input;
cout << setprecision(10) << (double(input.size() - regex_replace(input, regex("_"), "").size()) / input.size()) << endl;
cout << setprecision(10) << (double(input.size() - regex_replace(input, regex("[a-z]"), "").size()) / input.size()) << endl;
cout << setprecision(10) << (double(input.size() - regex_replace(input, regex("[A-Z]"), "").size()) / input.size()) << endl;
cout << setprecision(10) << (double(input.size() - regex_replace(input, regex("[^_A-Za-z]"), "").size()) / input.size()) << endl;
return 0;
}
|
[
"omarchehab98@gmail.com"
] |
omarchehab98@gmail.com
|
a0ecba1dc363d690e6570c203fb90e322aa7651d
|
e7305bf4b50cedfbecf236a545f109bd825840fa
|
/core/LinearForm.hpp
|
8efe92419d980eaee2cae472f00ede127ee24aa5
|
[] |
no_license
|
lucmobz/pacs-project
|
df03257ccf4b745692b1daf30919e7db188ef573
|
e54500b96dcf0e3d44aa07fa2970f95a5ac5c4b5
|
refs/heads/main
| 2023-04-30T11:49:55.701913
| 2021-05-21T20:27:13
| 2021-05-21T20:27:13
| 369,647,056
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 6,682
|
hpp
|
#pragma once
#include <Eigen/Core>
#include <algorithm>
#include <iostream>
#include <set>
#include <type_traits>
#include <utility>
#include "Expression.hpp"
#include "FeElement.hpp"
#include "FeFace.hpp"
#include "FeSpace.hpp"
#include "Traits.hpp"
#include "expression_type_traits.hpp"
#include "utilities_include.hpp"
namespace wave {
/**
\brief This class represents a LinearForm as in the variational formulation.
A LinearForm is built on top of a FeSpace, it can be given an expression as
imput to the int2d and int3d methods as a mathematical integral expression
written on paper (these two methods takes as template parameter the quadrature
rule as in QuadratureGaussLegendre or other rules). Once the expression is
given, the assembly happens and all the vector coefficients are saved. The
method vector will return the dense underlying vector to be used for further
computations.
*/
class LinearForm {
public:
using scalar_t = Traits::scalar_t;
using point_t = Traits::point_t;
using dense_t = Traits::dense_t;
/// \brief Construct a LinearForm from an FeSpace
explicit LinearForm(const FeSpace &fespace);
/// \brief Get the number of degrees of freedom (the length of the vector)
int size() const;
/// \brief Get the form associated vector.
const dense_t &vector() const;
/// \brief See BilinearForm int3d method.
/// The only difference is the absence of the symmetry flag.
template <typename Quadrature, typename Op, typename... Args>
void int3d(const Expression<Op, Args...> &expr);
/// \brief See BilinearForm int2d method.
/// The only difference is the absence of the symmetry flag.
template <typename Quadrature, typename Op, typename... Args>
void int2d(const Expression<Op, Args...> &expr,
const std::set<int> boundaries);
private:
/// The FeSpace on which the form is built.
const FeSpace &_fespace;
/// The vector associated with the form.
dense_t _vector;
};
//------------------------------------------------------------------------------
inline LinearForm::LinearForm(const FeSpace &fespace) : _fespace(fespace) {
_vector.resize(fespace.ndof());
_vector.setZero();
};
inline int LinearForm::size() const { return _fespace.ndof(); }
inline const LinearForm::dense_t &LinearForm::vector() const { return _vector; }
//------------------------------------------------------------------------------
// See BilinearForm int3d method for info
template <typename Quadrature, typename Op, typename... Args>
void LinearForm::int3d(const Expression<Op, Args...> &expr) {
#ifdef VERBOSE
utl::Timer timer("linear int3d");
#endif
// prefetch mesh
const auto &mesh = _fespace.mesh();
// prefetch quadrature information
constexpr auto QSIZE = Quadrature::size();
constexpr auto reference_measure = Quadrature::measure();
const auto weights = Quadrature::weights();
const auto nodes = Quadrature::nodes();
// helper to treat vectors as matrices (like sub2ind)
auto at = [&QSIZE](auto q, auto i) { return q + i * QSIZE; };
// loop over the elements
for (ElementIterator e(mesh); !e.end(); ++e) {
const auto &fe = _fespace(*e);
for (const auto &[jacobian, translation, simplex_measure] :
fe.triangulation()) {
// precompute ratio
scalar_t measure_ratio = simplex_measure / reference_measure;
// precompute transformed nodes
std::array<point_t, QSIZE> x;
std::array<point_t, QSIZE> xf;
int index = 0;
for (const auto &node : nodes) {
xf[index] = jacobian * node + translation;
x[index] = fe.map(xf[index]);
++index;
}
// precompute basis functions on nodes (seg-fault access never
// happens and this avoids realloc)
std::vector<scalar_t> phi;
std::vector<point_t> dphi;
if constexpr (has_Trial_or_Test_v<decltype(expr)>) {
phi = fe.eval_basis(x);
}
if constexpr (has_GradTrial_or_GradTest_v<decltype(expr)>) {
dphi = fe.eval_basis_derivatives(x);
}
// compute values
for (int i = 0; i < fe.ndof(); ++i) {
scalar_t value = 0.0;
for (int q = 0; q < QSIZE; ++q) {
value += expr.eval(phi[at(q, i)], dphi[at(q, i)], xf[q]) * weights[q];
}
_vector[fe.dof(i)] += value * measure_ratio;
}
}
}
}
//------------------------------------------------------------------------------
// See BilinearForm int2d method for info
template <typename Quadrature, typename Op, typename... Args>
void LinearForm::int2d(const Expression<Op, Args...> &expr,
const std::set<int> boundaries) {
#ifdef VERBOSE
utl::Timer timer("linear int2d");
#endif
// prefetch mesh
const auto &mesh = _fespace.mesh();
// prefetch quadrature information
constexpr auto QSIZE = Quadrature::size();
constexpr auto reference_measure = Quadrature::measure();
const auto weights = Quadrature::weights();
const auto nodes = Quadrature::nodes();
// helper to treat vectors as matrices (like sub2ind)
auto at = [&QSIZE](auto q, auto i) { return q + i * QSIZE; };
// loop over the faces (signed)
for (FaceIterator f(mesh); !f.end(); ++f) {
const auto &fef = _fespace(*f);
if (fef.is_exterior() && boundaries.contains(fef.boundary())) {
ElementIterator e(*f);
const auto &fe = _fespace(*e);
for (const auto &[jacobian, translation, simplex_measure] :
fef.triangulation()) {
// precompute ratio
scalar_t measure_ratio = simplex_measure / reference_measure;
// precompute transformed nodes
std::array<point_t, QSIZE> x;
std::array<point_t, QSIZE> xf;
int index = 0;
for (const auto &node : nodes) {
xf[index] = jacobian * node + translation;
x[index] = fe.map(xf[index]);
++index;
}
// precompute basis functions on nodes (seg-fault access never
// happens and this avoids realloc)
std::vector<scalar_t> phi;
std::vector<point_t> dphi;
if constexpr (has_Trial_or_Test_v<decltype(expr)>) {
phi = fe.eval_basis(x);
}
if constexpr (has_GradTrial_or_GradTest_v<decltype(expr)>) {
dphi = fe.eval_basis_derivatives(x);
}
for (int i = 0; i < fe.ndof(); ++i) {
scalar_t value = 0.0;
for (int q = 0; q < QSIZE; ++q) {
value += expr.eval(fef, FeFace::Side::POSITIVE, phi[at(q, i)],
dphi[at(q, i)], xf[q]) *
weights[q];
}
_vector[fe.dof(i)] += value * measure_ratio;
}
}
}
}
}
} // namespace wave
|
[
"luca.mobz.work@gmail.com"
] |
luca.mobz.work@gmail.com
|
016b47739a6af4513a098713ebe4501a0f5c0642
|
dd949f215d968f2ee69bf85571fd63e4f085a869
|
/systems/spring-school-2011/subarchitectures/vision.sa/src/c++/vision/components/StereoFlapDetector/vs3/GestaltPrinciple.cc
|
aeb6822e906be3ebdd0df796100b595a928b2b07
|
[] |
no_license
|
marc-hanheide/cogx
|
a3fd395805f1b0ad7d713a05b9256312757b37a9
|
cb9a9c9cdfeba02afac6a83d03b7c6bb778edb95
|
refs/heads/master
| 2022-03-16T23:36:21.951317
| 2013-12-10T23:49:07
| 2013-12-10T23:49:07
| 219,460,352
| 1
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,324
|
cc
|
/**
* $Id: GestaltPrinciple.cc,v 1.15 2006/11/24 13:47:03 mxz Exp mxz $
*/
#include <string.h>
#include "VisionCore.hh"
#include "GestaltPrinciple.hh"
namespace Z
{
static const int NAME_LENGTH = 40;
static const char type_names[][NAME_LENGTH] = {
"FORM_SEGMENTS",
"FORM_LINES",
"FORM_ARCS",
"FORM_PARALLEL_LINE_GROUPS",
"FORM_ARC_JUNCTIONS",
"FORM_CONVEX_ARC_GROUPS",
"FORM_ELLIPSES",
"FORM_JUNCTIONS",
"FORM_CLOSURES",
"FORM_RECTANGLES",
"FORM_FLAPS",
"UNDEF"
};
/**
* Returns the name of a given gestalt principle type.
*/
const char* GestaltPrinciple::TypeName(Type t)
{
return type_names[t];
}
GestaltPrinciple::GestaltPrinciple(VisionCore *vc)
{
core = vc;
ResetRunTime();
}
/**
* Return the enum type of a given gestalt principle type name.
*/
GestaltPrinciple::Type GestaltPrinciple::EnumType(const char *type_name)
{
for(int i = 0; i < MAX_TYPE; i++)
if(strncmp(type_name, type_names[i], NAME_LENGTH) == 0)
return (Type)i;
return UNDEF;
}
void GestaltPrinciple::RankGestalts(Gestalt::Type type,
int(*compar)(const void *, const void *))
{
// first rank gestalts
core->RankedGestalts(type).Sort(compar);
// then set rank for each gestalt
for(unsigned i = 0; i < core->NumGestalts(type); i++)
core->RankedGestalts(type, i)->SetRank(i);
}
}
|
[
"marc@hanheide.net"
] |
marc@hanheide.net
|
bb44e81afd6d80cfb40a906477f22d9d1483a70e
|
e54dcb71a395d3743c664db488153f495d0d91e6
|
/source/runtime.cpp
|
d57751c37bfaa725999ab93ee6be0a52220f45d8
|
[
"BSD-3-Clause"
] |
permissive
|
ghostinthecamera/reshade
|
c7ea6b0392bce719f828c5132ccd833c132588a1
|
25422a378a5e67cb3ccd9c316e9dfe6255090c39
|
refs/heads/master
| 2020-08-22T16:19:08.076805
| 2019-10-20T22:06:38
| 2019-10-20T22:06:38
| 216,435,590
| 2
| 0
|
BSD-3-Clause
| 2019-10-20T22:25:10
| 2019-10-20T22:25:10
| null |
UTF-8
|
C++
| false
| false
| 54,647
|
cpp
|
/**
* Copyright (C) 2014 Patrick Mours. All rights reserved.
* License: https://github.com/crosire/reshade#license
*/
#include "log.hpp"
#include "version.h"
#include "runtime.hpp"
#include "runtime_objects.hpp"
#include "effect_parser.hpp"
#include "effect_codegen.hpp"
#include "effect_preprocessor.hpp"
#include "input.hpp"
#include "ini_file.hpp"
#include <assert.h>
#include <thread>
#include <algorithm>
#include <stb_image.h>
#include <stb_image_dds.h>
#include <stb_image_write.h>
#include <stb_image_resize.h>
extern volatile long g_network_traffic;
extern std::filesystem::path g_reshade_dll_path;
extern std::filesystem::path g_target_executable_path;
static inline std::filesystem::path absolute_path(std::filesystem::path path)
{
std::error_code ec;
// First convert path to an absolute path
path = std::filesystem::absolute(g_reshade_dll_path.parent_path() / path, ec);
// Finally try to canonicalize the path too (this may fail though, so it is optional)
if (auto canonical_path = std::filesystem::canonical(path, ec); !ec)
path = std::move(canonical_path);
return path;
}
static inline bool check_preset_path(std::filesystem::path preset_path)
{
// First make sure the extension matches, before diving into the file system
if (preset_path.extension() != L".ini" && preset_path.extension() != L".txt")
return false;
preset_path = absolute_path(preset_path);
std::error_code ec;
const std::filesystem::file_type file_type = std::filesystem::status(preset_path, ec).type();
if (file_type == std::filesystem::file_type::directory || ec.value() == 0x7b) // 0x7b: ERROR_INVALID_NAME
return false;
if (file_type == std::filesystem::file_type::not_found)
return true; // A non-existent path is valid for a new preset
return reshade::ini_file::load_cache(preset_path).has({}, "Techniques");
}
static bool find_file(const std::vector<std::filesystem::path> &search_paths, std::filesystem::path &path)
{
std::error_code ec;
if (path.is_absolute())
return std::filesystem::exists(path, ec);
for (std::filesystem::path search_path : search_paths)
{
// Append relative file path to absolute search path
search_path = absolute_path(std::move(search_path)) / path;
if (std::filesystem::exists(search_path, ec)) {
path = std::move(search_path);
return true;
}
}
return false;
}
static std::vector<std::filesystem::path> find_files(const std::vector<std::filesystem::path> &search_paths, std::initializer_list<const char *> extensions)
{
std::error_code ec;
std::vector<std::filesystem::path> files;
for (std::filesystem::path search_path : search_paths)
{
// Ignore the working directory and instead start relative paths at the DLL location
search_path = absolute_path(std::move(search_path));
for (const auto &entry : std::filesystem::directory_iterator(search_path, ec))
for (auto ext : extensions)
if (entry.path().extension() == ext)
files.push_back(entry.path());
}
return files;
}
reshade::runtime::runtime() :
_start_time(std::chrono::high_resolution_clock::now()),
_last_present_time(std::chrono::high_resolution_clock::now()),
_last_frame_duration(std::chrono::milliseconds(1)),
_effect_search_paths({ ".\\" }),
_texture_search_paths({ ".\\" }),
_global_preprocessor_definitions({
"RESHADE_DEPTH_LINEARIZATION_FAR_PLANE=1000.0",
"RESHADE_DEPTH_INPUT_IS_UPSIDE_DOWN=0",
"RESHADE_DEPTH_INPUT_IS_REVERSED=1",
"RESHADE_DEPTH_INPUT_IS_LOGARITHMIC=0" }),
_reload_key_data(),
_effects_key_data(),
_screenshot_key_data(),
_previous_preset_key_data(),
_next_preset_key_data(),
_screenshot_path(g_target_executable_path.parent_path())
{
// Default shortcut PrtScrn
_screenshot_key_data[0] = 0x2C;
_configuration_path = g_reshade_dll_path;
_configuration_path.replace_extension(".ini");
// First look for an API-named configuration file
if (std::error_code ec; !std::filesystem::exists(_configuration_path, ec))
// On failure check for a "ReShade.ini" in the application directory
_configuration_path = g_target_executable_path.parent_path() / "ReShade.ini";
if (std::error_code ec; !std::filesystem::exists(_configuration_path, ec))
// If neither exist create a "ReShade.ini" in the ReShade DLL directory
_configuration_path = g_reshade_dll_path.parent_path() / "ReShade.ini";
_needs_update = check_for_update(_latest_version);
#if RESHADE_GUI
init_ui();
#endif
load_config();
}
reshade::runtime::~runtime()
{
assert(_worker_threads.empty());
assert(!_is_initialized && _techniques.empty());
#if RESHADE_GUI
deinit_ui();
#endif
}
bool reshade::runtime::on_init(input::window_handle window)
{
LOG(INFO) << "Recreated runtime environment on runtime " << this << '.';
_input = input::register_window(window);
// Reset frame count to zero so effects are loaded in 'update_and_render_effects'
_framecount = 0;
_is_initialized = true;
_last_reload_time = std::chrono::high_resolution_clock::now();
#if RESHADE_GUI
build_font_atlas();
#endif
return true;
}
void reshade::runtime::on_reset()
{
unload_effects();
if (!_is_initialized)
return;
#if RESHADE_GUI
destroy_font_atlas();
#endif
LOG(INFO) << "Destroyed runtime environment on runtime " << this << '.';
_width = _height = 0;
_is_initialized = false;
}
void reshade::runtime::on_present()
{
// Get current time and date
time_t t = std::time(nullptr); tm tm;
localtime_s(&tm, &t);
_date[0] = tm.tm_year + 1900;
_date[1] = tm.tm_mon + 1;
_date[2] = tm.tm_mday;
_date[3] = tm.tm_hour * 3600 + tm.tm_min * 60 + tm.tm_sec;
_framecount++;
const auto current_time = std::chrono::high_resolution_clock::now();
_last_frame_duration = current_time - _last_present_time;
_last_present_time = current_time;
// Lock input so it cannot be modified by other threads while we are reading it here
const auto input_lock = _input->lock();
// Handle keyboard shortcuts
if (!_ignore_shortcuts)
{
if (_input->is_key_pressed(_effects_key_data))
_effects_enabled = !_effects_enabled;
if (_input->is_key_pressed(_screenshot_key_data))
_should_save_screenshot = true; // Notify 'update_and_render_effects' that we want to save a screenshot
// Do not allow the next shortcuts while effects are being loaded or compiled (since they affect that state)
if (!is_loading() && _reload_compile_queue.empty())
{
if (_input->is_key_pressed(_reload_key_data))
load_effects();
const bool is_next_preset_key_pressed = _input->is_key_pressed(_next_preset_key_data);
const bool is_previous_preset_key_pressed = _input->is_key_pressed(_previous_preset_key_data);
if (is_next_preset_key_pressed || is_previous_preset_key_pressed)
{
// The preset shortcut key was pressed down, so start the transition
if (switch_to_next_preset({}, is_previous_preset_key_pressed))
{
_last_preset_switching_time = current_time;
_is_in_between_presets_transition = true;
save_config();
}
}
// Continuously update preset values while a transition is in progress
if (_is_in_between_presets_transition)
load_current_preset();
}
}
#if RESHADE_GUI
// Draw overlay
draw_ui();
#endif
// Reset input status
_input->next_frame();
// Save modified INI files
ini_file::flush_cache();
// Detect high network traffic
static int cooldown = 0, traffic = 0;
if (cooldown-- > 0)
{
traffic += g_network_traffic > 0;
}
else
{
_has_high_network_activity = traffic > 10;
traffic = 0;
cooldown = 30;
}
// Reset frame statistics
g_network_traffic = 0;
_drawcalls = _vertices = 0;
}
void reshade::runtime::load_effect(const std::filesystem::path &path, size_t &out_id)
{
effect_data effect;
effect.source_file = path;
effect.compile_sucess = true;
{ // Load, pre-process and compile the source file
reshadefx::preprocessor pp;
if (path.is_absolute())
pp.add_include_path(path.parent_path());
for (std::filesystem::path include_path : _effect_search_paths)
{
include_path = absolute_path(include_path);
if (!include_path.empty())
pp.add_include_path(include_path);
}
pp.add_macro_definition("__RESHADE__", std::to_string(VERSION_MAJOR * 10000 + VERSION_MINOR * 100 + VERSION_REVISION));
pp.add_macro_definition("__RESHADE_PERFORMANCE_MODE__", _performance_mode ? "1" : "0");
pp.add_macro_definition("__VENDOR__", std::to_string(_vendor_id));
pp.add_macro_definition("__DEVICE__", std::to_string(_device_id));
pp.add_macro_definition("__RENDERER__", std::to_string(_renderer_id));
// Truncate hash to 32-bit, since lexer currently only supports 32-bit numbers anyway
pp.add_macro_definition("__APPLICATION__", std::to_string(std::hash<std::string>()(g_target_executable_path.stem().u8string()) & 0xFFFFFFFF));
pp.add_macro_definition("BUFFER_WIDTH", std::to_string(_width));
pp.add_macro_definition("BUFFER_HEIGHT", std::to_string(_height));
pp.add_macro_definition("BUFFER_RCP_WIDTH", "(1.0 / BUFFER_WIDTH)");
pp.add_macro_definition("BUFFER_RCP_HEIGHT", "(1.0 / BUFFER_HEIGHT)");
pp.add_macro_definition("BUFFER_COLOR_BIT_DEPTH", std::to_string(_color_bit_depth));
std::vector<std::string> preprocessor_definitions = _global_preprocessor_definitions;
preprocessor_definitions.insert(preprocessor_definitions.end(), _preset_preprocessor_definitions.begin(), _preset_preprocessor_definitions.end());
for (const auto &definition : preprocessor_definitions)
{
if (definition.empty())
continue; // Skip invalid definitions
const size_t equals_index = definition.find('=');
if (equals_index != std::string::npos)
pp.add_macro_definition(
definition.substr(0, equals_index),
definition.substr(equals_index + 1));
else
pp.add_macro_definition(definition);
}
if (!pp.append_file(path))
{
LOG(ERROR) << "Failed to load " << path << ":\n" << pp.errors();
effect.compile_sucess = false;
}
unsigned shader_model;
if (_renderer_id == 0x9000) // D3D9
shader_model = 30;
else if (_renderer_id < 0xa100) // D3D10
shader_model = 40;
else if (_renderer_id < 0xb000) // D3D11
shader_model = 41;
else if (_renderer_id < 0xc000) // D3D12
shader_model = 50;
else
shader_model = 60;
std::unique_ptr<reshadefx::codegen> codegen;
if ((_renderer_id & 0xF0000) == 0)
codegen.reset(reshadefx::create_codegen_hlsl(shader_model, true, _performance_mode));
else if (_renderer_id < 0x20000)
codegen.reset(reshadefx::create_codegen_glsl(true, _performance_mode));
else // Vulkan uses SPIR-V input
codegen.reset(reshadefx::create_codegen_spirv(true, true, _performance_mode));
reshadefx::parser parser;
// Compile the pre-processed source code (try the compile even if the preprocessor step failed to get additional error information)
if (!parser.parse(std::move(pp.output()), codegen.get()))
{
LOG(ERROR) << "Failed to compile " << path << ":\n" << pp.errors() << parser.errors();
effect.compile_sucess = false;
}
// Append preprocessor and parser errors to the error list
effect.errors = std::move(pp.errors()) + std::move(parser.errors());
// Write result to effect module
codegen->write_result(effect.module);
}
// Fill all specialization constants with values from the current preset
if (_performance_mode && !_current_preset_path.empty() && effect.compile_sucess)
{
const ini_file preset(_current_preset_path);
const std::string section(path.filename().u8string());
for (reshadefx::uniform_info &constant : effect.module.spec_constants)
{
effect.preamble += "#define SPEC_CONSTANT_" + constant.name + ' ';
switch (constant.type.base)
{
case reshadefx::type::t_int:
preset.get(section, constant.name, constant.initializer_value.as_int);
break;
case reshadefx::type::t_bool:
case reshadefx::type::t_uint:
preset.get(section, constant.name, constant.initializer_value.as_uint);
break;
case reshadefx::type::t_float:
preset.get(section, constant.name, constant.initializer_value.as_float);
break;
}
for (unsigned int i = 0; i < constant.type.components(); ++i)
{
switch (constant.type.base)
{
case reshadefx::type::t_bool:
effect.preamble += constant.initializer_value.as_uint[i] ? "true" : "false";
break;
case reshadefx::type::t_int:
effect.preamble += std::to_string(constant.initializer_value.as_int[i]);
break;
case reshadefx::type::t_uint:
effect.preamble += std::to_string(constant.initializer_value.as_uint[i]);
break;
case reshadefx::type::t_float:
effect.preamble += std::to_string(constant.initializer_value.as_float[i]);
break;
}
if (i + 1 < constant.type.components())
effect.preamble += ", ";
}
effect.preamble += '\n';
}
}
// Guard access to shared variables
const std::lock_guard<std::mutex> lock(_reload_mutex);
effect.index = out_id = _loaded_effects.size();
effect.storage_offset = _uniform_data_storage.size();
for (const reshadefx::uniform_info &info : effect.module.uniforms)
{
uniform &variable = _uniforms.emplace_back(info);
variable.effect_index = effect.index;
variable.storage_offset = effect.storage_offset + variable.offset;
// Create space for the new variable in the storage area and fill it with the initializer value
_uniform_data_storage.resize(variable.storage_offset + variable.size);
// Copy initial data into uniform storage area
reset_uniform_value(variable);
const std::string_view special = variable.annotation_as_string("source");
if (special.empty()) /* Ignore if annotation is missing */;
else if (special == "frametime")
variable.special = special_uniform::frame_time;
else if (special == "framecount")
variable.special = special_uniform::frame_count;
else if (special == "random")
variable.special = special_uniform::random;
else if (special == "pingpong")
variable.special = special_uniform::ping_pong;
else if (special == "date")
variable.special = special_uniform::date;
else if (special == "timer")
variable.special = special_uniform::timer;
else if (special == "key")
variable.special = special_uniform::key;
else if (special == "mousepoint")
variable.special = special_uniform::mouse_point;
else if (special == "mousedelta")
variable.special = special_uniform::mouse_delta;
else if (special == "mousebutton")
variable.special = special_uniform::mouse_button;
}
effect.storage_size = (_uniform_data_storage.size() - effect.storage_offset + 15) & ~15;
_uniform_data_storage.resize(effect.storage_offset + effect.storage_size);
for (const reshadefx::texture_info &info : effect.module.textures)
{
// Try to share textures with the same name across effects
if (const auto existing_texture = std::find_if(_textures.begin(), _textures.end(),
[&info](const auto &item) { return item.unique_name == info.unique_name; });
existing_texture != _textures.end())
{
// Cannot share texture if this is a normal one, but the existing one is a reference and vice versa
if (info.semantic.empty() != (existing_texture->impl_reference == texture_reference::none))
{
effect.errors += "error: " + info.unique_name + ": another effect (";
effect.errors += _loaded_effects[existing_texture->effect_index].source_file.filename().u8string();
effect.errors += ") already created a texture with the same name but different usage; rename the variable to fix this error\n";
effect.compile_sucess = false;
break;
}
else if (info.semantic.empty() && !existing_texture->matches_description(info))
{
effect.errors += "warning: " + info.unique_name + ": another effect (";
effect.errors += _loaded_effects[existing_texture->effect_index].source_file.filename().u8string();
effect.errors += ") already created a texture with the same name but different dimensions; textures are shared across all effects, so either rename the variable or adjust the dimensions so they match\n";
}
existing_texture->shared = true;
continue;
}
texture &texture = _textures.emplace_back(info);
texture.effect_index = effect.index;
if (info.semantic == "COLOR")
texture.impl_reference = texture_reference::back_buffer;
else if (info.semantic == "DEPTH")
texture.impl_reference = texture_reference::depth_buffer;
else if (!info.semantic.empty())
effect.errors += "warning: " + info.unique_name + ": unknown semantic '" + info.semantic + "'\n";
}
_loaded_effects.push_back(effect); // The 'enable_technique' call below needs to access this, so append the effect now
for (const reshadefx::technique_info &info : effect.module.techniques)
{
technique &technique = _techniques.emplace_back(info);
technique.effect_index = effect.index;
technique.hidden = technique.annotation_as_int("hidden") != 0;
technique.timeout = technique.annotation_as_int("timeout");
technique.timeleft = technique.timeout;
technique.toggle_key_data[0] = technique.annotation_as_int("toggle");
technique.toggle_key_data[1] = technique.annotation_as_int("togglectrl");
technique.toggle_key_data[2] = technique.annotation_as_int("toggleshift");
technique.toggle_key_data[3] = technique.annotation_as_int("togglealt");
if (technique.annotation_as_int("enabled"))
enable_technique(technique);
}
if (effect.compile_sucess)
if (effect.errors.empty())
LOG(INFO) << "Successfully loaded " << path << '.';
else
LOG(WARN) << "Successfully loaded " << path << " with warnings:\n" << effect.errors;
_reload_remaining_effects--;
_last_reload_successful &= effect.compile_sucess;
}
void reshade::runtime::load_effects()
{
// Clear out any previous effects
unload_effects();
_last_reload_successful = true;
// Reload preprocessor definitions from current preset before compiling
if (!_current_preset_path.empty())
{
_preset_preprocessor_definitions.clear();
const ini_file &preset = ini_file::load_cache(_current_preset_path);
preset.get({}, "PreprocessorDefinitions", _preset_preprocessor_definitions);
}
// Build a list of effect files by walking through the effect search paths
const std::vector<std::filesystem::path> effect_files =
find_files(_effect_search_paths, { ".fx" });
_reload_total_effects = effect_files.size();
_reload_remaining_effects = _reload_total_effects;
if (_reload_total_effects == 0)
return; // No effect files found, so nothing more to do
// Now that we have a list of files, load them in parallel
// Split workload into batches instead of launching a thread for every file to avoid launch overhead and stutters due to too many threads being in flight
const size_t num_splits = std::min<size_t>(effect_files.size(), std::max<size_t>(std::thread::hardware_concurrency(), 2u) - 1);
// Keep track of the spawned threads, so the runtime cannot be destroyed while they are still running
for (size_t n = 0; n < num_splits; ++n)
_worker_threads.emplace_back([this, effect_files, num_splits, n]() {
for (size_t id, i = 0; i < effect_files.size(); ++i)
if (i * num_splits / effect_files.size() == n)
load_effect(effect_files[i], id);
});
}
void reshade::runtime::load_textures()
{
LOG(INFO) << "Loading image files for textures ...";
for (texture &texture : _textures)
{
if (texture.impl == nullptr || texture.impl_reference != texture_reference::none)
continue; // Ignore textures that are not created yet and those that are handled in the runtime implementation
std::filesystem::path source_path = std::filesystem::u8path(
texture.annotation_as_string("source"));
// Ignore textures that have no image file attached to them (e.g. plain render targets)
if (source_path.empty())
continue;
// Search for image file using the provided search paths unless the path provided is already absolute
if (!find_file(_texture_search_paths, source_path)) {
LOG(ERROR) << "> Source " << source_path << " for texture '" << texture.unique_name << "' could not be found in any of the texture search paths.";
continue;
}
unsigned char *filedata = nullptr;
int width = 0, height = 0, channels = 0;
if (FILE *file; _wfopen_s(&file, source_path.c_str(), L"rb") == 0)
{
// Read texture data into memory in one go since that is faster than reading chunk by chunk
std::vector<uint8_t> mem(static_cast<size_t>(std::filesystem::file_size(source_path)));
fread(mem.data(), 1, mem.size(), file);
fclose(file);
if (stbi_dds_test_memory(mem.data(), static_cast<int>(mem.size())))
filedata = stbi_dds_load_from_memory(mem.data(), static_cast<int>(mem.size()), &width, &height, &channels, STBI_rgb_alpha);
else
filedata = stbi_load_from_memory(mem.data(), static_cast<int>(mem.size()), &width, &height, &channels, STBI_rgb_alpha);
}
if (filedata == nullptr) {
LOG(ERROR) << "> Source " << source_path << " for texture '" << texture.unique_name << "' could not be loaded! Make sure it is of a compatible file format.";
continue;
}
// Need to potentially resize image data to the texture dimensions
if (texture.width != uint32_t(width) || texture.height != uint32_t(height))
{
LOG(INFO) << "> Resizing image data for texture '" << texture.unique_name << "' from " << width << "x" << height << " to " << texture.width << "x" << texture.height << " ...";
std::vector<uint8_t> resized(texture.width * texture.height * 4);
stbir_resize_uint8(filedata, width, height, 0, resized.data(), texture.width, texture.height, 0, 4);
upload_texture(texture, resized.data());
}
else
{
upload_texture(texture, filedata);
}
stbi_image_free(filedata);
}
_textures_loaded = true;
}
void reshade::runtime::unload_effect(size_t id)
{
#if RESHADE_GUI
_selected_effect = std::numeric_limits<size_t>::max();
_selected_effect_changed = true; // Force editor to clear text after effects where reloaded
_preview_texture = nullptr;
_effect_filter_buffer[0] = '\0'; // And reset filter too, since the list of techniques might have changed
#endif
_uniforms.erase(std::remove_if(_uniforms.begin(), _uniforms.end(),
[id](const auto &it) { return it.effect_index == id; }), _uniforms.end());
_textures.erase(std::remove_if(_textures.begin(), _textures.end(),
[id](const auto &it) { return it.effect_index == id; }), _textures.end());
_techniques.erase(std::remove_if(_techniques.begin(), _techniques.end(),
[id](const auto &it) { return it.effect_index == id; }), _techniques.end());
_loaded_effects[id].source_file.clear();
}
void reshade::runtime::unload_effects()
{
#if RESHADE_GUI
_selected_effect = std::numeric_limits<size_t>::max();
_selected_effect_changed = true; // Force editor to clear text after effects where reloaded
_preview_texture = nullptr;
_effect_filter_buffer[0] = '\0'; // And reset filter too, since the list of techniques might have changed
#endif
// Make sure no threads are still accessing effect data
for (std::thread &thread : _worker_threads)
thread.join();
_worker_threads.clear();
_uniforms.clear();
_textures.clear();
_techniques.clear();
_loaded_effects.clear();
_uniform_data_storage.clear();
_textures_loaded = false;
}
void reshade::runtime::update_and_render_effects()
{
// Delay first load to the first render call to avoid loading while the application is still initializing
if (_framecount == 0 && !_no_reload_on_init)
load_effects();
if (_reload_remaining_effects == 0)
{
// Finished loading effects, so apply preset to figure out which ones need compiling
load_current_preset();
_last_reload_time = std::chrono::high_resolution_clock::now();
_reload_total_effects = 0;
_reload_remaining_effects = std::numeric_limits<size_t>::max();
}
else if (_reload_remaining_effects != std::numeric_limits<size_t>::max())
{
return; // Cannot render while effects are still being loaded
}
else
{
if (!_reload_compile_queue.empty())
{
// Pop an effect from the queue
size_t effect_index = _reload_compile_queue.back();
_reload_compile_queue.pop_back();
effect_data &effect = _loaded_effects[effect_index];
// Create textures now, since they are referenced when building samplers in the 'compile_effect' call below
bool success = true;
for (texture &texture : _textures)
{
if (texture.impl == nullptr && (texture.effect_index == effect_index || texture.shared))
{
if (!init_texture(texture))
{
success = false;
effect.errors += "Failed to create texture " + texture.unique_name;
break;
}
}
}
// Compile the effect with the back-end implementation
if (success && !compile_effect(effect))
{
// De-duplicate error lines (D3DCompiler sometimes repeats the same error multiple times)
for (size_t cur_line_offset = 0, next_line_offset, end_offset;
(next_line_offset = effect.errors.find('\n', cur_line_offset)) != std::string::npos && (end_offset = effect.errors.find('\n', next_line_offset + 1)) != std::string::npos; cur_line_offset = next_line_offset + 1)
{
const std::string_view cur_line(effect.errors.c_str() + cur_line_offset, next_line_offset - cur_line_offset);
const std::string_view next_line(effect.errors.c_str() + next_line_offset + 1, end_offset - next_line_offset - 1);
if (cur_line == next_line)
{
effect.errors.erase(next_line_offset, end_offset - next_line_offset);
next_line_offset = cur_line_offset - 1;
}
}
LOG(ERROR) << "Failed to compile " << effect.source_file << ":\n" << effect.errors;
success = false;
}
if (!success) // Something went wrong, do clean up
{
// Destroy all textures belonging to this effect
for (texture &texture : _textures)
if (texture.effect_index == effect_index && !texture.shared)
texture.impl.reset();
// Disable all techniques belonging to this effect
for (technique &technique : _techniques)
if (technique.effect_index == effect_index)
disable_technique(technique);
effect.compile_sucess = false;
_last_reload_successful = false;
}
effect.runtime_loaded = success;
// An effect has changed, need to reload textures
_textures_loaded = false;
}
else if (!_textures_loaded)
{
// Now that all effects were compiled, load all textures
load_textures();
}
}
// Lock input so it cannot be modified by other threads while we are reading it here
// TODO: This does not catch input happening between now and 'on_present'
const auto input_lock = _input->lock();
if (_should_save_screenshot && (_screenshot_save_before || !_effects_enabled))
save_screenshot(_effects_enabled ? L"-original" : std::wstring(), !_effects_enabled);
// Nothing to do here if effects are disabled globally
if (!_effects_enabled)
{
_should_save_screenshot = false;
return;
}
// Update special uniform variables
for (uniform &variable : _uniforms)
{
if (!_ignore_shortcuts && variable.toggle_key_data[0] != 0 && _input->is_key_pressed(variable.toggle_key_data))
{
assert(variable.supports_toggle_key());
// Change to next value if the associated shortcut key was pressed
switch (variable.type.base)
{
case reshadefx::type::t_bool: {
bool data;
get_uniform_value(variable, &data, 1);
set_uniform_value(variable, !data);
break; }
case reshadefx::type::t_int:
case reshadefx::type::t_uint: {
int data[4];
get_uniform_value(variable, data, 4);
const std::string_view ui_items = variable.annotation_as_string("ui_items");
size_t num_items = 0;
for (size_t offset = 0, next; (next = ui_items.find('\0', offset)) != std::string::npos; offset = next + 1)
num_items++;
data[0] = (data[0] + 1 >= num_items) ? 0 : data[0] + 1;
set_uniform_value(variable, data, 4);
break; }
}
save_current_preset();
}
switch (variable.special)
{
case special_uniform::frame_time:
set_uniform_value(variable, _last_frame_duration.count() * 1e-6f, 0.0f, 0.0f, 0.0f);
break;
case special_uniform::frame_count:
if (variable.type.is_boolean())
set_uniform_value(variable, (_framecount % 2) == 0);
else
set_uniform_value(variable, static_cast<unsigned int>(_framecount % UINT_MAX));
break;
case special_uniform::random: {
const int min = variable.annotation_as_int("min");
const int max = variable.annotation_as_int("max");
set_uniform_value(variable, min + (std::rand() % (max - min + 1)));
break; }
case special_uniform::ping_pong: {
const float min = variable.annotation_as_float("min");
const float max = variable.annotation_as_float("max");
const float step_min = variable.annotation_as_float("step", 0);
const float step_max = variable.annotation_as_float("step", 1);
float increment = step_max == 0 ? step_min : (step_min + std::fmodf(static_cast<float>(std::rand()), step_max - step_min + 1));
const float smoothing = variable.annotation_as_float("smoothing");
float value[2] = { 0, 0 };
get_uniform_value(variable, value, 2);
if (value[1] >= 0)
{
increment = std::max(increment - std::max(0.0f, smoothing - (max - value[0])), 0.05f);
increment *= _last_frame_duration.count() * 1e-9f;
if ((value[0] += increment) >= max)
value[0] = max, value[1] = -1;
}
else
{
increment = std::max(increment - std::max(0.0f, smoothing - (value[0] - min)), 0.05f);
increment *= _last_frame_duration.count() * 1e-9f;
if ((value[0] -= increment) <= min)
value[0] = min, value[1] = +1;
}
set_uniform_value(variable, value, 2);
break; }
case special_uniform::date:
set_uniform_value(variable, _date, 4);
break;
case special_uniform::timer:
set_uniform_value(variable, static_cast<unsigned int>(std::chrono::duration_cast<std::chrono::milliseconds>(_last_present_time - _start_time).count()));
break;
case special_uniform::key:
if (const int keycode = variable.annotation_as_int("keycode");
keycode > 7 && keycode < 256)
if (const std::string_view mode = variable.annotation_as_string("mode");
mode == "toggle" || variable.annotation_as_int("toggle")) {
bool current_value = false;
get_uniform_value(variable, ¤t_value, 1);
if (_input->is_key_pressed(keycode))
set_uniform_value(variable, !current_value);
} else if (mode == "press")
set_uniform_value(variable, _input->is_key_pressed(keycode));
else
set_uniform_value(variable, _input->is_key_down(keycode));
break;
case special_uniform::mouse_point:
set_uniform_value(variable, _input->mouse_position_x(), _input->mouse_position_y());
break;
case special_uniform::mouse_delta:
set_uniform_value(variable, _input->mouse_movement_delta_x(), _input->mouse_movement_delta_y());
break;
case special_uniform::mouse_button:
if (const int keycode = variable.annotation_as_int("keycode");
keycode >= 0 && keycode < 5)
if (const std::string_view mode = variable.annotation_as_string("mode");
mode == "toggle" || variable.annotation_as_int("toggle")) {
bool current_value = false;
get_uniform_value(variable, ¤t_value, 1);
if (_input->is_mouse_button_pressed(keycode))
set_uniform_value(variable, !current_value);
} else if (mode == "press")
set_uniform_value(variable, _input->is_mouse_button_pressed(keycode));
else
set_uniform_value(variable, _input->is_mouse_button_down(keycode));
break;
}
}
// Render all enabled techniques
for (technique &technique : _techniques)
{
if (technique.timeleft > 0)
{
technique.timeleft -= std::chrono::duration_cast<std::chrono::milliseconds>(_last_frame_duration).count();
if (technique.timeleft <= 0)
disable_technique(technique);
}
else if (!_ignore_shortcuts && (_input->is_key_pressed(technique.toggle_key_data) ||
(technique.toggle_key_data[0] >= 0x01 && technique.toggle_key_data[0] <= 0x06 && _input->is_mouse_button_pressed(technique.toggle_key_data[0] - 1))))
{
if (!technique.enabled)
enable_technique(technique);
else
disable_technique(technique);
}
if (technique.impl == nullptr || !technique.enabled)
continue; // Ignore techniques that are not fully loaded or currently disabled
const auto time_technique_started = std::chrono::high_resolution_clock::now();
render_technique(technique);
const auto time_technique_finished = std::chrono::high_resolution_clock::now();
technique.average_cpu_duration.append(std::chrono::duration_cast<std::chrono::nanoseconds>(time_technique_finished - time_technique_started).count());
}
if (_should_save_screenshot)
{
save_screenshot(std::wstring(), true);
_should_save_screenshot = false;
}
}
void reshade::runtime::enable_technique(technique &technique)
{
if (!_loaded_effects[technique.effect_index].compile_sucess)
return; // Cannot enable techniques that failed to compile
const bool status_changed = !technique.enabled;
technique.enabled = true;
technique.timeleft = technique.timeout;
// Queue effect file for compilation if it was not fully loaded yet
if (technique.impl == nullptr && // Avoid adding the same effect multiple times to the queue if it contains multiple techniques that were enabled simultaneously
std::find(_reload_compile_queue.begin(), _reload_compile_queue.end(), technique.effect_index) == _reload_compile_queue.end())
{
_reload_total_effects++;
_reload_compile_queue.push_back(technique.effect_index);
}
if (status_changed) // Increase rendering reference count
_loaded_effects[technique.effect_index].rendering++;
}
void reshade::runtime::disable_technique(technique &technique)
{
const bool status_changed = technique.enabled;
technique.enabled = false;
technique.timeleft = 0;
technique.average_cpu_duration.clear();
technique.average_gpu_duration.clear();
if (status_changed) // Decrease rendering reference count
_loaded_effects[technique.effect_index].rendering--;
}
void reshade::runtime::subscribe_to_load_config(std::function<void(const ini_file &)> function)
{
_load_config_callables.push_back(function);
function(ini_file::load_cache(_configuration_path));
}
void reshade::runtime::subscribe_to_save_config(std::function<void(ini_file &)> function)
{
_save_config_callables.push_back(function);
function(ini_file::load_cache(_configuration_path));
}
void reshade::runtime::load_config()
{
const ini_file &config = ini_file::load_cache(_configuration_path);
std::filesystem::path current_preset_path;
config.get("INPUT", "KeyReload", _reload_key_data);
config.get("INPUT", "KeyEffects", _effects_key_data);
config.get("INPUT", "KeyScreenshot", _screenshot_key_data);
config.get("INPUT", "KeyPreviousPreset", _previous_preset_key_data);
config.get("INPUT", "KeyNextPreset", _next_preset_key_data);
config.get("INPUT", "PresetTransitionDelay", _preset_transition_delay);
config.get("GENERAL", "PerformanceMode", _performance_mode);
config.get("GENERAL", "EffectSearchPaths", _effect_search_paths);
config.get("GENERAL", "TextureSearchPaths", _texture_search_paths);
config.get("GENERAL", "PreprocessorDefinitions", _global_preprocessor_definitions);
config.get("GENERAL", "CurrentPresetPath", current_preset_path);
config.get("GENERAL", "ScreenshotPath", _screenshot_path);
config.get("GENERAL", "ScreenshotFormat", _screenshot_format);
config.get("GENERAL", "ScreenshotIncludePreset", _screenshot_include_preset);
config.get("GENERAL", "ScreenshotSaveBefore", _screenshot_save_before);
config.get("GENERAL", "NoReloadOnInit", _no_reload_on_init);
if (current_preset_path.empty())
{
// Convert legacy preset index to new preset path
size_t preset_index = 0;
std::vector<std::filesystem::path> preset_files;
config.get("GENERAL", "PresetFiles", preset_files);
config.get("GENERAL", "CurrentPreset", preset_index);
if (preset_index < preset_files.size())
current_preset_path = preset_files[preset_index];
}
if (check_preset_path(current_preset_path))
_current_preset_path = g_reshade_dll_path.parent_path() / current_preset_path;
else // Select a default preset file if none exists yet
_current_preset_path = g_reshade_dll_path.parent_path() / L"DefaultPreset.ini";
for (const auto &callback : _load_config_callables)
callback(config);
}
void reshade::runtime::save_config() const
{
ini_file &config = ini_file::load_cache(_configuration_path);
config.set("INPUT", "KeyReload", _reload_key_data);
config.set("INPUT", "KeyEffects", _effects_key_data);
config.set("INPUT", "KeyScreenshot", _screenshot_key_data);
config.set("INPUT", "KeyPreviousPreset", _previous_preset_key_data);
config.set("INPUT", "KeyNextPreset", _next_preset_key_data);
config.set("INPUT", "PresetTransitionDelay", _preset_transition_delay);
config.set("GENERAL", "PerformanceMode", _performance_mode);
config.set("GENERAL", "EffectSearchPaths", _effect_search_paths);
config.set("GENERAL", "TextureSearchPaths", _texture_search_paths);
config.set("GENERAL", "PreprocessorDefinitions", _global_preprocessor_definitions);
config.set("GENERAL", "CurrentPresetPath", _current_preset_path);
config.set("GENERAL", "ScreenshotPath", _screenshot_path);
config.set("GENERAL", "ScreenshotFormat", _screenshot_format);
config.set("GENERAL", "ScreenshotIncludePreset", _screenshot_include_preset);
config.set("GENERAL", "ScreenshotSaveBefore", _screenshot_save_before);
config.set("GENERAL", "NoReloadOnInit", _no_reload_on_init);
for (const auto &callback : _save_config_callables)
callback(config);
}
void reshade::runtime::load_current_preset()
{
const reshade::ini_file &preset = ini_file::load_cache(_current_preset_path);
std::vector<std::string> technique_list;
preset.get({}, "Techniques", technique_list);
std::vector<std::string> sorted_technique_list;
preset.get({}, "TechniqueSorting", sorted_technique_list);
std::vector<std::string> preset_preprocessor_definitions;
preset.get({}, "PreprocessorDefinitions", preset_preprocessor_definitions);
// Recompile effects if preprocessor definitions have changed or running in performance mode (in which case all preset values are compile-time constants)
if (_reload_remaining_effects != 0 && // ... unless this is the 'load_current_preset' call in 'update_and_render_effects'
(_performance_mode || preset_preprocessor_definitions != _preset_preprocessor_definitions))
{
_preset_preprocessor_definitions = std::move(preset_preprocessor_definitions);
load_effects();
return; // Preset values are loaded in 'update_and_render_effects' during effect loading
}
// Reorder techniques
if (sorted_technique_list.empty())
sorted_technique_list = technique_list;
std::sort(_techniques.begin(), _techniques.end(),
[&sorted_technique_list](const auto &lhs, const auto &rhs) {
return (std::find(sorted_technique_list.begin(), sorted_technique_list.end(), lhs.name) - sorted_technique_list.begin()) <
(std::find(sorted_technique_list.begin(), sorted_technique_list.end(), rhs.name) - sorted_technique_list.begin());
});
// Compute times since the transition has started and how much is left till it should end
auto transition_time = std::chrono::duration_cast<std::chrono::microseconds>(_last_present_time - _last_preset_switching_time).count();
auto transition_ms_left = _preset_transition_delay - transition_time / 1000;
auto transition_ms_left_from_last_frame = transition_ms_left + std::chrono::duration_cast<std::chrono::microseconds>(_last_frame_duration).count() / 1000;
if (_is_in_between_presets_transition && transition_ms_left <= 0)
_is_in_between_presets_transition = false;
for (uniform &variable : _uniforms)
{
const std::string section = _loaded_effects[variable.effect_index].source_file.filename().u8string();
reshadefx::constant values, values_old;
if (variable.supports_toggle_key())
{
// Load shortcut key, but first reset it, since it may not exist in the preset file
memset(variable.toggle_key_data, 0, sizeof(variable.toggle_key_data));
preset.get(section, "Key" + variable.name, variable.toggle_key_data);
}
switch (variable.type.base)
{
case reshadefx::type::t_int:
get_uniform_value(variable, values.as_int, 16);
preset.get(section, variable.name, values.as_int);
set_uniform_value(variable, values.as_int, 16);
break;
case reshadefx::type::t_bool:
case reshadefx::type::t_uint:
get_uniform_value(variable, values.as_uint, 16);
preset.get(section, variable.name, values.as_uint);
set_uniform_value(variable, values.as_uint, 16);
break;
case reshadefx::type::t_float:
get_uniform_value(variable, values.as_float, 16);
values_old = values;
preset.get(section, variable.name, values.as_float);
if (_is_in_between_presets_transition)
{
// Perform smooth transition on floating point values
for (unsigned int i = 0; i < 16; i++)
{
const auto transition_ratio = (values.as_float[i] - values_old.as_float[i]) / transition_ms_left_from_last_frame;
values.as_float[i] = values.as_float[i] - transition_ratio * transition_ms_left;
}
}
set_uniform_value(variable, values.as_float, 16);
break;
}
}
for (technique &technique : _techniques)
{
// Ignore preset if "enabled" annotation is set
if (technique.annotation_as_int("enabled")
|| std::find(technique_list.begin(), technique_list.end(), technique.name) != technique_list.end())
enable_technique(technique);
else
disable_technique(technique);
// Reset toggle key first, since it may not exist in the preset
memset(technique.toggle_key_data, 0, sizeof(technique.toggle_key_data));
preset.get({}, "Key" + technique.name, technique.toggle_key_data);
}
}
void reshade::runtime::save_current_preset() const
{
reshade::ini_file &preset = ini_file::load_cache(_current_preset_path);
// Build list of active techniques and effects
std::vector<size_t> effect_list;
std::vector<std::string> technique_list;
std::vector<std::string> sorted_technique_list;
effect_list.reserve(_techniques.size());
technique_list.reserve(_techniques.size());
sorted_technique_list.reserve(_techniques.size());
for (const technique &technique : _techniques)
{
if (technique.enabled)
technique_list.push_back(technique.name);
if (technique.enabled || technique.toggle_key_data[0] != 0)
effect_list.push_back(technique.effect_index);
// Keep track of the order of all techniques and not just the enabled ones
sorted_technique_list.push_back(technique.name);
if (technique.toggle_key_data[0] != 0)
preset.set({}, "Key" + technique.name, technique.toggle_key_data);
else if (int value = 0; preset.get({}, "Key" + technique.name, value), value != 0)
preset.set({}, "Key" + technique.name, 0); // Clear toggle key data
}
preset.set({}, "Techniques", std::move(technique_list));
preset.set({}, "TechniqueSorting", std::move(sorted_technique_list));
preset.set({}, "PreprocessorDefinitions", _preset_preprocessor_definitions);
// TODO: Do we want to save spec constants here too? The preset will be rather empty in performance mode otherwise.
for (const uniform &variable : _uniforms)
{
if (variable.special != special_uniform::none
|| std::find(effect_list.begin(), effect_list.end(), variable.effect_index) == effect_list.end())
continue;
assert(variable.type.components() <= 16);
const std::string section = _loaded_effects[variable.effect_index].source_file.filename().u8string();
reshadefx::constant values;
if (variable.supports_toggle_key())
{
// save the shortcut key into the preset files
if (variable.toggle_key_data[0] != 0)
preset.set(section, "Key" + variable.name, variable.toggle_key_data);
else if (int value = 0; preset.get(section, "Key" + variable.name, value), value != 0)
preset.set(section, "Key" + variable.name, 0); // Clear toggle key data
}
switch (variable.type.base)
{
case reshadefx::type::t_int:
get_uniform_value(variable, values.as_int, 16);
preset.set(section, variable.name, values.as_int, variable.type.components());
break;
case reshadefx::type::t_bool:
case reshadefx::type::t_uint:
get_uniform_value(variable, values.as_uint, 16);
preset.set(section, variable.name, values.as_uint, variable.type.components());
break;
case reshadefx::type::t_float:
get_uniform_value(variable, values.as_float, 16);
preset.set(section, variable.name, values.as_float, variable.type.components());
break;
}
}
}
bool reshade::runtime::switch_to_next_preset(const std::filesystem::path &filter_path, bool reversed)
{
std::error_code ec; // This is here to ignore file system errors below
std::filesystem::path filter_text = filter_path.filename();
std::filesystem::path search_path = absolute_path(filter_path);
if (std::filesystem::is_directory(search_path, ec))
filter_text.clear();
else if (!filter_text.empty())
search_path = search_path.parent_path();
size_t current_preset_index = std::numeric_limits<size_t>::max();
std::vector<std::filesystem::path> preset_paths;
for (const auto &entry : std::filesystem::directory_iterator(search_path, std::filesystem::directory_options::skip_permission_denied, ec))
{
// Skip anything that is not a valid preset file
if (!check_preset_path(entry.path()))
continue;
// Keep track of the index of the current preset in the list of found preset files that is being build
if (std::filesystem::equivalent(entry, _current_preset_path, ec)) {
current_preset_index = preset_paths.size();
preset_paths.push_back(entry);
continue;
}
const std::wstring preset_name = entry.path().stem();
// Only add those files that are matching the filter text
if (filter_text.empty() || std::search(preset_name.begin(), preset_name.end(), filter_text.native().begin(), filter_text.native().end(),
[](wchar_t c1, wchar_t c2) { return towlower(c1) == towlower(c2); }) != preset_name.end())
preset_paths.push_back(entry);
}
if (preset_paths.begin() == preset_paths.end())
return false; // No valid preset files were found, so nothing more to do
if (current_preset_index == std::numeric_limits<size_t>::max())
{
// Current preset was not in the container path, so just use the first or last file
if (reversed)
_current_preset_path = preset_paths.back();
else
_current_preset_path = preset_paths.front();
}
else
{
// Current preset was found in the container path, so use the file before or after it
if (auto it = std::next(preset_paths.begin(), current_preset_index); reversed)
_current_preset_path = it == preset_paths.begin() ? preset_paths.back() : *--it;
else
_current_preset_path = it == std::prev(preset_paths.end()) ? preset_paths.front() : *++it;
}
return true;
}
void reshade::runtime::save_screenshot(const std::wstring &postfix, const bool should_save_preset)
{
const int hour = _date[3] / 3600;
const int minute = (_date[3] - hour * 3600) / 60;
const int seconds = _date[3] - hour * 3600 - minute * 60;
char filename[21];
sprintf_s(filename, " %.4d-%.2d-%.2d %.2d-%.2d-%.2d", _date[0], _date[1], _date[2], hour, minute, seconds);
const std::wstring least = (_screenshot_path.is_relative() ? g_target_executable_path.parent_path() / _screenshot_path : _screenshot_path) / g_target_executable_path.stem().concat(filename);
const std::wstring screenshot_path = least + postfix + (_screenshot_format == 0 ? L".bmp" : L".png");
LOG(INFO) << "Saving screenshot to " << screenshot_path << " ...";
_screenshot_save_success = false; // Default to a save failure unless it is reported to succeed below
if (std::vector<uint8_t> data(_width * _height * 4); capture_screenshot(data.data()))
{
if (FILE *file; _wfopen_s(&file, screenshot_path.c_str(), L"wb") == 0)
{
const auto write_callback = [](void *context, void *data, int size) {
fwrite(data, 1, size, static_cast<FILE *>(context));
};
switch (_screenshot_format)
{
case 0:
_screenshot_save_success = stbi_write_bmp_to_func(write_callback, file, _width, _height, 4, data.data()) != 0;
break;
case 1:
_screenshot_save_success = stbi_write_png_to_func(write_callback, file, _width, _height, 4, data.data(), 0) != 0;
break;
}
fclose(file);
}
}
_last_screenshot_file = screenshot_path;
_last_screenshot_time = std::chrono::high_resolution_clock::now();
if (!_screenshot_save_success)
{
LOG(ERROR) << "Failed to write screenshot to " << screenshot_path << '!';
}
else if (_screenshot_include_preset && should_save_preset && ini_file::flush_cache(_current_preset_path))
{
// Preset was flushed to disk, so can just copy it over to the new location
std::error_code ec; std::filesystem::copy_file(_current_preset_path, least + L".ini", std::filesystem::copy_options::overwrite_existing, ec);
}
}
void reshade::runtime::get_uniform_value(const uniform &variable, uint8_t *data, size_t size) const
{
assert(data != nullptr);
size = std::min(size, size_t(variable.size));
assert(variable.storage_offset + size <= _uniform_data_storage.size());
std::memcpy(data, &_uniform_data_storage[variable.storage_offset], size);
}
void reshade::runtime::get_uniform_value(const uniform &variable, bool *values, size_t count) const
{
count = std::min(count, size_t(variable.size / 4));
assert(values != nullptr);
const auto data = static_cast<uint8_t *>(alloca(variable.size));
get_uniform_value(variable, data, variable.size);
for (size_t i = 0; i < count; i++)
values[i] = reinterpret_cast<const uint32_t *>(data)[i] != 0;
}
void reshade::runtime::get_uniform_value(const uniform &variable, int32_t *values, size_t count) const
{
if (!variable.type.is_floating_point() && _renderer_id != 0x9000)
{
get_uniform_value(variable, reinterpret_cast<uint8_t *>(values), count * sizeof(int32_t));
return;
}
count = std::min(count, variable.size / sizeof(float));
assert(values != nullptr);
const auto data = static_cast<uint8_t *>(alloca(variable.size));
get_uniform_value(variable, data, variable.size);
for (size_t i = 0; i < count; i++)
values[i] = static_cast<int32_t>(reinterpret_cast<const float *>(data)[i]);
}
void reshade::runtime::get_uniform_value(const uniform &variable, uint32_t *values, size_t count) const
{
get_uniform_value(variable, reinterpret_cast<int32_t *>(values), count);
}
void reshade::runtime::get_uniform_value(const uniform &variable, float *values, size_t count) const
{
if (variable.type.is_floating_point() || _renderer_id == 0x9000)
{
get_uniform_value(variable, reinterpret_cast<uint8_t *>(values), count * sizeof(float));
return;
}
count = std::min(count, variable.size / sizeof(int32_t));
assert(values != nullptr);
const auto data = static_cast<uint8_t *>(alloca(variable.size));
get_uniform_value(variable, data, variable.size);
for (size_t i = 0; i < count; ++i)
if (variable.type.is_signed())
values[i] = static_cast<float>(reinterpret_cast<const int32_t *>(data)[i]);
else
values[i] = static_cast<float>(reinterpret_cast<const uint32_t *>(data)[i]);
}
void reshade::runtime::set_uniform_value(uniform &variable, const uint8_t *data, size_t size)
{
assert(data != nullptr);
size = std::min(size, size_t(variable.size));
assert(variable.storage_offset + size <= _uniform_data_storage.size());
std::memcpy(&_uniform_data_storage[variable.storage_offset], data, size);
}
void reshade::runtime::set_uniform_value(uniform &variable, const bool *values, size_t count)
{
const auto data = static_cast<uint8_t *>(alloca(count * 4));
switch (_renderer_id != 0x9000 ? variable.type.base : reshadefx::type::t_float)
{
case reshadefx::type::t_bool:
for (size_t i = 0; i < count; ++i)
reinterpret_cast<int32_t *>(data)[i] = values[i] ? -1 : 0;
break;
case reshadefx::type::t_int:
case reshadefx::type::t_uint:
for (size_t i = 0; i < count; ++i)
reinterpret_cast<int32_t *>(data)[i] = values[i] ? 1 : 0;
break;
case reshadefx::type::t_float:
for (size_t i = 0; i < count; ++i)
reinterpret_cast<float *>(data)[i] = values[i] ? 1.0f : 0.0f;
break;
}
set_uniform_value(variable, data, count * 4);
}
void reshade::runtime::set_uniform_value(uniform &variable, const int32_t *values, size_t count)
{
if (!variable.type.is_floating_point() && _renderer_id != 0x9000)
{
set_uniform_value(variable, reinterpret_cast<const uint8_t *>(values), count * sizeof(int));
return;
}
const auto data = static_cast<float *>(alloca(count * sizeof(float)));
for (size_t i = 0; i < count; ++i)
data[i] = static_cast<float>(values[i]);
set_uniform_value(variable, reinterpret_cast<const uint8_t *>(data), count * sizeof(float));
}
void reshade::runtime::set_uniform_value(uniform &variable, const uint32_t *values, size_t count)
{
if (!variable.type.is_floating_point() && _renderer_id != 0x9000)
{
set_uniform_value(variable, reinterpret_cast<const uint8_t *>(values), count * sizeof(int));
return;
}
const auto data = static_cast<float *>(alloca(count * sizeof(float)));
for (size_t i = 0; i < count; ++i)
data[i] = static_cast<float>(values[i]);
set_uniform_value(variable, reinterpret_cast<const uint8_t *>(data), count * sizeof(float));
}
void reshade::runtime::set_uniform_value(uniform &variable, const float *values, size_t count)
{
if (variable.type.is_floating_point() || _renderer_id == 0x9000)
{
set_uniform_value(variable, reinterpret_cast<const uint8_t *>(values), count * sizeof(float));
return;
}
const auto data = static_cast<int32_t *>(alloca(count * sizeof(int32_t)));
for (size_t i = 0; i < count; ++i)
data[i] = static_cast<int32_t>(values[i]);
set_uniform_value(variable, reinterpret_cast<const uint8_t *>(data), count * sizeof(int32_t));
}
void reshade::runtime::reset_uniform_value(uniform &variable)
{
if (!variable.has_initializer_value)
{
memset(_uniform_data_storage.data() + variable.storage_offset, 0, variable.size);
return;
}
if (_renderer_id == 0x9000)
{
// Force all uniforms to floating-point in D3D9
for (size_t i = 0; i < variable.size / sizeof(float); i++)
{
switch (variable.type.base)
{
case reshadefx::type::t_int:
reinterpret_cast<float *>(_uniform_data_storage.data() + variable.storage_offset)[i] = static_cast<float>(variable.initializer_value.as_int[i]);
break;
case reshadefx::type::t_bool:
case reshadefx::type::t_uint:
reinterpret_cast<float *>(_uniform_data_storage.data() + variable.storage_offset)[i] = static_cast<float>(variable.initializer_value.as_uint[i]);
break;
case reshadefx::type::t_float:
reinterpret_cast<float *>(_uniform_data_storage.data() + variable.storage_offset)[i] = variable.initializer_value.as_float[i];
break;
}
}
}
else
{
memcpy(_uniform_data_storage.data() + variable.storage_offset, variable.initializer_value.as_uint, variable.size);
}
}
|
[
"crosiredev@gmail.com"
] |
crosiredev@gmail.com
|
4d8e3c773b3f3daf4bb1160f7baa7ab553e2028d
|
b4393b82bcccc59e2b89636f1fde16d82f060736
|
/devtools/lit/lib/ShellCommands.h
|
1897c46237d9a18f1a13cf10caa55e45e32e2894
|
[] |
no_license
|
phpmvc/polarphp
|
abb63ed491a0175aa43c873b1b39811f4eb070a2
|
eb0b406e515dd550fd99b9383d4b2952fed0bfa9
|
refs/heads/master
| 2020-04-08T06:51:03.842159
| 2018-11-23T06:32:04
| 2018-11-23T06:32:04
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,941
|
h
|
// This source file is part of the polarphp.org open source project
//
// Copyright (c) 2017 - 2018 polarphp software foundation
// Copyright (c) 2017 - 2018 zzu_softboy <zzu_softboy@163.com>
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://polarphp.org/LICENSE.txt for license information
// See http://polarphp.org/CONTRIBUTORS.txt for the list of polarphp project authors
//
// Created by polarboy on 2018/09/04.
#ifndef POLAR_DEVLTOOLS_LIT_SHELL_COMMANDS_H
#define POLAR_DEVLTOOLS_LIT_SHELL_COMMANDS_H
#include <list>
#include <string>
#include <any>
#include <memory>
#include <assert.h>
#include "LitGlobal.h"
#include "ForwardDefs.h"
namespace polar {
namespace lit {
using RedirectTokenType = std::tuple<ShellTokenType, std::string>;
class AbstractCommand
{
public:
enum class Type {
Command,
Pipeline,
Seq
};
public:
virtual void toShell(std::string &str, bool pipeFail = false) const = 0;
virtual operator std::string() = 0;
virtual Type getCommandType() = 0;
};
class Command : public AbstractCommand
{
public:
Command(const std::list<std::any> &args, const std::list<RedirectTokenType > &redirects)
: m_args(args),
m_redirects(redirects)
{}
operator std::string() override;
bool operator ==(const Command &other) const;
std::list<std::any> &getArgs();
const std::list<RedirectTokenType > &getRedirects();
void toShell(std::string &str, bool pipeFail = false) const override;
Type getCommandType() override
{
return Type::Command;
}
private:
bool compareTokenAny(const std::any &lhs, const std::any &rhs) const;
protected:
// GlobItem or std::tuple<std::string, int>
std::list<std::any> m_args;
std::list<RedirectTokenType> m_redirects;
};
class GlobItem
{
public:
GlobItem(const std::string &pattern)
: m_pattern(pattern)
{}
std::list<std::string> resolve(const std::string &cwd) const;
operator std::string();
bool operator ==(const GlobItem &other) const;
bool operator !=(const GlobItem &other) const
{
return !operator ==(other);
}
protected:
std::string m_pattern;
};
class Pipeline : public AbstractCommand
{
public:
Pipeline(const std::list<std::shared_ptr<AbstractCommand>> &commands, bool negate = false, bool pipeError = false)
: m_commands(commands),
m_negate(negate),
m_pipeError(pipeError)
{
}
operator std::string() override;
bool isNegate();
bool isPipeError();
bool operator ==(const Pipeline &other) const;
bool operator !=(const Pipeline &other) const
{
return !operator ==(other);
}
void toShell(std::string &str, bool pipeFail = false) const override;
Type getCommandType() override
{
return Type::Pipeline;
}
const CommandList &getCommands() const;
protected:
CommandList m_commands;
bool m_negate;
bool m_pipeError;
};
class Seq : public AbstractCommand
{
public:
Seq(std::shared_ptr<AbstractCommand> lhs, const std::string &op, std::shared_ptr<AbstractCommand> rhs)
: m_op(op),
m_lhs(lhs),
m_rhs(rhs)
{
assert(op.find(';') != std::string::npos ||
op.find('&') != std::string::npos ||
op.find("||") != std::string::npos ||
op.find("&&") != std::string::npos);
}
operator std::string() override;
bool operator ==(const Seq &other) const;
bool operator !=(const Seq &other) const
{
return !operator ==(other);
}
Type getCommandType() override
{
return Type::Seq;
}
const std::string &getOp() const;
AbstractCommandPointer getLhs() const;
AbstractCommandPointer getRhs() const;
void toShell(std::string &str, bool pipeFail = false) const override;
protected:
std::string m_op;
AbstractCommandPointer m_lhs;
AbstractCommandPointer m_rhs;
};
} // lit
} // polar
#endif // POLAR_DEVLTOOLS_LIT_SHELL_COMMANDS_H
|
[
"zzu_softboy@163.com"
] |
zzu_softboy@163.com
|
013a75ea9c06b05e0367c8d33f1d5eb526afd572
|
485e1d6bd46195b77c3d3095ea0f7a9bf2a63594
|
/.localhistory/F/school/year4/courses/DBpractice/pagination/pagination/pagination/1602667412$memory.cpp
|
0e99f77d784d040d5b2b40dbea43c95d70e35138
|
[] |
no_license
|
ZESl/pagination
|
67ceaa2ecfaf985034d5d57d5fbe1268e23b2031
|
e1fc369dc16c40baead903ab51512d5ea1a85ed3
|
refs/heads/master
| 2022-12-28T17:46:45.338565
| 2020-10-14T12:59:33
| 2020-10-14T12:59:33
| 304,015,976
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,916
|
cpp
|
๏ปฟ#include "memory.h"
#include <iostream>
#include <fstream>
using namespace std;
memory::memory()
{
m_pMemory = (MemBlock *)malloc(MEM_NUM * sizeof(MemBlock));
memset(m_anStack, -1, MEM_NUM * sizeof(int));
stackTop = -1;
}
memory::~memory()
{
}
// 1. read the file
// 2. page the file according to the file size, 4*1024 bytes per page
// 3. generate the page table index information.
int memory::LoadFile(QString fileName)
{
// 1. read the file
qDebug() << "opening file" << fileName << endl;
QFile myfile(fileName);
if (myfile.open(QFile::ReadOnly | QIODevice::Text)) {
txtFileName = fileName;
// 2. page the file according to the file size, 4*1024 bytes per page
int size = myfile.size();
qDebug() << "size:" << QString::number(size) << endl;
if (size % PAGE_SIZE != 0) {
pageNum = size / PAGE_SIZE + 1;
}
else {
pageNum = size / PAGE_SIZE;
}
m_pPageTable = NULL;
m_pPageTable = (PageItem *)malloc(pageNum * sizeof(PageItem));
// 3. generate the page table index information.
for (int i = 0; i < pageNum; i++) {
PageItem tmp = { i, false, false, (ULONGLONG)i*PAGE_SIZE, -1 };
m_pPageTable[i] = tmp;
}
return pageNum;
}
else {
return 0;
}
}
char* memory::ReadPage(const int pageno)
{
PushStack(pageno);
if (m_pPageTable[pageno].load) {
int memno = m_pPageTable[pageno].memno;
//char* pStr = (char*)malloc(PAGE_SIZE);
char pStr[PAGE_SIZE];
memcpy(pStr, m_pMemory[memno].content, PAGE_SIZE);
qDebug() << "FROM MEMORY";
//qDebug() << pStr << endl;
return pStr;
}
else {
m_pPageTable[pageno].load = true;
string str = txtFileName.toStdString();
const char* name = str.c_str();
char pStr[PAGE_SIZE];
FILE* pfile = nullptr;
fopen_s(&pfile, name, "rb");
fseek(pfile, m_pPageTable[pageno].position, SEEK_SET);
fread(pStr, 1, PAGE_SIZE, pfile);
fclose(pfile);
int memno = m_pPageTable[pageno].memno;
m_pMemory[memno].no = memno;
memcpy(m_pMemory[memno].content, pStr, PAGE_SIZE);
qDebug() << "FROM FILE";
//qDebug() << pStr << endl;
return pStr;
}
}
bool memory::UpdatePage(const int pageno, string str, const int nMaxSize)
{
// Query whether this page has existed in the current memory block.
// If it has existed, update the content in the memory block, and set the modification identifier as true.
// If it does not exist, load this page.
bool exist = false;
for (int i = 0; i < MEM_NUM; i++) {
if (pageno == m_anStack[i]) {
exist = true;
}
}
// search whether this page number has existed in the stack
if (exist) {
// fill in the blank
int len = str.length();
qDebug() << "len" << len <<endl;
if (len < PAGE_SIZE) {
for (int b = len; b <= PAGE_SIZE; b++) {
str += " ";
}
}
str += '\0';
m_pPageTable[pageno].modify = true;
int no = m_pPageTable[pageno].memno;
const char* pStr = str.c_str();
memcpy(m_pMemory[no].content, pStr, PAGE_SIZE);
}
/*else {
ReadPage(pageno, pStr, nMaxSize);
}*/
return true;
}
void memory::addPage()
{
// When a new page is added, allocate the memory space for the page table again
pageNum++;
m_pPageTable = (PageItem *)realloc(m_pPageTable, pageNum * sizeof(PageItem));
PageItem tmp = { pageNum-1, true, true, (pageNum-1)*PAGE_SIZE, -1 };
m_pPageTable[pageNum - 1] = tmp;
string text = "";
for (int g = 0; g < PAGE_SIZE; g++) {
text = text + " ";
}
text = text + '\0';
const char* str = text.c_str();
FILE* pfile = nullptr;
string name = txtFileName.toStdString();
const char* fileName = name.c_str();
// ๅจๆไปถๆๅ่ฟฝๅ
fopen_s(&pfile, fileName, "ab+");
fprintf_s(pfile, str);
fclose(pfile);
}
void memory::WriteBack()
{
// When the window is logged out, write back all records in the page table.
// traverse the whole page table, find the modified page in the memory, and write back into the file.
FILE* pfile = nullptr;
FILE* temp = nullptr;
string str = txtFileName.toStdString();
const char* fileName = str.c_str();
fopen_s(&pfile, fileName, "rb");
fopen_s(&temp, "temp.txt", "wb");
for (int i = 0; i < pageNum; i++) {
if (m_pPageTable[i].modify) {
int memno = m_pPageTable[i].memno;
// writeback the memory
fwrite(m_pMemory[memno].content, 1, PAGE_SIZE, temp);
m_pPageTable[i].modify = false;
}
else {
// writeback the original file
char* pStr = NULL;
pStr = (char *)malloc(PAGE_SIZE * sizeof(char));
fseek(pfile, m_pPageTable[i].position, SEEK_SET);
fread(pStr, 1, PAGE_SIZE, pfile);
fwrite(pStr, 1, PAGE_SIZE, temp);
}
}
fclose(pfile);
fclose(temp);
remove("Little Prince.txt");
rename("temp.txt", "Little Prince.txt");
}
int memory::GetPageNum()
{
return pageNum;
}
int memory::QueryMemory(const int pageno)
{
return m_pPageTable[pageno].memno;
}
void memory::PushStack(const int pageno)
{
bool exist = false;
for (int i = 0; i < MEM_NUM; i++) {
if (pageno == m_anStack[i]) {
exist = true;
}
}
// search whether this page number has existed in the stack
if (exist) {
// move this page number to the stack top
for (int i = 0; i < MEM_NUM; i++) {
if (pageno == m_anStack[i]) {
for (int j = i; j < stackTop; j++) {
m_anStack[j] = m_anStack[j + 1];
}
m_anStack[stackTop] = pageno;
break;
}
}
}
else {
// If it does not exist, add it.
if (stackTop == MEM_NUM - 1) {
// If the stack has been full, move out the element of the stack bottom
// and put this number on the stack top.
m_pPageTable[m_anStack[0]].modify = false;
m_pPageTable[m_anStack[0]].load = false;
m_pPageTable[pageno].memno = m_pPageTable[m_anStack[0]].memno; // replace
m_pPageTable[m_anStack[0]].memno = -1;
for (int j = 0; j < MEM_NUM - 1; j++) {
m_anStack[j] = m_anStack[j + 1];
}
m_anStack[MEM_NUM - 1] = pageno;
}
else {
stackTop++;
m_anStack[stackTop] = pageno;
m_pPageTable[pageno].memno = stackTop;
}
}
}
int memory::PopStack()
{
return m_anStack[0];
}
|
[
"823989065@qq.com"
] |
823989065@qq.com
|
c654d7e6f809feeb20527fa19e99e3b63e66b264
|
37cca16f12e7b1d4d01d6f234da6d568c318abee
|
/src/org/mpisws/p2p/testing/filetransfer/ProfileFileTest_main_2_incomingSocket_2_1.hpp
|
f723c905be7e791debcd53a2ce7565e21dcb685f
|
[] |
no_license
|
subhash1-0/thirstyCrow
|
e48155ce68fc886f2ee8e7802567c1149bc54206
|
78b7e4e3d2b9a9530ad7d66b44eacfe73ceea582
|
refs/heads/master
| 2016-09-06T21:25:54.075724
| 2015-09-21T17:21:15
| 2015-09-21T17:21:15
| 42,881,521
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,691
|
hpp
|
// Generated from /pastry-2.1/src/org/mpisws/p2p/testing/filetransfer/ProfileFileTest.java
#pragma once
#include <java/io/fwd-pastry-2.1.hpp>
#include <java/lang/fwd-pastry-2.1.hpp>
#include <java/nio/fwd-pastry-2.1.hpp>
#include <org/mpisws/p2p/testing/filetransfer/fwd-pastry-2.1.hpp>
#include <rice/environment/logging/fwd-pastry-2.1.hpp>
#include <java/lang/Object.hpp>
#include <org/mpisws/p2p/filetransfer/FileTransferCallback.hpp>
struct default_init_tag;
class org::mpisws::p2p::testing::filetransfer::ProfileFileTest_main_2_incomingSocket_2_1
: public virtual ::java::lang::Object
, public virtual ::org::mpisws::p2p::filetransfer::FileTransferCallback
{
public:
typedef ::java::lang::Object super;
void messageReceived(::java::nio::ByteBuffer* bb) override;
void fileReceived(::java::io::File* f, ::java::nio::ByteBuffer* metadata) override;
void receiveException(::java::lang::Exception* ioe) override;
// Generated
ProfileFileTest_main_2_incomingSocket_2_1(ProfileFileTest_main_2 *ProfileFileTest_main_2_this, ::rice::environment::logging::Logger* logger);
static ::java::lang::Class *class_();
ProfileFileTest_main_2 *ProfileFileTest_main_2_this;
::rice::environment::logging::Logger* logger;
private:
virtual ::java::lang::Class* getClass0();
friend class ProfileFileTest;
friend class ProfileFileTest_main_1;
friend class ProfileFileTest_main_2;
friend class ProfileFileTest_main_2_incomingSocket_2_2;
friend class ProfileFileTest_main_3;
friend class ProfileFileTest_main_4;
friend class ProfileFileTest_main_4_receiveResult_4_1;
friend class ProfileFileTest_main_4_receiveResult_4_2;
};
|
[
"sgurjar@adobe.com"
] |
sgurjar@adobe.com
|
60f44331f88af906ab8ebf1cfdceaf571eb05727
|
81de7d09d92e602d32055b5e84c12d07034e99ce
|
/Minimum Spanning Tree(์ต์ ์คํจ๋ ํธ๋ฆฌ)/1647_๋์ ๋ถํ ๊ณํ.cpp
|
d68be0edc2ceadb31f5885e0ab7798d49bcc6c90
|
[] |
no_license
|
newdeal123/BOJ
|
13499fe476ae1aee2b3174e147b4fafbc071985b
|
20a161e46018fc1baba1710f36d3d29fa3bf20db
|
refs/heads/master
| 2021-08-08T15:41:57.601898
| 2021-06-30T14:41:14
| 2021-06-30T14:41:14
| 164,074,479
| 5
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,504
|
cpp
|
#include <bits/stdc++.h>
using namespace std;
const int INF=987654321;
const int MAX_N=100000+2;
int N,M;
vector<pair<int,int>> adj[MAX_N];
struct UNION_FIND
{
vector <int> parent,height;
UNION_FIND(){;};
UNION_FIND(int n)
{
parent.resize(n+1),height.resize(n+1,1);
for(int i=1;i<=n;i++)
parent[i]=i;
}
int find(int n)
{
if(parent[n]==n) return n;
return find(parent[n]);
}
void merge(int u,int v)
{
u=find(u),v=find(v);
if(u==v)
return;
if(height[u]>height[v])
swap(u,v);
parent[u]=v;
if(height[u]==height[v])
height[v]++;
}
};
int kruskal()
{
int ret=0,maxCost=0;
vector <pair<int,pair<int,int>>> edges;
for(int i=1;i<=N;i++)
for(auto j:adj[i])
edges.push_back(make_pair(j.second,make_pair(i,j.first)));
sort(edges.begin(),edges.end());
UNION_FIND uf(N);
for(auto i:edges)
{
int cost=i.first,u=i.second.first,v=i.second.second;
if(uf.find(u)==uf.find(v)) continue;
uf.merge(u,v);
ret+=cost;
maxCost=max(maxCost,cost);
}
return ret-maxCost;
}
int main()
{
ios_base :: sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin>>N>>M;
for(int i=0;i<M;i++)
{
int a,b,c;
cin>>a>>b>>c;
adj[a].push_back(make_pair(b,c));
adj[b].push_back(make_pair(a,c));
}
cout<<kruskal();
}
|
[
"newdeal123@nate.com"
] |
newdeal123@nate.com
|
e41c3c527c7217e4dfbdc7c05e9b9ea602aedd29
|
d333a3cbdcf089746d17bbd8d89cd978982d83d7
|
/Cpp/test/a.cpp
|
5671959e32d2e7e7ae64346a05e122ac98010afc
|
[] |
no_license
|
duantao74520/workspace
|
59bfd5d886533035da4ed46c86cbdff0f828a29d
|
5922d4f6715801919d9c84fd6f17f4a9fba8346f
|
refs/heads/master
| 2020-07-14T22:27:53.708007
| 2019-08-30T15:55:01
| 2019-08-30T15:55:01
| 205,416,103
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 211
|
cpp
|
#include <stdio.h>
void debug(char *str)
{
printf("debug info :%s\n",str );
}
main(int argc,char *argv[]){
int i,j;
j=0;
for(i=0;i<10;i++){
j+=5;
printf("now a=%d\n", j);
}
}
|
[
"841618016@qq.com"
] |
841618016@qq.com
|
6c86ca854929d2c2cb0de3e21901bb343041e93f
|
edad7a6ae21782e63cb4992cbf29625f7a5b866f
|
/1541.cpp
|
5d5e883b470c903128a31c4e94a8ea61c5219d45
|
[] |
no_license
|
iamDip171/URI-Probelms
|
6f95339c2ab9ff5f3bd0b649a922166689585a65
|
786ea3121c12202e1109c0e7314afc4ce76fd545
|
refs/heads/master
| 2023-03-10T01:08:37.720151
| 2021-02-26T05:50:56
| 2021-02-26T05:50:56
| 336,617,169
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 242
|
cpp
|
#include <bits/stdc++.h>
using namespace std ;
int main ()
{
int a,b, percent ;
while (1) {
cin >> a ;
if (a == 0) break ;
cin >> b >> percent ;
cout << (int) sqrt((a*b)*100/percent) << "\n" ;
}
}
|
[
"dsaha201171@bscse.uiu.ac.bd"
] |
dsaha201171@bscse.uiu.ac.bd
|
6408baed7f1a1504ea4a71f7c02eae35236e6652
|
83bacfbdb7ad17cbc2fc897b3460de1a6726a3b1
|
/gen/v8_7_5/torque-generated/builtins-array-find-from-dsl-gen.h
|
a3c07ab60b22c89ef99cbcac3def07f0841b440d
|
[
"Apache-2.0"
] |
permissive
|
cool2528/miniblink49
|
d909e39012f2c5d8ab658dc2a8b314ad0050d8ea
|
7f646289d8074f098cf1244adc87b95e34ab87a8
|
refs/heads/master
| 2020-06-05T03:18:43.211372
| 2019-06-01T08:57:37
| 2019-06-01T08:59:56
| 192,294,645
| 2
| 0
|
Apache-2.0
| 2019-06-17T07:16:28
| 2019-06-17T07:16:27
| null |
UTF-8
|
C++
| false
| false
| 993
|
h
|
#ifndef V8_TORQUE_ARRAY_FIND_FROM_DSL_BASE_H__
#define V8_TORQUE_ARRAY_FIND_FROM_DSL_BASE_H__
#include "src/compiler/code-assembler.h"
#include "src/code-stub-assembler.h"
#include "src/utils.h"
#include "torque-generated/class-definitions-from-dsl.h"
namespace v8 {
namespace internal {
class ArrayFindBuiltinsFromDSLAssembler {
public:
explicit ArrayFindBuiltinsFromDSLAssembler(compiler::CodeAssemblerState* state) : state_(state), ca_(state) { USE(state_, ca_); }
compiler::TNode<Object> FastArrayFind(compiler::TNode<Context> p_context, compiler::TNode<JSReceiver> p_o, compiler::TNode<Number> p_len, compiler::TNode<JSReceiver> p_callbackfn, compiler::TNode<Object> p_thisArg, compiler::CodeAssemblerLabel* label_Bailout, compiler::TypedCodeAssemblerVariable<Smi>* label_Bailout_parameter_0);
private:
compiler::CodeAssemblerState* const state_;
compiler::CodeAssembler ca_;
};
} // namespace internal
} // namespace v8
#endif // V8_TORQUE_ARRAY_FIND_FROM_DSL_BASE_H__
|
[
"22249030@qq.com"
] |
22249030@qq.com
|
2762855789fd72ec9e2156ed72bfe0e67a3286cc
|
dd11fc3311b61ddbe196e21c14226d0b60777650
|
/src/classical/mign/mign_rewriting_majn_to_smaller.hpp
|
753659ce35ed00a6bbe579716c98812591ec1fc2
|
[
"MIT"
] |
permissive
|
eletesta/cirkit-addon-mign
|
3d03b72f2c6b3254c77c88aad0f81971eebb6bd0
|
65c79809495957892dbf3e48550d035970a2169b
|
refs/heads/master
| 2021-09-20T01:04:14.135418
| 2018-08-02T00:14:00
| 2018-08-02T00:14:00
| 84,551,715
| 0
| 0
| null | 2017-10-03T10:20:12
| 2017-03-10T11:08:31
|
C++
|
UTF-8
|
C++
| false
| false
| 1,404
|
hpp
|
/* CirKit: A circuit toolkit
* Copyright (C) 2009-2015 University of Bremen
* Copyright (C) 2015-2016 EPFL
*
* 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 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file mig_rewriting.hpp
*
* @brief MIG rewriting
*
* @author Mathias Soeken
* @since 2.3
*/
#ifndef MIGN_REWRITING_MAJN_TO_SMALLER_HPP
#define MIGN_REWRITING_MAJN_TO_SMALLER_HPP
#include <core/properties.hpp>
#include <classical/mign/mign.hpp>
namespace cirkit
{
mign_graph mign_rewriting_majn_to_smaller( mign_graph& mign, const unsigned n,
const properties::ptr& settings,
const properties::ptr& statistics );
}
#endif
// Local Variables:
// c-basic-offset: 2
// eval: (c-set-offset 'substatement-open 0)
// eval: (c-set-offset 'innamespace 0)
// End:
|
[
"eleonora.testa@epfl.ch"
] |
eleonora.testa@epfl.ch
|
6a899430f7023b69508630f772ce8514c3a4285e
|
73e7c20803be5d8ae467af1feba8a4a7fe219f4b
|
/Modules/Registration/RegistrationMethodsv4/test/itkSyNImageRegistrationTest.cxx
|
2d11bde505951ed63b9833556e05b3d20b8fe0a2
|
[
"LicenseRef-scancode-other-permissive",
"SMLNJ",
"BSD-3-Clause",
"LicenseRef-scancode-mit-old-style",
"LicenseRef-scancode-free-unknown",
"BSD-4.3TAHOE",
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-unknown-license-reference",
"IJG",
"Zlib",
"Spencer-86",
"libtiff",
"Apache-2.0",
"MIT",
"LicenseRef-scancode-public-domain",
"NTP",
"BSD-2-Clause",
"GPL-1.0-or-later",
"FSFUL",
"Libpng"
] |
permissive
|
CIBC-Internal/itk
|
deaa8aabe3995f3465ec70a46805bd333967ed5b
|
6f7b1014a73857115d6da738583492008bea8205
|
refs/heads/master
| 2021-01-10T18:48:58.502855
| 2018-01-26T21:25:51
| 2018-01-26T21:25:51
| 31,582,564
| 0
| 2
|
Apache-2.0
| 2018-05-21T07:59:53
| 2015-03-03T06:12:12
|
C++
|
UTF-8
|
C++
| false
| false
| 20,437
|
cxx
|
/*=========================================================================
*
* Copyright Insight Software Consortium
*
* 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.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*=========================================================================*/
#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkImageRegistrationMethodv4.h"
#include "itkSyNImageRegistrationMethod.h"
#include "itkAffineTransform.h"
#include "itkANTSNeighborhoodCorrelationImageToImageMetricv4.h"
#include "itkCompositeTransform.h"
#include "itkDisplacementFieldTransformParametersAdaptor.h"
#include "itkVector.h"
#include "itkTestingMacros.h"
template<typename TFilter>
class CommandIterationUpdate : public itk::Command
{
public:
typedef CommandIterationUpdate Self;
typedef itk::Command Superclass;
typedef itk::SmartPointer<Self> Pointer;
itkNewMacro( Self );
typedef typename TFilter::FixedImageType FixedImageType;
itkStaticConstMacro( ImageDimension, unsigned int, FixedImageType::ImageDimension ); /** ImageDimension constants */
typedef itk::ShrinkImageFilter<FixedImageType, FixedImageType> ShrinkFilterType;
typedef typename TFilter::OutputTransformType::ScalarType RealType;
typedef itk::DisplacementFieldTransform<RealType, ImageDimension> DisplacementFieldTransformType;
typedef typename DisplacementFieldTransformType::DisplacementFieldType DisplacementFieldType;
protected:
CommandIterationUpdate() {};
public:
virtual void Execute(itk::Object *caller, const itk::EventObject & event) ITK_OVERRIDE
{
Execute( (const itk::Object *) caller, event);
}
virtual void Execute(const itk::Object * object, const itk::EventObject & event) ITK_OVERRIDE
{
const TFilter * filter =
dynamic_cast< const TFilter * >( object );
if( typeid( event ) != typeid( itk::IterationEvent ) )
{ return; }
unsigned int currentLevel = filter->GetCurrentLevel();
typename TFilter::ShrinkFactorsPerDimensionContainerType shrinkFactors = filter->GetShrinkFactorsPerDimension( currentLevel );
typename TFilter::SmoothingSigmasArrayType smoothingSigmas = filter->GetSmoothingSigmasPerLevel();
typename TFilter::TransformParametersAdaptorsContainerType adaptors = filter->GetTransformParametersAdaptorsPerLevel();
std::cout << " Current level = " << currentLevel << std::endl;
std::cout << " shrink factor = " << shrinkFactors << std::endl;
std::cout << " smoothing sigma = " << smoothingSigmas[currentLevel] << std::endl;
std::cout << " required fixed parameters = " << adaptors[currentLevel]->GetRequiredFixedParameters() << std::endl;
/*
testing "itkGetConstObjectMacro" at each iteration
*/
typename ShrinkFilterType::Pointer shrinkFilter = ShrinkFilterType::New();
shrinkFilter->SetShrinkFactors( shrinkFactors );
shrinkFilter->SetInput( filter->GetFixedImage() );
shrinkFilter->Update();
const typename FixedImageType::SizeType ImageSize = shrinkFilter->GetOutput()->GetBufferedRegion().GetSize();
const typename DisplacementFieldType::SizeType FixedDisplacementFieldSize =
filter->GetFixedToMiddleTransform()->GetDisplacementField()->GetBufferedRegion().GetSize();
const typename DisplacementFieldType::SizeType MovingDisplacementFieldSize =
filter->GetMovingToMiddleTransform()->GetDisplacementField()->GetBufferedRegion().GetSize();
if( ( FixedDisplacementFieldSize == ImageSize ) && ( MovingDisplacementFieldSize == ImageSize ) )
{
std::cout << " *Filter returns its internal transforms properly*" << std::endl;
}
else
{
itkExceptionMacro( "Internal transforms should be consistent with input image size at each iteration. "
<< "Image size = " << ImageSize << ". Fixed field size = " << FixedDisplacementFieldSize
<< ". Moving field size = " << MovingDisplacementFieldSize << "." );
}
}
};
template<unsigned int TDimension>
int PerformDisplacementFieldImageRegistration( int itkNotUsed( argc ), char *argv[] )
{
const unsigned int ImageDimension = TDimension;
typedef double PixelType;
typedef itk::Image<PixelType, ImageDimension> FixedImageType;
typedef itk::Image<PixelType, ImageDimension> MovingImageType;
typedef itk::ImageFileReader<FixedImageType> ImageReaderType;
typename ImageReaderType::Pointer fixedImageReader = ImageReaderType::New();
fixedImageReader->SetFileName( argv[2] );
fixedImageReader->Update();
typename FixedImageType::Pointer fixedImage = fixedImageReader->GetOutput();
fixedImage->Update();
fixedImage->DisconnectPipeline();
typename ImageReaderType::Pointer movingImageReader = ImageReaderType::New();
movingImageReader->SetFileName( argv[3] );
movingImageReader->Update();
typename MovingImageType::Pointer movingImage = movingImageReader->GetOutput();
movingImage->Update();
movingImage->DisconnectPipeline();
typedef itk::AffineTransform<double, ImageDimension> AffineTransformType;
typedef itk::ImageRegistrationMethodv4<FixedImageType, MovingImageType, AffineTransformType> AffineRegistrationType;
typename AffineRegistrationType::Pointer affineSimple = AffineRegistrationType::New();
affineSimple->SetFixedImage( fixedImage );
affineSimple->SetMovingImage( movingImage );
// Shrink the virtual domain by specified factors for each level. See documentation
// for the itkShrinkImageFilter for more detailed behavior.
typename AffineRegistrationType::ShrinkFactorsArrayType affineShrinkFactorsPerLevel;
affineShrinkFactorsPerLevel.SetSize( 3 );
affineShrinkFactorsPerLevel[0] = 4;
affineShrinkFactorsPerLevel[1] = 4;
affineShrinkFactorsPerLevel[2] = 4;
affineSimple->SetShrinkFactorsPerLevel( affineShrinkFactorsPerLevel );
// Set the number of iterations
typedef itk::GradientDescentOptimizerv4 GradientDescentOptimizerv4Type;
GradientDescentOptimizerv4Type * optimizer = dynamic_cast<GradientDescentOptimizerv4Type *>( affineSimple->GetModifiableOptimizer() );
TEST_EXPECT_TRUE( optimizer != ITK_NULLPTR );
#ifdef NDEBUG
optimizer->SetNumberOfIterations( 100 );
#else
optimizer->SetNumberOfIterations( 1 );
#endif
try
{
std::cout << "Affine transform" << std::endl;
affineSimple->Update();
}
catch( itk::ExceptionObject &e )
{
std::cerr << "Exception caught: " << e << std::endl;
return EXIT_FAILURE;
}
//
// Now do the displacement field transform with gaussian smoothing using
// the composite transform.
//
typedef typename AffineRegistrationType::RealType RealType;
typedef itk::CompositeTransform<RealType, ImageDimension> CompositeTransformType;
typename CompositeTransformType::Pointer compositeTransform = CompositeTransformType::New();
compositeTransform->AddTransform( affineSimple->GetModifiableTransform() );
typedef itk::ResampleImageFilter<MovingImageType, FixedImageType> AffineResampleFilterType;
typename AffineResampleFilterType::Pointer affineResampler = AffineResampleFilterType::New();
affineResampler->SetTransform( compositeTransform );
affineResampler->SetInput( movingImage );
affineResampler->SetSize( fixedImage->GetBufferedRegion().GetSize() );
affineResampler->SetOutputOrigin( fixedImage->GetOrigin() );
affineResampler->SetOutputSpacing( fixedImage->GetSpacing() );
affineResampler->SetOutputDirection( fixedImage->GetDirection() );
affineResampler->SetDefaultPixelValue( 0 );
affineResampler->Update();
std::string affineMovingImageFileName = std::string( argv[4] ) + std::string( "MovingImageAfterAffineTransform.nii.gz" );
typedef itk::ImageFileWriter<FixedImageType> AffineWriterType;
typename AffineWriterType::Pointer affineWriter = AffineWriterType::New();
affineWriter->SetFileName( affineMovingImageFileName.c_str() );
affineWriter->SetInput( affineResampler->GetOutput() );
affineWriter->Update();
typedef itk::Vector<RealType, ImageDimension> VectorType;
VectorType zeroVector( 0.0 );
// Create the SyN deformable registration method
typedef itk::Image<VectorType, ImageDimension> DisplacementFieldType;
typename DisplacementFieldType::Pointer displacementField = DisplacementFieldType::New();
displacementField->CopyInformation( fixedImage );
displacementField->SetRegions( fixedImage->GetBufferedRegion() );
displacementField->Allocate();
displacementField->FillBuffer( zeroVector );
typename DisplacementFieldType::Pointer inverseDisplacementField = DisplacementFieldType::New();
inverseDisplacementField->CopyInformation( fixedImage );
inverseDisplacementField->SetRegions( fixedImage->GetBufferedRegion() );
inverseDisplacementField->Allocate();
inverseDisplacementField->FillBuffer( zeroVector );
typedef itk::SyNImageRegistrationMethod<FixedImageType, MovingImageType> DisplacementFieldRegistrationType;
typename DisplacementFieldRegistrationType::Pointer displacementFieldRegistration = DisplacementFieldRegistrationType::New();
typedef typename DisplacementFieldRegistrationType::OutputTransformType OutputTransformType;
typename OutputTransformType::Pointer outputTransform = OutputTransformType::New();
outputTransform->SetDisplacementField( displacementField );
outputTransform->SetInverseDisplacementField( inverseDisplacementField );
displacementFieldRegistration->SetInitialTransform( outputTransform );
displacementFieldRegistration->InPlaceOn();
//Test member functions
displacementFieldRegistration->SetDownsampleImagesForMetricDerivatives(false);
if( displacementFieldRegistration->GetDownsampleImagesForMetricDerivatives() != false )
{
return EXIT_FAILURE;
}
displacementFieldRegistration->SetDownsampleImagesForMetricDerivatives(true);
if( displacementFieldRegistration->GetDownsampleImagesForMetricDerivatives() != true )
{
return EXIT_FAILURE;
}
displacementFieldRegistration->SetAverageMidPointGradients(false);
if( displacementFieldRegistration->GetAverageMidPointGradients() != false )
{
return EXIT_FAILURE;
}
displacementFieldRegistration->SetAverageMidPointGradients(true);
if( displacementFieldRegistration->GetAverageMidPointGradients() != true )
{
return EXIT_FAILURE;
}
// Create the transform adaptors
typedef itk::DisplacementFieldTransformParametersAdaptor<OutputTransformType> DisplacementFieldTransformAdaptorType;
typename DisplacementFieldRegistrationType::TransformParametersAdaptorsContainerType adaptors;
// Create the transform adaptors
// For the gaussian displacement field, the specified variances are in image spacing terms
// and, in normal practice, we typically don't change these values at each level. However,
// if the user wishes to add that option, they can use the class
// GaussianSmoothingOnUpdateDisplacementFieldTransformAdaptor
unsigned int numberOfLevels = 3;
typename DisplacementFieldRegistrationType::NumberOfIterationsArrayType numberOfIterationsPerLevel;
numberOfIterationsPerLevel.SetSize( 3 );
#ifdef NDEBUG
numberOfIterationsPerLevel[0] = atoi( argv[5] );
numberOfIterationsPerLevel[1] = 2;
numberOfIterationsPerLevel[2] = 1;
#else
numberOfIterationsPerLevel[0] = 1;
numberOfIterationsPerLevel[1] = 1;
numberOfIterationsPerLevel[2] = 1;
#endif
RealType varianceForUpdateField = 1.75;
RealType varianceForTotalField = 0.5;
typename DisplacementFieldRegistrationType::ShrinkFactorsArrayType shrinkFactorsPerLevel;
shrinkFactorsPerLevel.SetSize( 3 );
shrinkFactorsPerLevel[0] = 3;
shrinkFactorsPerLevel[1] = 2;
shrinkFactorsPerLevel[2] = 1;
typename DisplacementFieldRegistrationType::SmoothingSigmasArrayType smoothingSigmasPerLevel;
smoothingSigmasPerLevel.SetSize( 3 );
smoothingSigmasPerLevel[0] = 2;
smoothingSigmasPerLevel[1] = 1;
smoothingSigmasPerLevel[2] = 0;
for( unsigned int level = 0; level < numberOfLevels; level++ )
{
// We use the shrink image filter to calculate the fixed parameters of the virtual
// domain at each level. To speed up calculation and avoid unnecessary memory
// usage, we could calculate these fixed parameters directly.
typedef itk::ShrinkImageFilter<DisplacementFieldType, DisplacementFieldType> ShrinkFilterType;
typename ShrinkFilterType::Pointer shrinkFilter = ShrinkFilterType::New();
shrinkFilter->SetShrinkFactors( shrinkFactorsPerLevel[level] );
shrinkFilter->SetInput( displacementField );
shrinkFilter->Update();
typename DisplacementFieldTransformAdaptorType::Pointer fieldTransformAdaptor = DisplacementFieldTransformAdaptorType::New();
fieldTransformAdaptor->SetRequiredSpacing( shrinkFilter->GetOutput()->GetSpacing() );
fieldTransformAdaptor->SetRequiredSize( shrinkFilter->GetOutput()->GetBufferedRegion().GetSize() );
fieldTransformAdaptor->SetRequiredDirection( shrinkFilter->GetOutput()->GetDirection() );
fieldTransformAdaptor->SetRequiredOrigin( shrinkFilter->GetOutput()->GetOrigin() );
fieldTransformAdaptor->SetTransform( outputTransform );
adaptors.push_back( fieldTransformAdaptor.GetPointer() );
}
typedef itk::ANTSNeighborhoodCorrelationImageToImageMetricv4<FixedImageType, MovingImageType> CorrelationMetricType;
typename CorrelationMetricType::Pointer correlationMetric = CorrelationMetricType::New();
typename CorrelationMetricType::RadiusType radius;
radius.Fill( 4 );
correlationMetric->SetRadius( radius );
correlationMetric->SetUseMovingImageGradientFilter( false );
correlationMetric->SetUseFixedImageGradientFilter( false );
displacementFieldRegistration->SetFixedImage( fixedImage );
displacementFieldRegistration->SetMovingImage( movingImage );
displacementFieldRegistration->SetNumberOfLevels( 3 );
displacementFieldRegistration->SetMovingInitialTransform( compositeTransform );
displacementFieldRegistration->SetShrinkFactorsPerLevel( shrinkFactorsPerLevel );
displacementFieldRegistration->SetSmoothingSigmasPerLevel( smoothingSigmasPerLevel );
displacementFieldRegistration->SetMetric( correlationMetric );
const typename DisplacementFieldRegistrationType::RealType local_epsilon = itk::NumericTraits< typename DisplacementFieldRegistrationType::RealType >::epsilon();
const typename DisplacementFieldRegistrationType::RealType local_LearningRate = atof( argv[6] );
displacementFieldRegistration->SetLearningRate( local_LearningRate );
if ( displacementFieldRegistration->GetLearningRate() - local_LearningRate > local_epsilon )
{
return EXIT_FAILURE;
}
displacementFieldRegistration->SetNumberOfIterationsPerLevel( numberOfIterationsPerLevel );
if ( displacementFieldRegistration->GetNumberOfIterationsPerLevel() != numberOfIterationsPerLevel )
{
return EXIT_FAILURE;
}
displacementFieldRegistration->SetTransformParametersAdaptorsPerLevel( adaptors );
displacementFieldRegistration->SetGaussianSmoothingVarianceForTheUpdateField( varianceForUpdateField );
if ( displacementFieldRegistration->GetGaussianSmoothingVarianceForTheUpdateField() - varianceForUpdateField > local_epsilon )
{
return EXIT_FAILURE;
}
displacementFieldRegistration->SetGaussianSmoothingVarianceForTheTotalField( varianceForTotalField );
if ( displacementFieldRegistration->GetGaussianSmoothingVarianceForTheTotalField() - varianceForTotalField > local_epsilon )
{
return EXIT_FAILURE;
}
const typename DisplacementFieldRegistrationType::RealType local_ConvergenceThreshold = 1.0e-6;
displacementFieldRegistration->SetConvergenceThreshold( local_ConvergenceThreshold );
if ( displacementFieldRegistration->GetConvergenceThreshold() - local_ConvergenceThreshold > local_epsilon )
{
return EXIT_FAILURE;
}
const unsigned int local_ConvergenceWindowSize = 10;
displacementFieldRegistration->SetConvergenceWindowSize( local_ConvergenceWindowSize );
if ( displacementFieldRegistration->GetConvergenceWindowSize() != local_ConvergenceWindowSize )
{
return EXIT_FAILURE;
}
typedef CommandIterationUpdate<DisplacementFieldRegistrationType> DisplacementFieldCommandType;
typename DisplacementFieldCommandType::Pointer DisplacementFieldObserver = DisplacementFieldCommandType::New();
displacementFieldRegistration->AddObserver( itk::IterationEvent(), DisplacementFieldObserver );
try
{
std::cout << "SyN registration" << std::endl;
displacementFieldRegistration->Update();
}
catch( itk::ExceptionObject &e )
{
std::cerr << "Exception caught: " << e << std::endl;
return EXIT_FAILURE;
}
compositeTransform->AddTransform( outputTransform );
typedef itk::ResampleImageFilter<MovingImageType, FixedImageType> ResampleFilterType;
typename ResampleFilterType::Pointer resampler = ResampleFilterType::New();
resampler->SetTransform( compositeTransform );
resampler->SetInput( movingImage );
resampler->SetSize( fixedImage->GetBufferedRegion().GetSize() );
resampler->SetOutputOrigin( fixedImage->GetOrigin() );
resampler->SetOutputSpacing( fixedImage->GetSpacing() );
resampler->SetOutputDirection( fixedImage->GetDirection() );
resampler->SetDefaultPixelValue( 0 );
resampler->Update();
std::string warpedMovingImageFileName = std::string( argv[4] ) + std::string( "MovingImageAfterSyN.nii.gz" );
typedef itk::ImageFileWriter<FixedImageType> WriterType;
typename WriterType::Pointer writer = WriterType::New();
writer->SetFileName( warpedMovingImageFileName.c_str() );
writer->SetInput( resampler->GetOutput() );
writer->Update();
typedef itk::ResampleImageFilter<FixedImageType, MovingImageType> InverseResampleFilterType;
typename InverseResampleFilterType::Pointer inverseResampler = ResampleFilterType::New();
inverseResampler->SetTransform( compositeTransform->GetInverseTransform() );
inverseResampler->SetInput( fixedImage );
inverseResampler->SetSize( movingImage->GetBufferedRegion().GetSize() );
inverseResampler->SetOutputOrigin( movingImage->GetOrigin() );
inverseResampler->SetOutputSpacing( movingImage->GetSpacing() );
inverseResampler->SetOutputDirection( movingImage->GetDirection() );
inverseResampler->SetDefaultPixelValue( 0 );
inverseResampler->Update();
std::string inverseWarpedFixedImageFileName = std::string( argv[4] ) + std::string( "InverseWarpedFixedImage.nii.gz" );
typedef itk::ImageFileWriter<MovingImageType> InverseWriterType;
typename InverseWriterType::Pointer inverseWriter = InverseWriterType::New();
inverseWriter->SetFileName( inverseWarpedFixedImageFileName.c_str() );
inverseWriter->SetInput( inverseResampler->GetOutput() );
inverseWriter->Update();
std::string displacementFieldFileName = std::string( argv[4] ) + std::string( "DisplacementField.nii.gz" );
typedef itk::ImageFileWriter<DisplacementFieldType> DisplacementFieldWriterType;
typename DisplacementFieldWriterType::Pointer displacementFieldWriter = DisplacementFieldWriterType::New();
displacementFieldWriter->SetFileName( displacementFieldFileName.c_str() );
displacementFieldWriter->SetInput( outputTransform->GetDisplacementField() );
displacementFieldWriter->Update();
return EXIT_SUCCESS;
}
int itkSyNImageRegistrationTest( int argc, char *argv[] )
{
if ( argc < 5 )
{
std::cout << argv[0] << " imageDimension fixedImage movingImage outputPrefix numberOfDeformableIterations learningRate" << std::endl;
exit( 1 );
}
switch( atoi( argv[1] ) )
{
case 2:
PerformDisplacementFieldImageRegistration<2>( argc, argv );
break;
case 3:
PerformDisplacementFieldImageRegistration<3>( argc, argv );
break;
default:
std::cerr << "Unsupported dimension" << std::endl;
exit( EXIT_FAILURE );
}
return EXIT_SUCCESS;
}
|
[
"ayla@sci.utah.edu"
] |
ayla@sci.utah.edu
|
b1df127d5d1a110abb9ba34d2a0f1ab0e9c3fcc5
|
aa8c315b03c10e46bda03d2ce6d334ad5b91ee01
|
/arduino_play/instrument.h
|
08700f81daade435792933fc64fcf8d092fe3815
|
[] |
no_license
|
jachang820/InstrumentPlayingRobot
|
84eed1b6104b92fae017cdaeefa0216d927d23ee
|
3cb38c5f4b454dc40ec120c52d4f6743bbb7b88d
|
refs/heads/master
| 2021-05-02T10:01:28.275188
| 2018-02-09T22:22:10
| 2018-02-09T22:22:10
| 120,786,855
| 0
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 140
|
h
|
#ifndef INSTRUMENT_H
#define INSTRUMENT_H
class Instrument {
public:
virtual void begin() = 0;
virtual void play(int) = 0;
};
#endif
|
[
"j.a.chang820@gmail.com"
] |
j.a.chang820@gmail.com
|
430f435a74ab4821f3a5b12bb7678d09002bee5b
|
9d364070c646239b2efad7abbab58f4ad602ef7b
|
/platform/external/chromium_org/media/base/mock_filters.h
|
ccf28d0806de20ab60efec263101107a2a6a5576
|
[
"BSD-3-Clause"
] |
permissive
|
denix123/a32_ul
|
4ffe304b13c1266b6c7409d790979eb8e3b0379c
|
b2fd25640704f37d5248da9cc147ed267d4771c2
|
refs/heads/master
| 2021-01-17T20:21:17.196296
| 2016-08-16T04:30:53
| 2016-08-16T04:30:53
| 65,786,970
| 0
| 2
| null | 2020-03-06T22:00:52
| 2016-08-16T04:15:54
| null |
UTF-8
|
C++
| false
| false
| 8,336
|
h
|
// Copyright (c) 2012 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 MEDIA_BASE_MOCK_FILTERS_H_
#define MEDIA_BASE_MOCK_FILTERS_H_
#include <string>
#include "base/callback.h"
#include "media/base/audio_decoder.h"
#include "media/base/audio_decoder_config.h"
#include "media/base/audio_renderer.h"
#include "media/base/decoder_buffer.h"
#include "media/base/decryptor.h"
#include "media/base/demuxer.h"
#include "media/base/pipeline_status.h"
#include "media/base/renderer.h"
#include "media/base/text_track.h"
#include "media/base/time_source.h"
#include "media/base/video_decoder.h"
#include "media/base/video_decoder_config.h"
#include "media/base/video_frame.h"
#include "media/base/video_renderer.h"
#include "testing/gmock/include/gmock/gmock.h"
namespace media {
class MockDemuxer : public Demuxer {
public:
MockDemuxer();
virtual ~MockDemuxer();
MOCK_METHOD3(Initialize,
void(DemuxerHost* host, const PipelineStatusCB& cb, bool));
MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
MOCK_METHOD2(Seek, void(base::TimeDelta time, const PipelineStatusCB& cb));
MOCK_METHOD0(Stop, void());
MOCK_METHOD0(OnAudioRendererDisabled, void());
MOCK_METHOD1(GetStream, DemuxerStream*(DemuxerStream::Type));
MOCK_CONST_METHOD0(GetStartTime, base::TimeDelta());
MOCK_CONST_METHOD0(GetTimelineOffset, base::Time());
MOCK_CONST_METHOD0(GetLiveness, Liveness());
private:
DISALLOW_COPY_AND_ASSIGN(MockDemuxer);
};
class MockDemuxerStream : public DemuxerStream {
public:
explicit MockDemuxerStream(DemuxerStream::Type type);
virtual ~MockDemuxerStream();
virtual Type type() OVERRIDE;
MOCK_METHOD1(Read, void(const ReadCB& read_cb));
virtual AudioDecoderConfig audio_decoder_config() OVERRIDE;
virtual VideoDecoderConfig video_decoder_config() OVERRIDE;
MOCK_METHOD0(EnableBitstreamConverter, void());
MOCK_METHOD0(SupportsConfigChanges, bool());
void set_audio_decoder_config(const AudioDecoderConfig& config);
void set_video_decoder_config(const VideoDecoderConfig& config);
virtual VideoRotation video_rotation() OVERRIDE;
private:
DemuxerStream::Type type_;
AudioDecoderConfig audio_decoder_config_;
VideoDecoderConfig video_decoder_config_;
DISALLOW_COPY_AND_ASSIGN(MockDemuxerStream);
};
class MockVideoDecoder : public VideoDecoder {
public:
MockVideoDecoder();
virtual ~MockVideoDecoder();
virtual std::string GetDisplayName() const;
MOCK_METHOD4(Initialize, void(const VideoDecoderConfig& config,
bool low_delay,
const PipelineStatusCB& status_cb,
const OutputCB& output_cb));
MOCK_METHOD2(Decode, void(const scoped_refptr<DecoderBuffer>& buffer,
const DecodeCB&));
MOCK_METHOD1(Reset, void(const base::Closure&));
MOCK_CONST_METHOD0(HasAlpha, bool());
private:
DISALLOW_COPY_AND_ASSIGN(MockVideoDecoder);
};
class MockAudioDecoder : public AudioDecoder {
public:
MockAudioDecoder();
virtual ~MockAudioDecoder();
virtual std::string GetDisplayName() const;
MOCK_METHOD3(Initialize,
void(const AudioDecoderConfig& config,
const PipelineStatusCB& status_cb,
const OutputCB& output_cb));
MOCK_METHOD2(Decode,
void(const scoped_refptr<DecoderBuffer>& buffer,
const DecodeCB&));
MOCK_METHOD1(Reset, void(const base::Closure&));
private:
DISALLOW_COPY_AND_ASSIGN(MockAudioDecoder);
};
class MockVideoRenderer : public VideoRenderer {
public:
MockVideoRenderer();
virtual ~MockVideoRenderer();
MOCK_METHOD8(Initialize, void(DemuxerStream* stream,
bool low_delay,
const PipelineStatusCB& init_cb,
const StatisticsCB& statistics_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& ended_cb,
const PipelineStatusCB& error_cb,
const TimeDeltaCB& get_time_cb));
MOCK_METHOD1(Flush, void(const base::Closure& callback));
MOCK_METHOD1(StartPlayingFrom, void(base::TimeDelta));
private:
DISALLOW_COPY_AND_ASSIGN(MockVideoRenderer);
};
class MockAudioRenderer : public AudioRenderer {
public:
MockAudioRenderer();
virtual ~MockAudioRenderer();
MOCK_METHOD6(Initialize, void(DemuxerStream* stream,
const PipelineStatusCB& init_cb,
const StatisticsCB& statistics_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& ended_cb,
const PipelineStatusCB& error_cb));
MOCK_METHOD0(GetTimeSource, TimeSource*());
MOCK_METHOD1(Flush, void(const base::Closure& callback));
MOCK_METHOD0(StartPlaying, void());
MOCK_METHOD1(SetVolume, void(float volume));
private:
DISALLOW_COPY_AND_ASSIGN(MockAudioRenderer);
};
class MockRenderer : public Renderer {
public:
MockRenderer();
virtual ~MockRenderer();
MOCK_METHOD5(Initialize, void(const base::Closure& init_cb,
const StatisticsCB& statistics_cb,
const base::Closure& ended_cb,
const PipelineStatusCB& error_cb,
const BufferingStateCB& buffering_state_cb));
MOCK_METHOD1(Flush, void(const base::Closure& flush_cb));
MOCK_METHOD1(StartPlayingFrom, void(base::TimeDelta timestamp));
MOCK_METHOD1(SetPlaybackRate, void(float playback_rate));
MOCK_METHOD1(SetVolume, void(float volume));
MOCK_METHOD0(GetMediaTime, base::TimeDelta());
MOCK_METHOD0(HasAudio, bool());
MOCK_METHOD0(HasVideo, bool());
MOCK_METHOD1(SetCdm, void(MediaKeys* cdm));
private:
DISALLOW_COPY_AND_ASSIGN(MockRenderer);
};
class MockTimeSource : public TimeSource {
public:
MockTimeSource();
virtual ~MockTimeSource();
MOCK_METHOD0(StartTicking, void());
MOCK_METHOD0(StopTicking, void());
MOCK_METHOD1(SetPlaybackRate, void(float));
MOCK_METHOD1(SetMediaTime, void(base::TimeDelta));
MOCK_METHOD0(CurrentMediaTime, base::TimeDelta());
MOCK_METHOD0(CurrentMediaTimeForSyncingVideo, base::TimeDelta());
private:
DISALLOW_COPY_AND_ASSIGN(MockTimeSource);
};
class MockTextTrack : public TextTrack {
public:
MockTextTrack();
virtual ~MockTextTrack();
MOCK_METHOD5(addWebVTTCue, void(const base::TimeDelta& start,
const base::TimeDelta& end,
const std::string& id,
const std::string& content,
const std::string& settings));
private:
DISALLOW_COPY_AND_ASSIGN(MockTextTrack);
};
class MockDecryptor : public Decryptor {
public:
MockDecryptor();
virtual ~MockDecryptor();
MOCK_METHOD2(RegisterNewKeyCB, void(StreamType stream_type,
const NewKeyCB& new_key_cb));
MOCK_METHOD3(Decrypt, void(StreamType stream_type,
const scoped_refptr<DecoderBuffer>& encrypted,
const DecryptCB& decrypt_cb));
MOCK_METHOD1(CancelDecrypt, void(StreamType stream_type));
MOCK_METHOD2(InitializeAudioDecoder,
void(const AudioDecoderConfig& config,
const DecoderInitCB& init_cb));
MOCK_METHOD2(InitializeVideoDecoder,
void(const VideoDecoderConfig& config,
const DecoderInitCB& init_cb));
MOCK_METHOD2(DecryptAndDecodeAudio,
void(const scoped_refptr<media::DecoderBuffer>& encrypted,
const AudioDecodeCB& audio_decode_cb));
MOCK_METHOD2(DecryptAndDecodeVideo,
void(const scoped_refptr<media::DecoderBuffer>& encrypted,
const VideoDecodeCB& video_decode_cb));
MOCK_METHOD1(ResetDecoder, void(StreamType stream_type));
MOCK_METHOD1(DeinitializeDecoder, void(StreamType stream_type));
private:
DISALLOW_COPY_AND_ASSIGN(MockDecryptor);
};
}
#endif
|
[
"allegrant@mail.ru"
] |
allegrant@mail.ru
|
992ec6199433c68edc229631b2a0cbb415a0c276
|
4ba0b403637e7aa3e18c9bafae32034e3c394fe4
|
/cplusplus/eLang/eLang/el_sequence_expr.h
|
e005739943d6fa4c4d2fccf7ed940186a0bbef3a
|
[] |
no_license
|
ASMlover/study
|
3767868ddae63ac996e91b73700d40595dd1450f
|
1331c8861fcefbef2813a2bdd1ee09c1f1ee46d6
|
refs/heads/master
| 2023-09-06T06:45:45.596981
| 2023-09-01T08:19:49
| 2023-09-01T08:19:49
| 7,519,677
| 23
| 6
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,044
|
h
|
// Copyright (c) 2015 ASMlover. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list ofconditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in
// the documentation and/or other materialsprovided with the
// distribution.
//
// 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.
#ifndef __EL_SEQUENCE_EXPR_HEADER_H__
#define __EL_SEQUENCE_EXPR_HEADER_H__
#include "el_expr.h"
#include "el_expr_compiler_base.h"
namespace el {
class SequenceExpr : public Expr {
Array<Ref<Expr> > expressions_;
public:
explicit SequenceExpr(const Array<Ref<Expr> >& expressions)
: expressions_(expressions) {
}
inline const Array<Ref<Expr> >& Expressions(void) const {
return expressions_;
}
virtual void Trace(std::ostream& stream) const override {
stream << expressions_[0];
for (auto i = 1; i < expressions_.Count(); ++i)
stream << "; " << expressions_[i];
}
EL_EXPR_VISITOR
};
}
#endif // __EL_SEQUENCE_EXPR_HEADER_H__
|
[
"asmlover@126.com"
] |
asmlover@126.com
|
c052c0e80f40dc78efbc8bad836d2089fb32faf1
|
0faf14a347e134a82a5d406c7e5e7f5f2ded0cdd
|
/PlatformLib/common/include/revSampler.h
|
afaccd514a6bc0426f8577bdc42e0442053a5288
|
[
"MIT"
] |
permissive
|
monge13/Rev
|
7fa177dc816afc88ffc8ea49038444697aa121ff
|
db3b71a27659a2652bdd50069a881702b3ae059e
|
refs/heads/master
| 2022-12-13T04:07:48.451662
| 2020-07-25T13:06:52
| 2020-07-25T13:06:52
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 390
|
h
|
#ifndef __REVSAMPLER_H__
#define __REVSAMPLER_H__
#include "revGraphicsTypedef.h"
#include "revTexture.h"
class revSampler
{
public:
revSampler():
device(nullptr)
{}
virtual ~revSampler(){}
const revTextureSampler& GetHandle() const { return sampler; }
protected:
revDevice* device;
revTextureSampler sampler;
revTexture::SamplerDesc desc;
};
#endif
|
[
"ekioprogram@gmail.com"
] |
ekioprogram@gmail.com
|
3e3bf33a4555f212a38d60b45f204a80a270286b
|
d14b5d78b72711e4614808051c0364b7bd5d6d98
|
/third_party/llvm-10.0/llvm/lib/DebugInfo/PDB/PDBSymbolTypeCustom.cpp
|
6723894c90ea80f4293520bd9ceae3444899b209
|
[
"Apache-2.0"
] |
permissive
|
google/swiftshader
|
76659addb1c12eb1477050fded1e7d067f2ed25b
|
5be49d4aef266ae6dcc95085e1e3011dad0e7eb7
|
refs/heads/master
| 2023-07-21T23:19:29.415159
| 2023-07-21T19:58:29
| 2023-07-21T20:50:19
| 62,297,898
| 1,981
| 306
|
Apache-2.0
| 2023-07-05T21:29:34
| 2016-06-30T09:25:24
|
C++
|
UTF-8
|
C++
| false
| false
| 666
|
cpp
|
//===- PDBSymbolTypeCustom.cpp - --------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/PDB/PDBSymbolTypeCustom.h"
#include "llvm/DebugInfo/PDB/PDBSymDumper.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include <utility>
using namespace llvm;
using namespace llvm::pdb;
void PDBSymbolTypeCustom::dump(PDBSymDumper &Dumper) const {
Dumper.dump(*this);
}
|
[
"bclayton@google.com"
] |
bclayton@google.com
|
abbe8c60195667f438ff862b8dc81214f760e34d
|
882b06a0f5b570c6072afddf3ab1d5684fe982f4
|
/jge/Projects/cspsp/src/Person.h
|
ec3ded30d9fdc501559449a9a2eb9bb95fe5fa4b
|
[
"BSD-3-Clause"
] |
permissive
|
kevinbchen/cspsp
|
75a06a7decc826ec788ff79e01d1d31de4b43d5f
|
51abd9ed47ca39c576030a8ed233523e2d41d44c
|
refs/heads/master
| 2022-07-13T04:41:00.832823
| 2022-06-27T06:18:06
| 2022-06-27T06:18:06
| 6,846,752
| 26
| 10
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,568
|
h
|
#ifndef _PERSON_H_
#define _PERSON_H_
#include "JRenderer.h"
#include "JSoundSystem.h"
#include "Bullet.h"
#include "Grenade.h"
#include "GunObject.h"
#include "SfxManager.h"
#include <vector>
#include "Node.h"
#include "GunObjectOnline.h"
#include "Animation.h"
#define RELATIVE1 0
#define ABSOLUTE1 1
#define MOVING 0
#define NOTMOVING 1
#define NORMAL 0
#define DEAD 1
#define ATTACKING 2
#define RELOADING 3
#define DRYFIRING 4
#define SWITCHING 5
#define PRIMARY 0
#define SECONDARY 1
#define KNIFE 2
#define GRENADE 3
#define BODY 0
#define RIGHTARM 1
#define RIGHTHAND 2
#define LEFTARM 3
#define LEFTHAND 4
#define GUN 5
#define HEAD 5
#define LEGS 6
#define NUM_QUADS 7
#define WALKTIME 160.0f
enum {
ANIM_PRIMARY = 0,
ANIM_SECONDARY,
ANIM_KNIFE,
ANIM_GRENADE,
ANIM_BOMB,
ANIM_PRIMARY_FIRE,
ANIM_SECONDARY_FIRE,
ANIM_KNIFE_SLASH,
ANIM_GRENADE_PULLBACK,
ANIM_PRIMARY_RELOAD,
ANIM_SECONDARY_RELOAD
};
enum {
WALK1 = 0,
WALK2,
WALK3,
WALK4
};
//------------------------------------------------------------------------------------------------
class Person
{
private:
protected:
static JRenderer* mRenderer;
static JSoundSystem* mSoundSystem;
int mSoundId;
int mNumDryFire;
KeyFrame mKeyFrame;
Animation* mAnimations[11];
Animation* mCurrentAnimation;
int mMuzzleFlashIndex;
float mMuzzleFlashAngle;
float mMuzzleFlashTime;
float mWalkX;
float mWalkY;
void UpdateAngle(float &angle, float targetangle, float speed);
public:
JQuad* mQuads[NUM_QUADS];
//JQuad* mPartQuads[6];
JQuad* mDeadQuad;
float mAngle;
float mSpeed;
float mRotation;
float mX;
float mY;
float mOldX;
float mOldY;
std::vector<Person*>* mPeople;
std::vector<Bullet*>* mBullets;
std::vector<GunObject*>* mGunObjects;
float mMaxSpeed;
int mState;
int mMoveState;
float mStateTime;
float mFadeTime;
float mStepTime;
int mHealth;
int mMoney;
float mFacingAngle;
float mRecoilAngle;
float mLastFireAngle;
bool mIsActive;
GunObject* mGuns[5];
int mGunIndex;
//GunObject* mPrimaryGun;
//GunObject* mSecondaryGun;
//GunObject* mKnife;
int mTeam;
char mName[32];
int mMovementStyle;
int mNumKills;
int mNumDeaths;
float mPing;
bool mIsPlayerOnline;
bool mIsFiring;
bool mHasFired;
bool mIsFlashed;
float mFlashTime;
float mFlashIntensity;
bool mIsInBuyZone;
std::vector<Node*> mNodes;
Node* mNode;
Node* mTargetNode;
int mWalkState;
float mWalkTime;
float mWalkAngle;
float mRadarTime;
float mRadarX;
float mRadarY;
bool mHasFlag;
float mInvincibleTime;
Person(JQuad* quads[], JQuad* deadquad, std::vector<Bullet*>* bullets, std::vector<GunObject*>* guns, int team, char* name, int movementstyle);
virtual ~Person();
void PreUpdate(float dt);
virtual void Update(float dt);
virtual void Render(float x, float y);
virtual void Move(float speed, float angle);
virtual std::vector<Bullet*> Fire();
virtual std::vector<Bullet*> StopFire();
virtual bool Reload();
virtual void Switch(int index);
void SwitchNext();
bool PickUp(GunObject* gunobject);
virtual bool Drop(int index, float speed = 0.35f);
void RotateFacing(float theta);
void SetMoveState(int state);
void SetState(int state);
void SetAnimation(int animation);
void SetTotalRotation(float theta);
virtual void Die();
virtual void Reset();
void TakeDamage(int damage);
void ReceiveFlash(float intensity);
void SetQuads(JQuad* quads[], JQuad* deadquad);
GunObject* GetCurrentGun();
virtual void Teleport(float x, float y);
};
inline GunObject* Person::GetCurrentGun() {
return mGuns[mGunIndex];
}
#endif
|
[
"kevinchen1992@gmail.com"
] |
kevinchen1992@gmail.com
|
42e54e77c32c31c25643974f7de7fcf49359162c
|
158a8bb4d5e40c3f1655969fe8c9d06356925f2d
|
/Reverse Linked List II .cpp
|
e30186d7e182c7c92f79969de3e1ee0e1dea5a8f
|
[] |
no_license
|
xjh10389290/leetcode
|
1ade186b1d1d43bab6706718ce1c595da771e0bd
|
f7d9fe4e944a024093a2383447078983513505b1
|
refs/heads/master
| 2020-04-18T00:52:33.794217
| 2015-06-13T01:34:20
| 2015-06-13T01:34:20
| 28,729,799
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 893
|
cpp
|
class Solution {
public:
ListNode *reverseBetween(ListNode *head, int m, int n) {
int nn=m;
int k=m-1;
ListNode *chead=head;
ListNode *ptr0=head;
ListNode *ptr1=head;
ListNode *ptr2=head;
ListNode *ptr3=head;
while((--k)>0) ptr0=ptr0->next;
while((--m)>0) ptr1=ptr1->next;
while((--n)>0) ptr2=ptr2->next;
ptr3=ptr2->next;
if (ptr1!=NULL&&ptr2!=NULL&&ptr1!=ptr2)reverseKGroup(ptr1,ptr2);
if (nn!=1)ptr0->next=ptr2;
ptr1->next=ptr3;
if (nn==1) return ptr2;
else return chead;
}
void reverseKGroup(ListNode *head,ListNode *tail)
{
ListNode *ptr1=head;
ListNode *ptr2=ptr1->next;
ListNode *ptr3=ptr2->next;
while (ptr2!=NULL&&(ptr1!=tail))
{
ptr2->next=ptr1;
ptr1=ptr2;
ptr2=ptr3;
if (ptr2!=NULL) ptr3=ptr2->next;
}
}
};
|
[
"307154003@qq.com"
] |
307154003@qq.com
|
6e2f0a71474f123b25c7860ad25e766df929815f
|
580258c3959289967335bdf26638693ff7770bd8
|
/Source/Project_X_Ray/TurretHardPoint.cpp
|
a7253f6568616464877119e2368e51351827e174
|
[] |
no_license
|
Tiba3195/Project_X_Ray_Full
|
ab997659be3e0a41fad860b389a58c3c58dbe634
|
53283808b71589988217b0a1242c456bccff031e
|
refs/heads/master
| 2021-01-25T09:10:38.405054
| 2017-06-09T07:07:39
| 2017-06-09T07:07:39
| 93,795,445
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 12,219
|
cpp
|
// Fill out your copyright notice in the Description page of Project Settings.
#include "Project_X_Ray.h"
#include "TurretHardPoint.h"
#include "GlobalGameState.h"
#include "MediumTurretActor.h"
#include "LightTurretActor.h"
#include "HeavyTurretActor.h"
#include "HeavyAntiAirTurretActor.h"
#include "AntiAirTurretActor.h"
#include "DuelCannonTurretActor.h"
#include "AntiPawnTurretActor.h"
#include "PlasmaTurretActor.h"
//the turret classes that will be imported and filled with a blueprint
UClass* HeavyTurretActorClassHolder;
UClass* MediumTurretActorClassHolder;
UClass* LightTurretActorClassHolder;
UClass* HeavyAntiAirTurretActorClassHolder;
UClass* AntiAirTurretActorClassHolder;
UClass* DuelTurretActorClassHolder;
UClass* AntiPawnTurretActorClassHolder;
UClass* TurretActorClassHolder;
UClass* PlasmaTurretClassHolder;
//Names of the blueprints for checking if we can build a turret type
static FString HeavyTurretName = "/Game/Turrets/BP_HeavyTurretActor.BP_HeavyTurretActor_C";
static FString MediumTurretTurretName = "/Game/Turrets/BP_MediumTurretActor.BP_MediumTurretActor_C";
static FString LightTurretName = "/Game/Turrets/BP_LightTurretActor.BP_LightTurretActor_C";
static FString HeavyAntiAirTurretName = "/Game/Turrets/BP_HeavyAntiAirTurretActor.BP_HeavyAntiAirTurretActor_C";
static FString AntiAirTurretTurretName = "/Game/Turrets/BP_AntiAirTurretActor.BP_AntiAirTurretActor_C";
static FString DuelTurretName = "/Game/Turrets/BP_DuelCannonTurretActor.BP_DuelCannonTurretActor_C";
static FString AntiPawnTurretName = "/Game/Turrets/BP_AntiPawnTurretActor.BP_AntiPawnTurretActor_C";
static FString PlasmaTurretName = "/Game/Turrets/BP_PlasmaTurretActor.BP_PlasmaTurretActor_C";
ATurretHardPoint::ATurretHardPoint(const class FObjectInitializer& PCIP)
: Super(PCIP)
{
// Set this pawn to call Tick() every frame. You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
HardpointBase = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("HardpointBase Mesh"));
HardpointBase->SetupAttachment(RootComponent);
TurretAttachment = CreateDefaultSubobject<UTurretAttachmenttComponent>(TEXT("Turret Attachment"));
TurretAttachment->SetupAttachment(HardpointBase);
HardPointAttachment = CreateDefaultSubobject<UHardPointAttachment>(TEXT("HardPoint Attachment"));
HardPointAttachment->SetupAttachment(HardpointBase);
//TurretAttachment->SetRelativeLocation(FVector(0.0f, 0.0f, 113.179932));
UWorld* World = GetWorld();
if (World)
{
}
//importing blueprints
static ConstructorHelpers::FClassFinder<ATurretActor> TheTurret(TEXT("/Game/Turrets/BP_LightTurretActor.BP_LightTurretActor_C"));
if (TheTurret.Class != NULL)
{
LightTurretActorClassHolder = TheTurret.Class;
}
static ConstructorHelpers::FClassFinder<ATurretActor> TheTurret2(TEXT("/Game/Turrets/BP_MediumTurretActor.BP_MediumTurretActor_C"));
if (TheTurret2.Class != NULL)
{
MediumTurretActorClassHolder = TheTurret2.Class;
}
static ConstructorHelpers::FClassFinder<ATurretActor> TheTurret3(TEXT("/Game/Turrets/BP_HeavyTurretActor.BP_HeavyTurretActor_C"));
if (TheTurret3.Class != NULL)
{
HeavyTurretActorClassHolder = TheTurret3.Class;
}
static ConstructorHelpers::FClassFinder<ATurretActor> TheTurret4(TEXT("/Game/Turrets/BP_TurretActor.BP_TurretActor_C"));
if (TheTurret4.Class != NULL)
{
TurretActorClassHolder = TheTurret4.Class;
}
static ConstructorHelpers::FClassFinder<ATurretActor> TheTurret5(TEXT("/Game/Turrets/BP_HeavyAntiAirTurretActor.BP_HeavyAntiAirTurretActor_C"));
if (TheTurret5.Class != NULL)
{
HeavyAntiAirTurretActorClassHolder = TheTurret5.Class;
}
static ConstructorHelpers::FClassFinder<ATurretActor> TheTurret6(TEXT("/Game/Turrets/BP_AntiAirTurretActor.BP_AntiAirTurretActor_C"));
if (TheTurret6.Class != NULL)
{
AntiAirTurretActorClassHolder = TheTurret6.Class;
}
static ConstructorHelpers::FClassFinder<ATurretActor> TheTurret8(TEXT("/Game/Turrets/BP_DuelCannonTurretActor.BP_DuelCannonTurretActor_C"));
if (TheTurret8.Class != NULL)
{
DuelTurretActorClassHolder = TheTurret8.Class;
}
static ConstructorHelpers::FClassFinder<ATurretActor> TheTurret9(TEXT("/Game/Turrets/BP_AntiPawnTurretActor.BP_AntiPawnTurretActor_C"));
if (TheTurret9.Class != NULL)
{
AntiPawnTurretActorClassHolder = TheTurret9.Class;
}
static ConstructorHelpers::FClassFinder<ATurretActor> TheTurret10(TEXT("/Game/Turrets/BP_PlasmaTurretActor.BP_PlasmaTurretActor_C"));
if (TheTurret10.Class != NULL)
{
PlasmaTurretClassHolder = TheTurret10.Class;
}
}
ATurretHardPoint::ATurretHardPoint()
{
// Set this pawn to call Tick() every frame. You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("Root Component"));
HardpointBase = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("HardpointBase Mesh"));
HardpointBase->SetupAttachment(RootComponent);
TurretAttachment = CreateDefaultSubobject<UTurretAttachmenttComponent>(TEXT("Turret Attachment"));
TurretAttachment->SetupAttachment(HardpointBase);
//TurretAttachment->SetRelativeLocation(FVector(0.0f, 0.0f,113.179932));
HardPointAttachment = CreateDefaultSubobject<UHardPointAttachment>(TEXT("HardPoint Attachment"));
HardPointAttachment->SetupAttachment(HardpointBase);
}
void ATurretHardPoint::RegisterDelegate()
{
}
void ATurretHardPoint::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
Super::EndPlay(EndPlayReason);
}
void ATurretHardPoint::BeginPlay()
{
Super::BeginPlay();
RegisterDelegate();
UWorld* World = GetWorld();
AGlobalGameState* GS= Cast<AGlobalGameState>(World->GetGameState());
if (GS)
{
//adding the hardpoint to the gamestate and saving the index for fast lookups
int counter = GS->TurretHardPoints.Num();
HardPointIndex = counter;
GS->TurretHardPoints.Add(this);
}
// BuildTurret();
}
void ATurretHardPoint::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
}
//builds the base turret actor blueprint
void ATurretHardPoint::BuildTurret()
{
if (TurretActorClassHolder != NULL)
{
UWorld* World = GetWorld();
if (World)
{
FActorSpawnParameters SpawnParams;
//SpawnParams.Instigator = this;
ATurretActor* temp = Cast<ATurretActor>(TurretActorClassHolder->GetDefaultObject());
FVector tempV = temp->TurretAttachment->RelativeLocation;
FVector tempV2 = TurretAttachment->RelativeLocation;
FVector tempV3 = GetActorLocation() + tempV2 + tempV;
ATurretActor* NewTurret = World->SpawnActor<ATurretActor>(TurretActorClassHolder, tempV3, FRotator(0.0f, 0.0f, 0.0f), SpawnParams);
}
}
}
//builds a turret based on the name of the blueprint passed in, the name will come from the selection rose menu actor
void ATurretHardPoint::BuildTurret(FString TurretName)
{
UWorld* World = GetWorld();
if (World)
{
AGlobalGameState* GS= Cast<AGlobalGameState>(World->GetGameState());
FActorSpawnParameters SpawnParams;
if (TurretName == HeavyTurretName)
{
if (HeavyTurretActorClassHolder != NULL)
{
//getting a temp copy of this turret so we can find all the offsets, proly a much better way to do this. With an array like the muzzle offsets
AHeavyTurretActor* temp = Cast<AHeavyTurretActor>(HeavyTurretActorClassHolder->GetDefaultObject());
//finding the attachment offset for world placement
FVector tempV = temp->TurretAttachment->RelativeLocation;
FVector tempV2 = TurretAttachment->RelativeLocation;
FVector tempV3 = GetActorLocation() + tempV2 + tempV;
//spawning the turret we will se in the game
AHeavyTurretActor* NewTurret = World->SpawnActor<AHeavyTurretActor>(HeavyTurretActorClassHolder, tempV3, FRotator(0.0f, 0.0f, 0.0f), SpawnParams);
//telling the gamestae we just built a turret
GS->NewActorSpawned(NewTurret);
//cleaning up
temp->Destroy();
}
}
if (TurretName == MediumTurretTurretName)
{
if (MediumTurretActorClassHolder != NULL)
{
AMediumTurretActor* temp = Cast<AMediumTurretActor>(MediumTurretActorClassHolder->GetDefaultObject());
FVector tempV = temp->TurretAttachment->RelativeLocation;
FVector tempV2 = TurretAttachment->RelativeLocation;
FVector tempV3 = GetActorLocation() + tempV2 + tempV;
AMediumTurretActor* NewTurret = World->SpawnActor<AMediumTurretActor>(MediumTurretActorClassHolder, tempV3, FRotator(0.0f, 0.0f, 0.0f), SpawnParams);
GS->NewActorSpawned(NewTurret);
temp->Destroy();
}
}
if (TurretName == LightTurretName)
{
if (LightTurretActorClassHolder != NULL)
{
ALightTurretActor* temp = Cast<ALightTurretActor>(LightTurretActorClassHolder->GetDefaultObject());
FVector tempV = temp->TurretAttachment->RelativeLocation;
FVector tempV2 = TurretAttachment->RelativeLocation;
FVector tempV3 = GetActorLocation() + tempV2 + tempV;
ALightTurretActor* NewTurret = World->SpawnActor<ALightTurretActor>(LightTurretActorClassHolder, tempV3, FRotator(0.0f, 0.0f, 0.0f), SpawnParams);
GS->NewActorSpawned(NewTurret);
}
}
if (TurretName == HeavyAntiAirTurretName)
{
if (HeavyAntiAirTurretActorClassHolder != NULL)
{
AHeavyAntiAirTurretActor* temp = Cast<AHeavyAntiAirTurretActor>(HeavyAntiAirTurretActorClassHolder->GetDefaultObject());
FVector tempV = temp->TurretAttachment->RelativeLocation;
FVector tempV2 = TurretAttachment->RelativeLocation;
FVector tempV3 = GetActorLocation() + tempV2 + tempV;
AHeavyAntiAirTurretActor* NewTurret = World->SpawnActor<AHeavyAntiAirTurretActor>(HeavyAntiAirTurretActorClassHolder, tempV3, FRotator(0.0f, 0.0f, 0.0f), SpawnParams);
GS->NewActorSpawned(NewTurret);
temp->Destroy();
}
}
if (TurretName == AntiAirTurretTurretName)
{
if (AntiAirTurretActorClassHolder != NULL)
{
AAntiAirTurretActor* temp = Cast<AAntiAirTurretActor>(AntiAirTurretActorClassHolder->GetDefaultObject());
FVector tempV = temp->TurretAttachment->RelativeLocation;
FVector tempV2 = TurretAttachment->RelativeLocation;
FVector tempV3 = GetActorLocation() + tempV2 + tempV;
AAntiAirTurretActor* NewTurret = World->SpawnActor<AAntiAirTurretActor>(AntiAirTurretActorClassHolder, tempV3, FRotator(0.0f, 0.0f, 0.0f), SpawnParams);
GS->NewActorSpawned(NewTurret);
temp->Destroy();
}
}
if (TurretName == DuelTurretName)
{
if (DuelTurretActorClassHolder != NULL)
{
ADuelCannonTurretActor* temp = Cast<ADuelCannonTurretActor>(DuelTurretActorClassHolder->GetDefaultObject());
FVector tempV = temp->TurretAttachment->RelativeLocation;
FVector tempV2 = TurretAttachment->RelativeLocation;
FVector tempV3 = GetActorLocation() + tempV2 + tempV;
ADuelCannonTurretActor* NewTurret = World->SpawnActor<ADuelCannonTurretActor>(DuelTurretActorClassHolder, tempV3, FRotator(0.0f, 0.0f, 0.0f), SpawnParams);
GS->NewActorSpawned(NewTurret);
temp->Destroy();
}
}
if (TurretName == AntiPawnTurretName)
{
if (AntiPawnTurretActorClassHolder != NULL)
{
AAntiPawnTurretActor* temp = Cast<AAntiPawnTurretActor>(AntiPawnTurretActorClassHolder->GetDefaultObject());
FVector tempV = temp->TurretAttachment->RelativeLocation;
FVector tempV2 = TurretAttachment->RelativeLocation;
FVector tempV3 = GetActorLocation() + tempV2 + tempV;
AAntiPawnTurretActor* NewTurret = World->SpawnActor<AAntiPawnTurretActor>(AntiPawnTurretActorClassHolder, tempV3, FRotator(0.0f, 0.0f, 0.0f), SpawnParams);
GS->NewActorSpawned(NewTurret);
temp->Destroy();
}
}
if (TurretName == PlasmaTurretName)
{
if (PlasmaTurretClassHolder != NULL)
{
APlasmaTurretActor* temp = Cast<APlasmaTurretActor>(PlasmaTurretClassHolder->GetDefaultObject());
FVector tempV = temp->TurretAttachment->RelativeLocation;
FVector tempV2 = TurretAttachment->RelativeLocation;
FVector tempV3 = GetActorLocation() + tempV2 + tempV;
APlasmaTurretActor* NewTurret = World->SpawnActor<APlasmaTurretActor>(PlasmaTurretClassHolder, tempV3, FRotator(0.0f, 0.0f, 0.0f), SpawnParams);
GS->NewActorSpawned(NewTurret);
temp->Destroy();
}
}
}
}
void ATurretHardPoint::RunCommand(FString command)
{
BuildTurret(command);
}
|
[
"justin_beast@hotmail.com"
] |
justin_beast@hotmail.com
|
2efe330b86229097797fe63f9212a3e023072bae
|
baa5c2143fd1c3ac831f020037859fbc259a903f
|
/Solver/CSRMatrix.h
|
6505ea18c127411de289d07f8832b1c30643f727
|
[
"MIT"
] |
permissive
|
ntrin/Linear-Solvers
|
34e8623e917623c630131f6ec947318b46313ff3
|
7fb80defd41fc59a19290f7a12dedaf74d27bcaa
|
refs/heads/master
| 2022-12-17T13:36:16.516386
| 2020-09-24T01:24:22
| 2020-09-24T01:24:22
| 298,136,274
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,035
|
h
|
/*
* CSRMatrix.h
*
* Created on: Jan 30, 2020
* Author: Nicolas
*/
#ifndef CSRMATRIX_H_
#define CSRMATRIX_H_
#pragma once
#include "Matrix.h"
template <class T>
class CSRMatrix: public Matrix<T>
{
public:
// constructor where we want to preallocate ourselves
CSRMatrix(int rows, int cols, int nnzs, bool preallocate);
// constructor where we already have allocated memory outside
CSRMatrix(int rows, int cols, int nnzs, T *values_ptr, int *row_position, int *col_index);
// destructor
~CSRMatrix();
// Print out the values in our matrix
virtual void printMatrix();
virtual void printVector(std::vector<double>& v);
CSRMatrix<T>* transpose();
static bool Sorter(const std::pair<int, int>& left, const std::pair<int, int>& right);
void fill_random_sparse();
// Perform some operations with our matrix
CSRMatrix<T>* matMatMult(CSRMatrix<T>& B);
CSRMatrix<T>* generate_random_spd_sparse(int rows, int cols);
CSRMatrix<T>* generate_random_diagdom_sparse(int rows, int cols, double sparsity);
virtual void matVecMult(std::vector<double>& input, std::vector<double>& output);
virtual void matRowVecMult(std::vector<double>& input, std::vector<double>& output);
// Explicitly using the C++11 nullptr here
int *row_position = nullptr;
int *col_index = nullptr;
// How many non-zero entries we have in the matrix
int nnzs=-1;
virtual void Conj_Grad(std::vector<double>& b, std::vector<double>& x);
virtual void jacobi(std::vector<double>& x, const std::vector<double>& b);
virtual void Gauss_Seidel(std::vector<double>& x, const std::vector<double>& b);
virtual void sor(std::vector<double>& x, const std::vector<double>& b, double w);
CSRMatrix* Cholesky();
void LU(CSRMatrix<T>& L,std::vector<T>& b_vec, std::vector<T>& x_vec);
// Private variables - there is no need for other classes
// to know about these variables
private:
};
#endif /* CSRMATRIX_H_ */
|
[
"noreply@github.com"
] |
ntrin.noreply@github.com
|
cc3e9c0bf3097bb6e03cc0b0ef011f4d90a5291c
|
19cd9c1397558dc2c815ad10e354a8b7a7b0ea47
|
/scemi/scemi_pipes.cc
|
db8151e99a83f507ec2d5edfa58b23d77a180374
|
[
"MIT"
] |
permissive
|
Arja7/scemi_lib
|
1741898e68465d083ade38b49498ff09eee77811
|
2358f613a4defe613493a68094c313cb0f570d47
|
refs/heads/master
| 2023-06-22T06:51:37.480323
| 2019-07-13T17:25:07
| 2019-07-13T17:25:07
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 18,260
|
cc
|
#include <fcntl.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <unistd.h>
#include <inttypes.h>
#include <errno.h>
#include <cstring>
#include <string>
#include <map>
#include <queue>
#include "vpi_user.h"
#include "scemi_defines.h"
#include "scemi_pipes.h"
static unsigned char fifoi[RWBUF_SIZE];
static unsigned char fifoo[RWBUF_SIZE];
static svScope svscope = NULL, svpscope = NULL;
static bool SceMiFinish = false, data_keeper_vpi = true;
static uint32_t process_tokens(uint32_t cmd, uint32_t num_args, uint32_t idx);
static void * _scemi_pipe_c_handle( uint32_t uid );
static void scemi_data_keeper();
static void scemi_final_cleanup();
struct InBuffer {
unsigned char *buf; /* That holds data */
uint16_t lidx, idx; /* read index */
int file_id;
bool init_done;
InBuffer(unsigned char *b) {
buf = b;
lidx = idx = 0;
init_done = false;
}
void Init() {
errno = 0;
file_id = open(SVC_FIFO_R, O_RDONLY);
// DBG_PRINT("%s file_id:%d errno:%d\n", SVC_FIFO_R, file_id, errno);
assert ((-1 != file_id) && (0 == errno));
int flags = fcntl(file_id, F_GETFL, 0);
assert(0 == fcntl(file_id, F_SETFL, flags | O_NONBLOCK));
init_done = true;
}
~InBuffer() {
close(file_id);
scemi_final_cleanup();
}
void clear() {
if (lidx == idx) {
lidx = idx = 0;
return;
}
if (0 != idx) {
bcopy((char *)buf+idx, (char *)buf, lidx-idx);
lidx -= idx;
idx = 0;
}
}
bool get_token_valid(uint32_t t_idx) {
return init_done && (t_idx < lidx) && ((lidx-t_idx) >= sizeof(uint32_t));
}
uint32_t get_token(uint32_t t_idx) {
uint32_t dt=0, ui1=0;
for (; (ui1<sizeof(uint32_t)); ui1++, t_idx++) {
dt |= uint32_t(buf[t_idx])<<(ui1<<3);
}
return dt;
}
int32_t data_keeper() {
clear();
errno = 0;
int32_t count = read(file_id, buf+idx, RWBUF_SIZE-idx);
if (count < 0) {
assert(EAGAIN == errno);
return errno;
} else if (0 == count) {
return 0;
}
lidx += count;
/* We are attempting to read RWBUF_SIZE data. So
in theory lidx could be == RWBUF_SIZE. */
assert(lidx <= RWBUF_SIZE);
/* Process the data : Packet info
SCEMI_CMD, [DEST], NUM_ARGS, __VA_ARGS__
process only if you have on complete transactions
*/
do {
uint32_t cmd = get_token(idx);
uint32_t num_args = get_token(idx+sizeof(uint32_t));
if ( get_token_valid(idx+sizeof(uint32_t)) &&
get_token_valid(idx+((2/*CMD, NUM_ARGS*/+num_args-1)*sizeof(uint32_t))) ) {
idx += process_tokens(cmd, num_args, idx);
} else break;
} while (idx < lidx);
#ifndef SVC_DUT
if (svscope) {
svSetScope(svscope);
scemi_data_avail_trigger();
}
#endif
return 0;
}
uint32_t process_tokens(uint32_t cmd, uint32_t num_args, uint32_t idx);
};
struct OutBuffer {
unsigned char *buf; /* That holds data */
uint16_t idx; /* index */
int file_id;
bool init_done;
OutBuffer(unsigned char *b) {
buf = b;
idx = 0;
init_done = false;
}
void Init() {
errno = 0;
file_id = open(SVC_FIFO, O_WRONLY | O_SYNC, 0);
// DBG_PRINT("%s file_id:%d errno:%d\n", SVC_FIFO, file_id, errno);
assert ((-1 != file_id) && (0 == errno));
init_done = true;
}
~OutBuffer() {
close(file_id);
}
bool can_put(uint32_t n) {
return init_done && (((sizeof(uint32_t)*n) + idx) <= RWBUF_SIZE);
}
/* Only support integers */
void put(uint32_t v) {
/* if can't hold the value, flush */
if ((sizeof(uint32_t) + idx) > RWBUF_SIZE)
flush();
for (uint32_t ui1=0; ui1<sizeof(uint32_t); ui1++, idx++) {
buf[idx] = v >> (ui1<<3);
}
assert(idx <= RWBUF_SIZE);
}
#if 0
void put_vaargs(uint32_t n, ...) {
uint32_t dat;
va_list argp;
va_start (argp, n);
for (uint32_t ui2=0; ui2<n; ui2++) {
dat = va_arg(argp, uint32_t);
/* if can't hold the value, flush */
if ((sizeof(uint32_t) + idx) > RWBUF_SIZE)
flush();
for (uint32_t ui1=0; ui1<sizeof(uint32_t); ui1++, idx++) {
buf[idx] = dat >> (ui1<<3);
}
}
va_end(argp);
assert (idx <= RWBUF_SIZE);
}
#endif
void flush() {
if (! init_done) return;
if (idx) DBG_PRINT("Flushing Out Stream:");
for (uint32_t ui1=0; ui1<idx; ui1++) { DBG_PRINT("%3x", buf[ui1]); }
if (idx) DBG_PRINT("\n");
write(file_id, buf, idx);
idx = 0;
}
};
enum {DIR_OUT, DIR_IN};
typedef std::map<void *, void*> udata_t;
struct Pipe {
uint32_t uid;
uint16_t bytes_per_element, callback_threshold, pending_data;
uint8_t direction, auto_flush, connected;
std::queue<uint32_t> data;
std::queue<uint32_t> data_buf;
udata_t udata;
scemi_pipe_notify_callback notify_callback;
void* notify_context;
Pipe(uint32_t uid_l) {
uid = uid_l;
direction = DIR_OUT;
bytes_per_element = connected = 0;
pending_data = callback_threshold = 0;
notify_callback = NULL;
}
};
static InBuffer inbuf(fifoi);
static OutBuffer outbuf(fifoo);
typedef std::map<uint32_t, struct Pipe *> hash2path_t;
typedef std::map<uint32_t, std::string> hash2name_t;
static hash2path_t hash2path;
extern "C"
unsigned int
scemi_shash(char* s)
{
unsigned int hash = 5381;
int c;
while ((c = *s++)) {
/* hash = hash * 33 ^ c */
hash = ((hash << 5) + hash) + c;
}
return hash;
}
uint32_t
InBuffer::process_tokens(uint32_t cmd, uint32_t num_args, uint32_t idx)
{
uint32_t uid = get_token(idx+(2/*CMD, NUM_ARGS*/+1-1)*sizeof(uint32_t));
Pipe *p = (Pipe *)_scemi_pipe_c_handle(uid);
if (SCMD_CONNECT_PATH == cmd) {
assert(3 == num_args);
p->bytes_per_element = get_token(idx+(2/*CMD, NUM_ARGS*/+2-1)*sizeof(uint32_t));
p->direction = get_token(idx+(2/*CMD, NUM_ARGS*/+3-1)*sizeof(uint32_t));
DBG_PRINT("Obtained command SCMD_CONNECT_PATH: uid:%x bytes_per_element:%u p->direction:%u\n", uid, p->bytes_per_element, p->direction);
p->connected = 1;
assert(p->bytes_per_element > 0);
assert(0 == (p->bytes_per_element % sizeof(svBitVecVal)));
} else if (SCMD_DATA == cmd) {
assert(num_args > 1);
p->data.push(SCMD_DATA);
p->data.push(num_args-1); /* num args */
DBG_PRINT("Obtained command SCMD_DATA num_args:%u uid:%x", num_args, uid);
for (uint32_t t_ui1=2; t_ui1<=num_args; t_ui1++) {
uint32_t t_ui2 = get_token(idx+(2/*CMD, NUM_ARGS*/+t_ui1-1)*sizeof(uint32_t));
p->data.push(t_ui2);
DBG_PRINT(" %u:%8x", t_ui1, t_ui2);
}
DBG_PRINT("\n");
/* callback */
p->pending_data++;
if ((NULL != p->notify_callback) && (p->pending_data > p->callback_threshold)) {
(*(p->notify_callback))(p->notify_context);
}
} else if (SCMD_DATA_EOM == cmd) {
DBG_PRINT("Obtained command SCMD_DATA_EOM\n");
p->data.push(SCMD_DATA_EOM);
} else if (SCMD_FINISH == cmd) {
DBG_PRINT("Obtained command SCMD_FINISH\n");
SceMiFinish = true;
} else {
DBG_PRINT("Unknown cmd %u\n", cmd);
assert(0);
}
return (2/*CMD, ARGS*/+num_args)*sizeof(uint32_t);
}
extern "C"
PLI_INT32
scemi_data_keeper_callback
(struct t_cb_data *cbd)
{
/* */
if ( (! inbuf.init_done) || (! outbuf.init_done) ) {
scemi_data_keeper();
return 0;
}
/* housekeeping 1: flush outbuf */
int32_t ret_val = inbuf.data_keeper();
scemi_data_keeper();
if ((0 != ret_val) && (EAGAIN != ret_val)) {
DBG_PRINT("Some problem with Communications channel, Triggering Finish\n");
SceMiFinish = true;
}
/* housekeeping 2: flush outbuf */
outbuf.flush();
return 0;
}
static
void
scemi_data_keeper()
{
if (! data_keeper_vpi) return;
s_cb_data cbData;
cbData.reason = cbNextSimTime;
cbData.cb_rtn = scemi_data_keeper_callback;
cbData.time = NULL;
cbData.value = NULL;
cbData.obj = NULL;
cbData.user_data = NULL;
vpiHandle cbHandle = vpi_register_cb(&cbData);
vpi_free_object(cbHandle);
}
static
void * // return: pipe handle
_scemi_pipe_c_handle( uint32_t uid ) // input: path to HDL endpoint instance
{
/* if pipe available return the same */
hash2path_t::iterator it = hash2path.find(uid);
if (it != hash2path.end()) {
return it->second;
}
/* new object */
Pipe *p = new Pipe(uid);
hash2path.insert( std::pair<uint32_t, struct Pipe *>(uid, p) );
return p;
}
void * // return: pipe handle
scemi_pipe_c_handle( const char *endpoint_path ) // input: path to HDL endpoint instance
{
uint32_t uid = scemi_shash((char *)endpoint_path);
return _scemi_pipe_c_handle(uid);
}
svBit // return: 1 for input pipe, 0 for output pipe
scemi_pipe_get_direction( void *pipe_handle ) // input: pipe handle
{
return static_cast<struct Pipe *>(pipe_handle)->direction;
}
int // return: current depth (in elements) of the pipe
scemi_pipe_get_depth( void *pipe_handle ) // input: pipe handle
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
return (int)((RWBUF_SIZE-outbuf.idx) / p->bytes_per_element);
}
int // return: bytes per element
scemi_pipe_get_bytes_per_element( void *pipe_handle ) // input: pipe handle
{
return static_cast<struct Pipe *>(pipe_handle)->bytes_per_element;
}
svBit
scemi_pipe_set_eom_auto_flush( void *pipe_handle, svBit enabled ) // input: enable/disable
{
return static_cast<struct Pipe *>(pipe_handle)->auto_flush = enabled;
}
extern "C"
void
scemi_initialize()
{
static bool init_done = false;
/* make sure you don't init twice */
if (init_done) return;
init_done = true;
#ifdef SVC_DUT
inbuf.Init();
outbuf.Init();
#else
outbuf.Init();
inbuf.Init();
#endif
svscope = svGetScopeFromName(SVC_SV_SCOPE);
svpscope = svGetScopeFromName(SVC_SVP_SCOPE);
scemi_data_keeper();
}
static
void
scemi_final_cleanup()
{
for (hash2path_t::iterator it = hash2path.begin(); it!=hash2path.end(); it++) {
delete it->second;
}
}
extern "C"
void
scemi_pipes_finish()
{
SceMiFinish = true;
outbuf.put(SCMD_FINISH);
outbuf.put(0);
outbuf.flush();
}
void
scemi_pipe_c_send_data (
void *pipe_handle,
uint32_t data)
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
p->data_buf.push(data);
}
void
scemi_pipe_c_send_nodata (
void *pipe_handle, // input: pipe handle
int num_elements, // input: #elements to be written
svBit eom ) // input: end-of-message marker flag (and flush)
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
if (! p->connected) {
svSetScope(svpscope);
ERROR("Attempt to send to '%s' before establishing connection\n", hash2string(p->uid));
return;
}
for (uint32_t elem=0; elem<num_elements; elem++) {
/* */
uint32_t num_args = (p->bytes_per_element/sizeof(svBitVecVal)) + 1; /* UID */
outbuf.put(SCMD_DATA);
outbuf.put(num_args);
outbuf.put(p->uid);
/* */
for (uint32_t ui1=0; ui1<(p->bytes_per_element/sizeof(svBitVecVal)); ui1++) {
assert(! (p->data_buf.empty()));
outbuf.put((uint32_t)(p->data_buf.front()));
p->data_buf.pop();
}
}
/* */
if (0 != num_elements) {
if (eom && p->auto_flush) {
outbuf.put(SCMD_DATA_EOM);
outbuf.put(1);
outbuf.put(p->uid);
outbuf.flush();
}
}
}
void
scemi_pipe_c_send (
void *pipe_handle, // input: pipe handle
int num_elements, // input: #elements to be written
const svBitVecVal *data, // input: data
svBit eom ) // input: end-of-message marker flag (and flush)
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
if (! p->connected) {
ERROR("Attempt to send in pipe '%s' before establishing connection\n", hash2string(p->uid));
return;
}
for (uint32_t elem=0; elem<num_elements; elem++) {
/* */
uint32_t num_args = (p->bytes_per_element/sizeof(svBitVecVal)) + 1; /* UID */
outbuf.put(SCMD_DATA);
outbuf.put(num_args);
outbuf.put(p->uid);
/* */
for (uint32_t ui1=0; ui1<(p->bytes_per_element/sizeof(svBitVecVal)); ui1++) {
outbuf.put((uint32_t)data[ui1]);
}
}
/* */
if (0 != num_elements) {
if (eom && p->auto_flush) {
outbuf.put(SCMD_DATA_EOM);
outbuf.put(1);
outbuf.put(p->uid);
outbuf.flush();
}
}
}
int /* # elements sent */
scemi_pipe_c_try_send (
void *pipe_handle, // input: pipe handle
int byte_offset, // input: byte offset within data array
int num_elements, // input: #elements to be written
const svBitVecVal *data, // input: data
svBit eom ) // input: end-of-message marker flag
{
scemi_pipe_c_send(pipe_handle, num_elements-byte_offset, data, eom);
return num_elements;
}
void
scemi_pipe_c_flush( void *pipe_handle ) // input: pipe handle
{
outbuf.flush();
}
int
scemi_pipe_c_try_flush( void *pipe_handle ) // input: pipe handle
{
scemi_pipe_c_flush( pipe_handle );
return 1;
}
svBit // return: whether pipe is in Flush state
scemi_pipe_c_in_flush_state( void *pipe_handle ) // input: pipe handle
{
return (0 == outbuf.idx) ? 1 : 0;
}
int
scemi_pipe_c_can_send( void *pipe_handle )
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
return (DIR_OUT == p->direction) ? 1 : 0;
}
int
scemi_pipe_c_can_receive( void *pipe_handle )
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
return (DIR_IN == p->direction) ? 1 : 0;
}
void
scemi_pipe_put_user_data (
void *pipe_handle, // input: pipe handle
void *user_key, // input: user key
void *user_data ) // input: user data
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
p->udata.insert( std::pair<void *, void *>(user_key, user_data) );
}
void *
scemi_pipe_get_user_data (
void *pipe_handle, // input: pipe handle
void *user_key ) // input: user key
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
udata_t::iterator it = p->udata.find(user_key);
return (it != p->udata.end()) ? it->second: NULL;
}
uint32_t
scemi_pipe_c_receive_data ( void *pipe_handle )
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
assert (! (p->data_buf.empty()));
uint32_t ret_val = p->data_buf.front();
p->data_buf.pop();
return ret_val;
}
void
scemi_pipe_c_receive_nodata (
void *pipe_handle, // input: pipe handle
int num_elements, // input: #elements to be read
int *num_elements_valid, // output: #elements that are valid
svBit *eom ) // output: end-of-message marker flag (and flush)
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
*num_elements_valid = 0;
*eom = 0;
if ((p->data.empty()) || !(p->connected)) {
return;
}
uint32_t data_idx = 0;
do {
uint32_t cmd = p->data.front(); p->data.pop();
if (SCMD_DATA == cmd) {
uint32_t num_args = p->data.front(); p->data.pop();
for (uint32_t ui1=0; ui1<num_args; data_idx++, ui1++) {
assert(! p->data.empty());
p->data_buf.push(p->data.front());
// DBG_PRINT("Receiving data %x\n", p->data.front());
p->data.pop();
}
(*num_elements_valid)++;
assert(p->pending_data > 0);
p->pending_data--;
} else if (SCMD_DATA_EOM == cmd) {
*eom = 1;
break;
} else { /* Unknown command */
assert(0);
}
} while ((! p->data.empty()) && ((*num_elements_valid) < num_elements));
}
void
scemi_pipe_c_receive (
void *pipe_handle, // input: pipe handle
int num_elements, // input: #elements to be read
int *num_elements_valid, // output: #elements that are valid
svBitVecVal *data, // output: data
svBit *eom ) // output: end-of-message marker flag (and flush)
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
*num_elements_valid = 0;
*eom = 0;
if ((p->data.empty()) || !(p->connected)) {
return;
}
uint32_t data_idx = 0;
do {
uint32_t cmd = p->data.front(); p->data.pop();
if (SCMD_DATA == cmd) {
uint32_t num_args = p->data.front(); p->data.pop();
for (uint32_t ui1=0; ui1<num_args; data_idx++, ui1++) {
assert(! p->data.empty());
data[data_idx] = p->data.front();
// DBG_PRINT("Receiving data %x\n", p->data.front());
p->data.pop();
}
(*num_elements_valid)++;
assert(p->pending_data > 0);
p->pending_data--;
} else if (SCMD_DATA_EOM == cmd) {
*eom = 1;
break;
} else { /* Unknown command */
assert(0);
}
} while ((! p->data.empty()) && ((*num_elements_valid) < num_elements));
}
int /* # elements received */
scemi_pipe_c_try_receive (
void *pipe_handle, // input: pipe handle
int byte_offset, // input: byte offset within data array
int num_elements, // input: #elements to be read
svBitVecVal *data, // output: data
svBit *eom ) // output: end-of-message marker flag
{
int num_elem_received = 0;
/* num_elem_received is returned as byte_offset after mult with p->bytes_per_element */
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
uint32_t offset_svbitvec = byte_offset / p->bytes_per_element;
scemi_pipe_c_receive(pipe_handle, num_elements, &num_elem_received, data+offset_svbitvec, eom);
return num_elem_received;
}
scemi_pipe_notify_callback_handle
scemi_pipe_set_notify_callback (
void *pipe_handle, // input: pipe handle
scemi_pipe_notify_callback notify_callback, // input: notify callback function
void *notify_context, // input: notify context
int callback_threshold ) // input: threshold for notify callback function
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
p->notify_callback = notify_callback;
p->notify_context = notify_context;
p->callback_threshold = callback_threshold;
return pipe_handle;
}
void
scemi_pipe_clear_notify_callback (
scemi_pipe_notify_callback_handle notify_callback_handle )
{
Pipe *p = static_cast<struct Pipe *>(notify_callback_handle);
p->notify_callback = NULL;
}
void * //return: notify context object pointer
scemi_pipe_get_notify_context(
scemi_pipe_notify_callback_handle notify_callback_handle ) // input: notify handle
{
Pipe *p = static_cast<struct Pipe *>(notify_callback_handle);
return p->notify_context;
}
uint32_t
scemi_pipe_pending_data(void *pipe_handle)
{
return static_cast<struct Pipe *>(pipe_handle)->pending_data;
}
extern "C"
void
scemi_pipe_outport_configure(void *pipe_handle, int unsigned num_bits)
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
/* */
p->bytes_per_element = ((num_bits+31)/32)*sizeof(uint32_t);
p->direction = DIR_OUT;
p->connected = 1;
/* */
outbuf.put(SCMD_CONNECT_PATH);
outbuf.put(3);
outbuf.put(p->uid);
outbuf.put(p->bytes_per_element);
outbuf.put(p->direction);
}
extern "C"
void
scemi_pipe_inport_configure(void *pipe_handle, int unsigned num_bits)
{
Pipe *p = static_cast<struct Pipe *>(pipe_handle);
/* */
p->bytes_per_element = ((num_bits+31)/32)*sizeof(uint32_t);
p->direction = DIR_IN;
p->connected = 1;
/* */
outbuf.put(SCMD_CONNECT_PATH);
outbuf.put(3);
outbuf.put(p->uid);
outbuf.put(p->bytes_per_element);
outbuf.put(p->direction);
}
|
[
"narenkn@gmail.com"
] |
narenkn@gmail.com
|
d9081df9b3eb0fd4eb59a31a21a610fe9d0c4dfa
|
e21a933f4c455ed36aedace59c100feabb390bce
|
/regexp_matcher.h
|
dd6de29eff8fcc8e08c5e22bd6a4ae73e3d178f9
|
[] |
no_license
|
smokys123/PL_hw1
|
e868b6f314f22575f9fd4023dd10e927d8b806ea
|
c3f1078559071e0a1b43069e8159bf818aff7ff5
|
refs/heads/master
| 2021-01-21T18:33:54.804709
| 2017-05-24T06:32:23
| 2017-05-24T06:32:23
| 92,058,954
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,811
|
h
|
// PL homework: hw2
// regexp_matcher.h
#ifndef _PL_HOMEWORK_REGEXP_MATCHER_H_
#define _PL_HOMEWORK_REGEXP_MATCHER_H_
#include <vector>
#include <string>
#include <map>
#include <set>
#include <stack>
using namespace std;
struct FSATableElement {
int state;
int next_state;
char str;
};
struct RegExpMatcher {
// Design your RegExpMatcher structure
map<pair<set<int>, char>, set<int> > FSA;
set<int> accept;
set<int> init_state;
};
// Homework 1.3
bool BuildRegExpMatcher(const char* regexp, RegExpMatcher* regexp_matcher);
// Homework 1.3
bool RunRegExpMatcher(const RegExpMatcher& regexp_matcher, const char* str);
vector<int> FindOR(const char* str, int start, int end);
int BuildNFA(const char*regexp, int state, vector<FSATableElement>* FSA_table, int start_str, int end_str);
void pushNFAelement(vector<FSATableElement>* FSA_table, char input_symbol, int state, int next_state);
bool CheckRegexp(const char* regexp); //check correct regexp
void SetStarProduction(vector<FSATableElement>* FSA_table, stack<pair<int,int> > pairs);
int CalculNextState(vector<int> state_list);
vector<int >findAllAccept(vector<FSATableElement>& elements, int accept);
bool NFAtoDFA1(const std::vector<FSATableElement>& elements, const std::vector<int>& accept_states, RegExpMatcher* fsa);
vector<pair<int,int> > FindAllEpsilon1(const std::vector<FSATableElement>& elements);
vector<FSATableElement> FindState1(const std::vector<FSATableElement>& elements);
set<int> StatebyEplison1(vector<pair<int,int> >& EpsilonState, set<int>& next_state,int state);
bool PrintFSAelements1(set<int> state, set<int>next_states, char symbol);
bool MoveToNextState(const RegExpMatcher& regexp_matcher, set<int>& curstate, const char symbol);
bool CheckSymbols(const char str);
#endif //_PL_HOMEWORK_REGEXP_MATCHER_H_
|
[
"smkoy123@hanyang.ac.kr"
] |
smkoy123@hanyang.ac.kr
|
8152d0c0609e7ee3f1235a44439ec06b71312db2
|
b7d730a231a94e2efb220ed6252c1c6f14eb0070
|
/gestionnaire_ordre.cpp
|
5329784f22dc2fc0de502a79dccca919d94f57ac
|
[] |
no_license
|
sebangi/serveur_afficheur
|
dd71ee3fd61f2f57cd0e06c8a7ba5154b2ef0b48
|
8f3dbd3823bdaf2698d7cd2d1406a8ee16ff9c09
|
refs/heads/master
| 2021-05-15T14:03:35.264571
| 2017-11-13T07:53:02
| 2017-11-13T07:53:02
| 106,415,541
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 6,217
|
cpp
|
/** \file gestionnaire_ordre.cpp
* \brief Fichier d'implรฉmentation de la classe GestionnaireOrdre.
* \author Sรฉbastien Angibaud
*/
#include "gestionnaire_ordre.h"
#include "afficheur_interface.h"
#include "message_afficheur.h"
#include <iostream>
/** --------------------------------------------------------------------------------------
* \brief Constructeur de la classe GestionnaireOrdre.
*/
GestionnaireOrdre::GestionnaireOrdre()
{
}
/** --------------------------------------------------------------------------------------
* \brief Traite un ordre donnรฉ.
* \param mess L'ordre ร traiter.
* \return Le message ร renvoyer au client.
*/
MessageClient GestionnaireOrdre::traiterOrdre(const MessageClient &mess)
{
MessageClient result;
if ( mess.valide() )
{
std::cout << "traitement du message nยฐ" << mess.numero() << std::endl;
std::cout << "\t- ordre = " << mess.ordre().toStdString() << std::endl;
if ( mess.a_parametre() )
std::cout << "\t- parametre = " << mess.parametre().toStdString() << std::endl;
if ( mess.ordre().compare("AFFICHER") == 0 )
result = traiterOrdreAfficher(mess);
else if ( mess.ordre().compare("COULEUR") == 0 )
result = traiterOrdreCouleur(mess);
}
else
{
std::cout << "message invalide : pas de traitement de : " << mess.texte().toStdString() << std::endl;
result = MessageClient(0,"message invalide : " + mess.texte());
}
return result;
}
/** --------------------------------------------------------------------------------------
* \brief Traitement d'un ordre d'affichage.
* \param mess Le message client reรงu.
* \return Le message ร renvoyer au client.
*/
MessageClient GestionnaireOrdre::traiterOrdreAfficher(const MessageClient &mess)
{
if ( AfficheurInterface::instance()->connexionEtablie() )
{
if ( mess.a_parametre() )
{
AfficheurInterface::instance()->envoyerMessage( mess );
return MessageClient(mess.numero(),"Le message a ete envoye ร l'afficheur.");
}
else
return MessageClient(mess.numero(),"Erreur : Le message ร envoyer est vide.");
}
else
return MessageClient(mess.numero(),"Erreur : le serveur n'est pas connecte a l'afficheur.");
}
/** --------------------------------------------------------------------------------------
* \brief Traitement d'un ordre de choix de couleur.
* \param mess Le message client reรงu.
* \return Le message ร renvoyer au client.
*/
MessageClient GestionnaireOrdre::traiterOrdreCouleur(const MessageClient &mess)
{
bool result = AfficheurInterface::instance()->setCouleur( mess );
if ( result )
return MessageClient(mess.numero(),"Le message a ete envoye ร l'afficheur.");
else
return MessageClient(mess.numero(),"Le choix de couleur n'est pas conforme.");
}
/** --------------------------------------------------------------------------------------
* \brief Traitement d'un ordre d'initialisation d'une variable de type String.
* \param mess Le message client reรงu.
* \return Le message ร renvoyer au client.
*/
MessageClient GestionnaireOrdre::traiterSetStringVariable(const MessageClient &mess)
{
if ( mess.a_parametre() )
if ( mess.nb_parametres() == 2 )
{
m_string_variables[ mess.parametre(0) ] = mess.parametre(1);
return MessageClient(mess.numero(),"L'initialisation est effectuรฉe.");
}
return MessageClient(mess.numero(),"La demande d'initialisation n'est pas au bon format.");
}
/** --------------------------------------------------------------------------------------
* \brief Traitement d'un ordre d'initialisation d'une variable de type int.
* \param mess Le message client reรงu.
* \return Le message ร renvoyer au client.
*/
MessageClient GestionnaireOrdre::traiterSetIntVariable(const MessageClient &mess)
{
if ( mess.a_parametre() )
if ( mess.nb_parametres() == 2 )
{
m_int_variables[ mess.parametre(0) ] = mess.parametre(1).toInt();
return MessageClient(mess.numero(),"L'initialisation est effectuรฉe.");
}
return MessageClient(mess.numero(),"La demande d'initialisation n'est pas au bon format.");
}
/** --------------------------------------------------------------------------------------
* \brief Traitement d'un ordre d'accรจs ร une variable de type String.
* \param mess Le message client reรงu.
* \return Le message ร renvoyer au client.
*/
MessageClient GestionnaireOrdre::traiterGetStringVariable(const MessageClient &mess)
{
if ( mess.a_parametre() )
if ( mess.nb_parametres() == 1 )
{
std::map<QString, QString>::iterator it = m_string_variables.find( mess.parametre(0) );
if ( it == m_string_variables.end() )
return MessageClient(mess.numero(),"La variable demandรฉe n'existe pas.");
else
{
std::vector<QString> l;
l.push_back( it->second );
return MessageClient(mess.numero(),"GET",l);
}
}
return MessageClient(mess.numero(),"La demande d'accรจs n'est pas au bon format.");
}
/** --------------------------------------------------------------------------------------
* \brief Traitement d'un ordre d'accรจs ร une variable de type Int.
* \param mess Le message client reรงu.
* \return Le message ร renvoyer au client.
*/
MessageClient GestionnaireOrdre::traiterGetIntVariable(const MessageClient &mess)
{
if ( mess.a_parametre() )
if ( mess.nb_parametres() == 1 )
{
std::map<QString, int>::iterator it = m_int_variables.find( mess.parametre(0) );
if ( it == m_int_variables.end() )
return MessageClient(mess.numero(),"La variable demandรฉe n'existe pas.");
else
{
std::vector<QString> l;
l.push_back( QString::number(it->second) );
return MessageClient(mess.numero(),"GET",l);
}
}
return MessageClient(mess.numero(),"La demande d'accรจs n'est pas au bon format.");
}
|
[
"sebastien_angibaud@yahoo.fr"
] |
sebastien_angibaud@yahoo.fr
|
e849471865cf714e2f8d7b05428a498c391c2197
|
5241a49fc86a3229e1127427146b5537b3dfd48f
|
/src/Sparrow/App/CommandLineOptions.h
|
0ea5a73a08eabb0425b26febd004f02a347182ff
|
[
"BSD-3-Clause"
] |
permissive
|
qcscine/sparrow
|
05fb1e53ce0addc74e84251ac73d6871f0807337
|
f1a1b149d7ada9ec9d5037c417fbd10884177cba
|
refs/heads/master
| 2023-05-29T21:58:56.712197
| 2023-05-12T06:56:50
| 2023-05-12T06:56:50
| 191,568,488
| 68
| 14
|
BSD-3-Clause
| 2021-12-15T08:19:47
| 2019-06-12T12:39:30
|
C++
|
UTF-8
|
C++
| false
| false
| 4,650
|
h
|
/**
* @file
* @copyright This code is licensed under the 3-clause BSD license.\n
* Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group.\n
* See LICENSE.txt for details.
*/
#ifndef SPARROW_COMMANDLINEOPTIONS_H
#define SPARROW_COMMANDLINEOPTIONS_H
#include <memory>
#include <ostream>
namespace Scine {
namespace Core {
class Log;
} // namespace Core
namespace Utils {
class Settings;
} // namespace Utils
namespace Sparrow {
/**
* @brief Class to parse the command line options for non-default options and passes them to a Util::Settings class.
* This class uses the pImpl idiom to hide the boost::program_options dependency.
*/
class CommandLineOptions {
public:
/**
* @brief Class constructor, parses the command line arguments and maps them to the according setting.
* @param argv the vector with the argument strings.
* @param argc the number of arguments.
*/
CommandLineOptions(int argc, char* argv[]);
~CommandLineOptions();
/** @brief returns the command call used to run the program. */
std::string getCallStatement() const;
/** @brief returns whether the help flag option has been set. */
bool helpRequired() const;
/** @brief returns whether the matrices should be saved as files. */
bool outputToFileRequired() const;
/** @brief returns the method name given as command-line argument. */
std::string getSelectedMethodName() const;
/** @brief returns the xyz file containing the coordinates with the desired structures. */
std::string getStructureCoordinatesFile() const;
/** @brief returns the desired calculation description. */
std::string getCalculationDescription() const;
/** @brief returns the desired verbosity of the logging. */
std::string getLoggerVerbosity() const;
/** @brief returns the name of the file where the logging should be printed. */
std::string getLogFilename() const;
/** @brief returns the desired number of orbital steers. */
int getNumberOfOrbitalSteers() const;
/** @brief returns whether the gradients have to be computed. */
bool gradientRequired() const;
/** @brief returns whether the hessian matrix has to be computed. */
bool hessianRequired() const;
/** @brief returns whether the atomic Hessians have to be computed. */
bool atomicHessiansRequired() const;
/** @brief returns whether the bond order matrix has to be computed. */
bool bondOrdersRequired() const;
/** @brief returns whether the normal modes output is printed or suppressed. */
bool suppressNormalModes() const;
/** @brief returns whether an excited states calculation has to be performed. */
bool excitedStatesRequired() const;
/** @brief returns whether an orbital steering calculation has to be performed. */
bool orbitalSteeringRequired() const;
/** @brief returns whether the wavefunction output is printed as a molden file. */
bool wavefunctionRequired() const;
/** @brief returns whether the thermochemical properties are calculated. */
bool thermochemistryRequired() const;
/** @brief returns whether the excited state basis needs to be pruned. */
bool pruneBasis() const;
/** @brief updates a logger with the verbosity parsed from the command line. */
void updateLogger(Core::Log& log) const;
/** @brief updates a setting with the option parsed from the command line. */
void updateSettings(Utils::Settings& settingsToUpdate) const;
/** @brief updates the excited states setting with the option parsed from the command line. */
void updateExcitedStatesSettings(Utils::Settings& settingsToUpdate) const;
/** @brief updates the orbital steering setting with the option parsed from the command line. */
void updateOrbitalSteeringSettings(Utils::Settings& settingsToUpdate) const;
/** @brief prints the help message. */
void printHelp(std::ostream& out) const;
private:
struct Impl;
std::unique_ptr<Impl> pImpl_;
/// @brief Parses the command line to generate a call statement.
std::string generateCallStatement(int argc, char* argv[]) const;
/// templated function to allow using with string and const char pointers as argument.
/// Checks whether the option given by optionIdentifier can be used in the corresponding settings.
template<class CharType>
bool validOptionToSet(CharType optionIdentifier, const Utils::Settings& settings) const;
/// Combines two character types to form a single const char*.
template<class CharPtrType, class StringType>
std::string combineNamesForOptions(CharPtrType nameOfOption, StringType abbreviatedOption) const;
};
} // namespace Sparrow
} // namespace Scine
#endif // SPARROW_COMMANDLINEOPTIONS_H
|
[
"scine@phys.chem.ethz.ch"
] |
scine@phys.chem.ethz.ch
|
d42f35ba441ed81032ef76ff4cc018ff61e2aba6
|
4244b498b3bd674b535d35da38b2ac80adf424ca
|
/Dynamic Programming/Longest Increasing Subsequence.cpp
|
3f18de903a86d4329f2681b7d39e0ae4a508f73c
|
[] |
no_license
|
rachitgupta98/competitive-programming
|
9064cafa79696f069ea582152c9b08aa3cd12280
|
b7af0c87f6d1a2ad97a9e8460715c463f2d40713
|
refs/heads/master
| 2022-08-21T19:20:24.421999
| 2022-08-19T11:29:02
| 2022-08-19T11:29:02
| 204,412,121
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 712
|
cpp
|
//Time Complexity is o(n^2)
#include <bits/stdc++.h>
using namespace std;
int main(){
int n=5;
int arr[n] = {2,4,6,1,4};
vector<vector<int>>R(n);
R[0].push_back(arr[0]);
for(int i=1;i<n;i++){
for(int j=0;j<i;j++){
if((arr[i] > arr[j]) && (R[i].size() < R[j].size()+1)){
R[i] = R[j];
}
}
R[i].push_back(arr[i]);
}
// extracting the bigger size arr in adjacency list
vector<int>res = R[0];
for(vector<int>x : R){
if(x.size() > res.size()){
res = x;
}
}
// output the longest increasing subsequence
for(auto y : res){
cout<< y <<" ";
}
return 0;
}
|
[
"rachit371@gmail.com"
] |
rachit371@gmail.com
|
b080b223a919a845787503a33a0650ee5e53e46c
|
240259adb5fd085aecac513b73e316d869a4f877
|
/CodeJam_qualification_2021/Reversort_Engineering.cpp
|
73980276199177163d5f3d4c1de09af2bddd5811
|
[] |
no_license
|
sumandutta8877/CP
|
11aba5a77d6494aff314a522ec82d680415f31b0
|
dbdf74cd1759bfaf1e8605b1f0d7b49c0e6fa83c
|
refs/heads/main
| 2023-05-29T07:44:55.236913
| 2021-06-20T07:46:05
| 2021-06-20T07:46:05
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,094
|
cpp
|
//! โญโโโโฎโฑโฑโฑโฑโฑโฑโฑโฑโญโฎโฑโฑโฑโญโโโโณโโโโฎ
//! โโญโโฎโโฑโฑโฑโฑโฑโฑโฑโญโฏโฐโฎโฑโฑโโญโโฎโโญโโฎโ
//? โโโฑโโฃโโณโณโโโณโโปโฎโญโโโโซโโโโฃโฏโญโฏโ
//? โโฐโโฏโโญโโซโญโฎโโญโฎโโโโญโฎโโโโโโฑโโญโฏ
//? โโญโโฎโโโโโฐโฏโโญโฎโโฐโซโฐโฏโโฐโโฏโโฑโโ
//? โฐโฏโฑโฐโปโฏโฐโปโโฎโฃโฏโฐโปโโปโโโปโโโโฏโฑโฐโฏ
//* โฑโฑโฑโฑโฑโฑโฑโญโโฏโ
//* โฑโฑโฑโฑโฑโฑโฑโฐโโโฏ
#include <bits/stdc++.h>
using namespace std;
#define fo(i, a, n) for (i = a; i < n; i++)
#define ll long long
#define deb(x) cout << #x << '=' << x << endl
#define deb2(x, y) cout << #x << '=' << x << ',' << #y << '=' << y << endl
#define clr(x) memset(x, 0, sizeof(x))
#define PI 3.1415926535897932384626
#define pb push_back
//===========================
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<vl> vvl;
//=======================
const int MOD = 1'000'000'007;
const int N = INT_MAX, M = N;
//=======================
void solve()
{
int i, j, c, n, m, k;
ll temp = 0, flag = 1;
cin >> n >> c;
if (c < n - 1)
{
cout << "IMPOSSIBLE" << endl;
return;
}
vl A;
c -= n - 1;
for (i = n - 1; i >= 1; i--)
{
if (c - i >= 0)
{
A.pb(i);
c -= i;
}
}
if (c)
{
cout << "IMPOSSIBLE" << endl;
return;
}
vi ans(n);
fo(i, 0, n)
{
ans[i] = i + 1;
}
reverse(A.begin(), A.end());
for (auto x : A)
{
// cout << x << " ";
reverse(ans.end() - x - 1, ans.end());
}
// cout << endl;
fo(i, 0, n)
{
cout << ans[i] << " ";
}
cout << endl;
}
int main()
{
int t = 1;
cin >> t;
int k = 1;
while (t--)
{
cout << "Case #" << k << ": ";
solve();
k++;
}
return 0;
}
//=======================
|
[
"dbdibyendu5@gmail.com"
] |
dbdibyendu5@gmail.com
|
3cf3bd0a3bfd5f234d0bcb1f4b2f52dcc67bfad0
|
339f0cadee47775edc9e18cb9202b1ca75f3f7c7
|
/lab_2/CMPSC 122 - Lab 2 - Histogram/histogram.cpp
|
5adbb51402e4cddd4b13a21cf83056c5b22bb21b
|
[] |
no_license
|
christophercarney/intermediate-programming
|
ec7df0ba123549321320b190033a7be801862edf
|
6350b9ebaa94d19caaa04623510d742fe005a3a7
|
refs/heads/master
| 2021-06-04T21:04:00.988368
| 2016-08-24T15:25:54
| 2016-08-24T15:25:54
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,807
|
cpp
|
//Programmer: Christopher Carney
//Section: 2
//Lab: 2
//Date: January 24, 2014
//Description: This program takes numbers in an array of a specified
// length and creates a histogram of data visually of
// different length bars in a data range and shows the
// frequency of the data in that range.
#include <iostream>
#include <iomanip>
using namespace std;
const int MAX_VALS = 100; //constant for the max number of categories in a histogram
void generateHistogram(double data[], double highBound, double lowBound, int intervals, int logicalSize)
//PRE: data[0..logicalSize-1] is initialized
// highBound > lowBound
// intervals > 0
// logicalSize > 0, logicalSize is the number of data points in data[]
//POST: one asterik (*) has been printed for all values within data[0..logicalSize-1] for all k s.t.
// lowBound <= k <= highBound
// a histogram has been printed with lines of output == intervals, each line begins with the bounds
// of input for each category
// intervals is the even spacing between the lowBound and highBound
// frequency amount in data range is printed next to the last asterik in a row in parenthesis
{
double arrayIntervals[MAX_VALS]; //the intervals for the histogram starting at lowBound and
// ending at highBound
int arrayFrequency[MAX_VALS]; //a parallel array to arrayIntervals which contains the freq.
// of a value in the corresponding subscript to the interval
double deltaX; // space between each interval from lowBound to highBound
//PROCESS
deltaX = (highBound - lowBound) / intervals; //basic "change in" formula
//initialize the values in arrayFrequency[0..intervals-1] = 0
for (int i = 0; i < intervals; i++)
{
arrayFrequency[i] = 0;
}
//set arrayIntervals[0...intervals] to the data range according to deltaX
for (int i = 0; i <= intervals; i++)
{
if (i == 0) //arrayIntervals[0] is always lowBound
arrayIntervals[i] = lowBound;
else if (i == intervals) //arrayIntervals[intervals] = last interval, it is the highBound
arrayIntervals[i] = highBound;
else //subscripts in arrayIntervals[0..intervals] = deltaX apart
arrayIntervals[i] = arrayIntervals[i-1] + deltaX;
}
//go through the values of data[0..logicalSize - 1] and determine the frequency in each interval
for (int i = 0; i < logicalSize; i++)
{
//check the value of data[i] against the ranges of arrayIntervals[0..intervals - 1] to
// see if it is in that data range
for (int b = 0; b < intervals; b++)
{
if (data[i] >= arrayIntervals[b] && data[i] < arrayIntervals[b + 1])
arrayFrequency[b]++; //data[i] fits the data range then increment the
// frequency of that interval by 1
}
}
//OUTPUT
//outputs lines equal to the number of intervals, their data ranges, an aseterisks for every
// value within the range, and the frequency
for (int i = 0; i < intervals; i++)
{
cout.precision(2); //always show atleast 2 decimal places
cout << fixed << setw(7) << arrayIntervals[i] << " to "; //outputs intervals with
cout << fixed << setw(7) << arrayIntervals[i + 1] << " : "; // appropriate whitespace
//outputs 1 asterisks the numer in arrayFrequency[i], so arrayFrequency[i] = 3, outputs ***
for (int b = 0; b < arrayFrequency[i]; b++)
{
cout << "*";
}
cout << " (" << arrayFrequency[i] << ") \n"; //outputs the frequency at the end of a bar
}
cout << endl;
}
int main()
{
double exampleDataOne[] = { 0, 2, 3.8, 5, 9, 16, 16.2,
17, 18, 19, 19.5 }; //data set test
double exampleDataTwo[] = { -2.3, -5, -4.2, 0.7, 6, 9.9,
-9.3, 8.4, 5.5, 3, 1, 0,
8.9, 2.4, -7.3, -1.1, -3,
5, 3.8, 4.4 }; //user generated data set
//INPUT
cout << "Histogram for original data set: \n";
generateHistogram(exampleDataOne, 20, 0, 5, 11);
cout << "Histogram for second data set: \n";
generateHistogram(exampleDataTwo, 10, -10, 10, 20);
cout << "Histogram for modified parameters on second data set: \n";
generateHistogram(exampleDataTwo, 7, -4, 8, 20);
return 0;
}
|
[
"crc5464@psu.edu"
] |
crc5464@psu.edu
|
58291cfb650f8e95490e580d5d3f3aa43cca87b3
|
d6a27f3d563073337dbe1a91e4c6c927ffe1632b
|
/include/loco/contact_detection/ContactDetectorFeedThrough.hpp
|
3b003884103e2de12b4010716865af43388176a6
|
[
"BSD-3-Clause"
] |
permissive
|
YC-collection/loco
|
c4f808115b893a3147f295710eddeacc5c22bc74
|
f76a4ee2c0f6e44a3be33bafd23f107fcfba9480
|
refs/heads/master
| 2020-12-24T09:15:13.371496
| 2014-12-12T01:07:11
| 2014-12-12T01:07:11
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,345
|
hpp
|
/*****************************************************************************************
* Software License Agreement (BSD License)
*
* Copyright (c) 2014, Christian Gehring, Pรฉter Fankhauser, C. Dario Bellicoso, Stelian Coros
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Autonomous Systems Lab nor ETH Zurich
* 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 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* ContactDetectorFeedThrough.h
*
* Created on: May 26, 2014
* Author: gech
*/
#ifndef LOCO_CONTACTDETECTORFEEDTHROUGH_H_
#define LOCO_CONTACTDETECTORFEEDTHROUGH_H_
#include "loco/contact_detection/ContactDetectorBase.hpp"
namespace loco {
class ContactDetectorFeedThrough: public ContactDetectorBase {
public:
ContactDetectorFeedThrough();
virtual ~ContactDetectorFeedThrough();
virtual bool initialize(double dt);
virtual bool advance(double dt);
};
} /* namespace loco */
#endif /* CONTACTDETECTORFEEDTHROUGH_H_ */
|
[
"gehrinch@ethz.ch"
] |
gehrinch@ethz.ch
|
5f5f433c6b8087e4c7f9f95649b0e7332cd1437e
|
2cd0803ba1e648d591cb3bae11e879de179f0f93
|
/Contests/Virtual Judge/ShengSaiXunLian02/4.cc
|
f9dc968b97faea80cb6c005f7f454820852fe1e6
|
[
"MIT"
] |
permissive
|
DCTewi/CodeWorkspace
|
62e323fc126d92c9e20c711cae4bac9220907e64
|
9904f8057ec96e21cbc8cf9c62a49658a0f6d392
|
refs/heads/master
| 2023-05-31T23:46:55.126704
| 2021-06-23T12:11:45
| 2021-06-23T12:11:45
| 175,194,197
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 917
|
cc
|
//B duipai
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int ans = 0;
int check(string a, int l)
{
int len = 0;
string na;
for (int i = l; i >= 0; i--)
{
if (a[i] == '(') na += ')';
else if (a[i] == ')') na += '(';
else na += a[i];
}
for (int i = l + 1; i < a.size(); i++)
{
na += a[i];
}
for (int i = 1; i < na.size(); i++)
{
if (na[i] == ')' && na[i - 1] == ':')
{
len++;
}
}
return len;
}
int checkif(string a, int wanna)
{
for (int i = 0; i < a.size(); i++)
{
if (check(a, i) == wanna)
{
return i;
}
}
}
int main()
{
string a; cin>>a;
for (int i = 0; i < a.size(); i++)
{
ans = max(ans, check(a, i));
}
cout<<ans<<endl;
cout<<checkif(a, ans)<<endl;
return 0;
}
|
[
"dctewi@dctewi.com"
] |
dctewi@dctewi.com
|
656027f26ff11e3656157b5f371e7f7b08830ad7
|
198806ccd0b5a7d476c701be5943e9a7afacb7d0
|
/xdaq/include/jal/jtagSVFSequencer/JTAGSVFCommandFrequency.h
|
efc1942571dc29317a3132759e50d7ab1366bb21
|
[] |
no_license
|
marcomuzio/EMULib_CLCT_Timing
|
df5999b5f1187725d7f5b6196ba566045ba60f55
|
04e930d46cadaa0c73b94a0c22e4478f55fac844
|
refs/heads/master
| 2021-01-16T13:47:26.141865
| 2014-08-14T12:04:33
| 2014-08-14T12:04:33
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,415
|
h
|
/**
* @class JTAGSVFCommandFrequency
*
* @short JTAG SVF Frequency command.
* Sets the maximum frequency in Hz.
*
* @see ---
* @author Hannes Sakulin
* $Revision: 1.1 $
* $Date: 2007/03/27 07:59:09 $
*
*
**/
#ifndef jal_JTAGSVFCommandFrequency_H
#define jal_JTAGSVFCommandFrequency_H
#include "jal/jtagSVFSequencer/JTAGSVFCommand.h"
#include "jal/jtagSVFSequencer/JTAGSVFChain.h"
namespace jal {
class JTAGSVFCommandFrequency : public JTAGSVFCommand {
public:
/// constructor
/// @param f is the frequency in Hz or -1. if the frequency should be set back to the default.
JTAGSVFCommandFrequency(double f) :
_frequency(f) {};
/// destructor.
virtual ~JTAGSVFCommandFrequency() {};
/// execute the command. returns true if successful, false if not.
virtual bool execute (JTAGSVFChain& svf_ch) const
throw(jal::HardwareException,
jal::TimeoutException,
jal::OutOfRangeException,
jal::SVFSyntaxException) {
svf_ch.setFrequency ( _frequency );
return true;
};
protected:
virtual std::ostream& display(std::ostream& os) const {
if (_frequency != -1.)
os << "Command FREQUENCY " << _frequency << " Hz" << std::endl;
else
os << "Command FREQUENCY. (return to original frequency) " << std::endl;
return os;
}
double _frequency;
};
}
#endif
|
[
"hogenshpogen@gmail.com"
] |
hogenshpogen@gmail.com
|
0c1a2ab292d52e84fb37d6c9ccbadfa01cd80dd7
|
34efeca8e6aaa1f28a88140d41b44bdbeb31b10f
|
/GUIInternal/GUIInternal.cpp
|
f9fc75cd5588b0a1db4aae8cb98e9e797e827315
|
[] |
no_license
|
arunmudhaliar/GEAR_Alpha
|
e1b7abc68bcba2582f2e6bbb38a55e808aa1d3b3
|
55120e1cdc71f833cf5a05c4830177e7ecd8c9ff
|
refs/heads/master
| 2020-12-20T23:39:19.189604
| 2015-06-24T20:58:05
| 2015-06-24T20:58:05
| 13,659,721
| 0
| 0
| null | 2015-06-24T20:58:05
| 2013-10-17T20:03:21
|
C++
|
UTF-8
|
C++
| false
| false
| 21,480
|
cpp
|
// GUIInternal.cpp : Defines the entry point for the application.
//
//#ifndef USEMONOENGINE
#pragma comment(lib,"GEAREngine.lib")
//#endif
#include "stdafx.h"
#include "GUIInternal.h"
#include "GEAREditor\EditorApp.h"
//#include "../GEAREngine/src/core/Timer.h"
#include <WindowsX.h>
#include <ShlObj.h>
#ifdef _DEBUG
#define ENABLE_MEMORY_CHECK
#include <crtdbg.h>
#endif
#if DEPRECATED
#include "MDragGropInterface.h"
#include "GEAREditor\win32\MDropSource.h"
#include "GEAREditor\win32\eventHook.h"
#include "GEAREditor\secondryViews\geColorDlg.h"
#include <direct.h>
#include <Commdlg.h>
#ifdef _DEBUG
#define ENABLE_MEMORY_CHECK
#include <crtdbg.h>
#endif
#define MAX_LOADSTRING 100
// Global Variables:
HINSTANCE hInst; // current instance
TCHAR szTitle[MAX_LOADSTRING]; // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name
EditorApp m_cEditorApp;
//#if DEPRECATED
MDragDropInterface* m_cDropTargetInterfacePtr=NULL; //must not delete this pointer
//#endif
// Forward declarations of functions included in this code module:
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK Proj_DlgProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
char* browseFolder(HWND hWndParent, const char* title, const char* root_dir=NULL);
LPITEMIDLIST convertPathToLpItemIdList(const char *pszPath);
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
#if defined(_DEBUG) && defined(ENABLE_MEMORY_CHECK)
_CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_CHECK_ALWAYS_DF);
_CrtSetReportMode ( _CRT_ERROR, _CRTDBG_MODE_DEBUG);
//SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS);
SymInitialize(GetCurrentProcess(), NULL, TRUE);
#endif
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// TODO: Place code here.
MSG msg;
HACCEL hAccelTable;
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_GUIINTERNAL, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization:
if (!InitInstance (hInstance, SW_SHOWMAXIMIZED/*nCmdShow*/))
{
return FALSE;
}
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_GUIINTERNAL));
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
//
// FUNCTION: MyRegisterClass()
//
// PURPOSE: Registers the window class.
//
// COMMENTS:
//
// This function and its usage are only necessary if you want this code
// to be compatible with Win32 systems prior to the 'RegisterClassEx'
// function that was added to Windows 95. It is important to call this function
// so that the application will get 'well formed' small icons associated
// with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX 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_GUIINTERNAL));
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = MAKEINTRESOURCE(IDC_GUIINTERNAL);
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
static TCHAR szAppName2[] = TEXT ("childWnd");
WNDCLASSEX childWndClass;
childWndClass.cbSize = sizeof(WNDCLASSEX);
childWndClass.style = CS_HREDRAW | CS_VREDRAW;
childWndClass.lpfnWndProc = geSecondryView::SecondryView_DlgProc;
childWndClass.cbClsExtra = 0;
childWndClass.cbWndExtra = 0;
childWndClass.hInstance = hInstance;
childWndClass.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_GUIINTERNAL));
childWndClass.hCursor = LoadCursor (NULL, IDC_ARROW);
childWndClass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH);
childWndClass.lpszMenuName = NULL;
childWndClass.lpszClassName = szAppName2;
childWndClass.hIconSm = LoadIcon(childWndClass.hInstance, MAKEINTRESOURCE(IDI_SMALL));
if (!RegisterClassEx(&childWndClass))
{
MessageBox (NULL, TEXT ("This program requires Windows 95/98/NT"),
szAppName2, MB_ICONERROR);
return NULL;
}
return RegisterClassEx(&wcex);
}
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HWND hWnd;
hInst = hInstance; // Store instance handle in our global variable
hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
return TRUE;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
switch (message)
{
case WM_CREATE:
{
char current_working_directory[1024];
GetCurrentDirectory(sizeof(current_working_directory), current_working_directory);
geUtil::convertPathToUnixFormat(current_working_directory);
EditorApp::setAppDirectory(current_working_directory);
monoWrapper::initDebugConsole();
monoWrapper::loadMonoModules();
m_cDropTargetInterfacePtr=NULL;
if(DialogBox(hInst, MAKEINTRESOURCE(IDD_PROJ_DLG), hWnd, reinterpret_cast<DLGPROC>(Proj_DlgProc))==0)
{
PostQuitMessage(0);
}
else
{
monoWrapper::reInitMono(EditorApp::getProjectHomeDirectory());
monoWrapper::mono_engine_test_function_for_mono();
m_cEditorApp.init(hWnd, hInst);
OleInitialize(NULL);
MDragDropInterface* dropTarget = new MDragDropInterface(&m_cEditorApp);
// acquire a strong lock
CoLockObjectExternal(dropTarget, TRUE, FALSE);
RegisterDragDrop(hWnd, dropTarget);
m_cDropTargetInterfacePtr=dropTarget;
Timer::init();
//eventHook::g_pEditorAppPtr=&m_cEditorApp;
//eventHook::hookEvent(hWnd);
//load the current scene
std::string root_dir = EditorApp::getProjectHomeDirectory();
root_dir+="/ProjectSettings/currentscene";
gxFile currenSceneFile;
if(currenSceneFile.OpenFile(root_dir.c_str()))
{
const char* relativepath = currenSceneFile.ReadString();
currenSceneFile.CloseFile();
root_dir = EditorApp::getProjectHomeDirectory();
root_dir+="/Assets";
root_dir+=relativepath;
if(EditorApp::getSceneHierarchy()->loadScene(root_dir.c_str()))
{
std::string wndTitle ="GEAR Alpha [";
wndTitle+=relativepath;
wndTitle+=+"]";
SetWindowText(hWnd, wndTitle.c_str());
EditorApp::getSceneProject()->populateProjectView();
EditorApp::getSceneFileView()->populateFileView();
}
GX_DELETE_ARY(relativepath);
}
//
}
}
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
m_cEditorApp.DoCommand(wmId);
// Parse the menu selections:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case ID_TEST_COMMAND:
{
gxFile file;
file.OpenFile("01_snow_planet.scene.xml.bin");
int nActor=0;
file.Read(nActor);
geGUIBase* tvnode=EditorApp::getSceneHierarchy()->getSelectedTreeNode();
if(!tvnode)
break;
object3d* selectedobj=(object3d*)tvnode->getUserData();
if(!selectedobj)
break;
for(int x=0;x<nActor;x++)
{
char* actorname=file.ReadString();
bool bPrefab=false;
file.Read(bPrefab);
char* prefabname=NULL;
if(bPrefab)
prefabname=file.ReadString();
float rotation[3];
float translation[3];
file.Read(rotation[0]);
file.Read(rotation[1]);
file.Read(rotation[2]);
file.Read(translation[0]);
file.Read(translation[1]);
file.Read(translation[2]);
if(prefabname)
{
std::vector<object3d*>* list=selectedobj->getChildList();
for(std::vector<object3d*>::iterator it = list->begin(); it != list->end(); ++it)
{
object3d* childobj = *it;
if(strcmp(prefabname, childobj->getName())==0)
{
//apply transforms
childobj->rotateLocalXf(rotation[0]);
childobj->rotateLocalXf(rotation[1]);
childobj->rotateLocalXf(rotation[2]);
childobj->updatePositionf(translation[0], translation[2], translation[1]);
break;
}
}
}
GX_DELETE_ARY(actorname);
GX_DELETE_ARY(prefabname);
}
file.CloseFile();
}
break;
case ID_PROJECT_BUILDFORANDROID:
{
printf("\n================ANDROID BUILD ENGINE===============\n");
char inputbuffer[1024*6];
sprintf(inputbuffer, "%s//AndroidProjectMaker.exe %s %s", EditorApp::getAppDirectory().c_str(), EditorApp::getAppDirectory().c_str(), EditorApp::getProjectHomeDirectory());
if(monoWrapper::exec_cmd(inputbuffer)!=0)
{
printf("\nERROR\n");
}
printf("\n======================================================\n");
}
break;
case ID_EDIT_ACTIVECAMERAPROPERTY:
{
object3d* cam=monoWrapper::mono_engine_getWorld(0)->getActiveCamera();
EditorApp::getSceneWorldEditor()->selectedObject3D(cam);
EditorApp::getScenePropertyEditor()->populatePropertyOfObject(cam);
}
break;
case ID_EDIT_OCTREEPROPERTY:
{
EditorApp::getScenePropertyEditor()->populatePropertyOfOctree();
}
break;
case ID_EDIT_LAYERSPROPERTY:
{
EditorApp::getScenePropertyEditor()->populatePropertyOfLayers();
}
break;
case ID_EDIT_FOGSETTINGS:
{
EditorApp::getScenePropertyEditor()->populateSettingsOfFog();
}
break;
case ID_FILE_SAVESCENE:
{
std::string root_dir = EditorApp::getProjectHomeDirectory();
root_dir+="/Assets";
std::replace( root_dir.begin(), root_dir.end(), '/', '\\');
char output_buffer[MAX_PATH];
if(EditorApp::showSaveCommonDlg(hWnd, output_buffer, MAX_PATH, "GEAR Scene (*.gearscene)\0*.gearscene\0", "gearscene", root_dir.c_str()))
{
if(EditorApp::getSceneHierarchy()->saveCurrentScene(output_buffer))
{
EditorApp::getSceneProject()->populateProjectView();
EditorApp::getSceneFileView()->populateFileView();
//update the currentscene file
root_dir = EditorApp::getProjectHomeDirectory();
root_dir+="/ProjectSettings/currentscene";
gxFile currenSceneFile;
if(currenSceneFile.OpenFile(root_dir.c_str(), gxFile::FILE_w))
{
const char* relativepath=AssetImporter::relativePathFromProjectHomeDirectory_AssetFolder(output_buffer);
char unix_path[MAX_PATH];
memset(unix_path, 0, MAX_PATH);
strcpy(unix_path, relativepath);
geUtil::convertPathToUnixFormat(unix_path);
currenSceneFile.Write(unix_path);
currenSceneFile.CloseFile();
std::string wndTitle ="GEAR Alpha [";
wndTitle+=relativepath;
wndTitle+=+"]";
SetWindowText(hWnd, wndTitle.c_str());
}
//
}
}
}
break;
case ID_FILE_OPENSCENE:
{
std::string root_dir = EditorApp::getProjectHomeDirectory();
root_dir+="/Assets";
std::replace( root_dir.begin(), root_dir.end(), '/', '\\');
char output_buffer[MAX_PATH];
if(EditorApp::showOpenCommonDlg(hWnd, output_buffer, MAX_PATH, "GEAR Scene (*.gearscene)\0*.gearscene\0", "gearscene", root_dir.c_str()))
{
if(EditorApp::getSceneHierarchy()->loadScene(output_buffer))
{
EditorApp::getSceneProject()->populateProjectView();
EditorApp::getSceneFileView()->populateFileView();
//update the currentscene file
root_dir = EditorApp::getProjectHomeDirectory();
root_dir+="/ProjectSettings/currentscene";
gxFile currenSceneFile;
if(currenSceneFile.OpenFile(root_dir.c_str(), gxFile::FILE_w))
{
const char* relativepath=AssetImporter::relativePathFromProjectHomeDirectory_AssetFolder(output_buffer);
char unix_path[MAX_PATH];
memset(unix_path, 0, MAX_PATH);
strcpy(unix_path, relativepath);
geUtil::convertPathToUnixFormat(unix_path);
currenSceneFile.Write(unix_path);
currenSceneFile.CloseFile();
std::string wndTitle ="GEAR Alpha [";
wndTitle+=relativepath;
wndTitle+=+"]";
SetWindowText(hWnd, wndTitle.c_str());
}
//
}
}
}
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_PAINT:
{
Timer::update();
m_cEditorApp.update(Timer::getDtinSec());
m_cEditorApp.draw();
}
break;
case WM_SIZE:
{
if((LOWORD(wParam)==SIZE_MAXIMIZED || LOWORD(wParam)==SIZE_RESTORED) && m_cEditorApp.isInitialized())
{
monoWrapper::reInitMono(EditorApp::getProjectHomeDirectory());
m_cEditorApp.importAssetToMetaData(hWnd, hInst);
EditorApp::getSceneProject()->populateProjectView();
EditorApp::getSceneFileView()->populateFileView();
}
m_cEditorApp.size(LOWORD(lParam), HIWORD(lParam));
}
break;
case WM_MOUSEMOVE:
{
int nFlags=LOWORD(wParam);
int xx=LOWORD(lParam);
int yy=HIWORD(lParam);
m_cEditorApp.MouseMove(xx, yy, nFlags);
}
break;
case WM_MOUSEWHEEL:
{
int nFlags=LOWORD(wParam);
int xx=LOWORD(lParam);
int yy=HIWORD(lParam);
xx = GET_X_LPARAM(lParam);
yy = GET_Y_LPARAM(lParam);
int zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
m_cEditorApp.MouseWheel(zDelta, xx, yy, nFlags);
}
break;
case WM_LBUTTONDOWN:
{
//if(geTextBox::g_pCurrentlyActiveTextBoxPtr)
// geTextBox::g_pCurrentlyActiveTextBoxPtr->clearSelection();
geTextBox::g_pCurrentlyActiveTextBoxPtr=NULL;
int nFlags=LOWORD(wParam);
int xx=LOWORD(lParam);
int yy=HIWORD(lParam);
m_cEditorApp.MouseLButtonDown(xx, yy, nFlags);
}
break;
case WM_LBUTTONUP:
{
int nFlags=LOWORD(wParam);
int xx=LOWORD(lParam);
int yy=HIWORD(lParam);
m_cEditorApp.MouseLButtonUp(xx, yy, nFlags);
}
break;
case WM_DESTROY:
{
if(m_cDropTargetInterfacePtr)
{
RevokeDragDrop(hWnd);
// remove the strong lock
CoLockObjectExternal(m_cDropTargetInterfacePtr, FALSE, TRUE);
// release our own reference
m_cDropTargetInterfacePtr->Release();
OleUninitialize();
}
monoWrapper::destroyMono();
monoWrapper::destroyDebugConsole();
#if defined(_DEBUG) && defined(ENABLE_MEMORY_CHECK)
SymCleanup(GetCurrentProcess());
#endif
PostQuitMessage(0);
}
break;
case WM_KEYDOWN:
{
if(geTextBox::g_pCurrentlyActiveTextBoxPtr)
{
if(wParam==VK_SHIFT)
break;
short shift_keystate=GetKeyState(VK_SHIFT);
char ch=MapVirtualKey(wParam, MAPVK_VK_TO_CHAR);
if(ch>=0x41 && ch<=0x5A)
{
if(!(shift_keystate&0x8000))
ch=ch+32;
}
else if(ch>=0x31 && ch<=0x39)
{
if((shift_keystate&0x8000))
ch=ch-16;
}
bool bCaptured=geTextBox::g_pCurrentlyActiveTextBoxPtr->KeyDown(ch, lParam);
}
else
{
m_cEditorApp.KeyDown(wParam, lParam);
}
}
break;
case WM_KEYUP:
{
if(geTextBox::g_pCurrentlyActiveTextBoxPtr)
{
if(wParam==VK_SHIFT)
break;
short shift_keystate=GetKeyState(VK_SHIFT);
char ch=MapVirtualKey(wParam, MAPVK_VK_TO_CHAR);
if(ch>=0x41 && ch<=0x5A)
{
if(!(shift_keystate&0x8000))
ch=ch+32;
}
else if(ch>=0x31 && ch<=0x39)
{
if((shift_keystate&0x8000))
ch=ch-16;
}
geTextBox::g_pCurrentlyActiveTextBoxPtr->KeyUp(ch, lParam);
}
else
{
m_cEditorApp.KeyUp(wParam, lParam);
}
}
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
//WINOLEAPI dllimport DoDragDrop(
// IDataObject * pDataObject, // Pointer to the data object
// IDropSource * pDropSource, // Pointer to the source
// DWORD dwOKEffect, // Effects allowed by the source
// DWORD * pdwEffect // Pointer to effects on the source
// )
//{
//
//}
// Message handler for about box.
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;
case WM_CLOSE:
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
break;
default:
return DefWindowProc(hDlg, message, wParam, lParam);
}
return (INT_PTR)FALSE;
}
#endif
char* browseFolder(HWND hWndParent, const char* title, const char* root_dir=NULL);
LPITEMIDLIST convertPathToLpItemIdList(const char *pszPath);
LRESULT CALLBACK projectSelector_DlgProc(HWND hWndDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
{
switch(Msg)
{
case WM_INITDIALOG:
{
//read the recent dialog
FILE* fp = fopen("recentProjects", "r");
if(fp)
{
char temp_buffer[1024];
while (fscanf(fp, "%s\n", temp_buffer) != EOF)
{
SendDlgItemMessage(hWndDlg, IDC_PROJ_DLG_RECENT_PROJECT_LIST, LB_ADDSTRING, NULL, (LPARAM)temp_buffer);
}
fclose(fp);
}
return TRUE;
}
break;
case WM_COMMAND:
switch(wParam)
{
case ID_PROJ_DLG_OPEN_NEW_PROJECT:
{
char* project_directory=browseFolder(hWndDlg, _T("Select an empty folder to create project."));
if(EditorGEARApp::createNewProject(project_directory)!=0)
{
MessageBox(hWndDlg, "Project creation failed", "Error.", MB_OK | MB_ICONERROR);
GE_DELETE_ARY(project_directory);
return true;
}
EditorGEARApp::setProjectHomeDirectory(project_directory);
GE_DELETE_ARY(project_directory);
EndDialog(hWndDlg, 1);
return true;
}
break;
case ID_PROJ_DLG_OPEN_RECENT_PROJECT:
{
// Get current selection index in listbox
int itemIndex = (int) SendDlgItemMessage(hWndDlg, IDC_PROJ_DLG_RECENT_PROJECT_LIST, LB_GETCURSEL, (WPARAM)0, (LPARAM) 0);
if (itemIndex == LB_ERR)
{
MessageBox(hWndDlg, "Select atleast one recent project", "GEAR.", MB_OK | MB_ICONINFORMATION);
}
else
{
// Get actual text in buffer
char temp_buffer[1024];
SendDlgItemMessage(hWndDlg, IDC_PROJ_DLG_RECENT_PROJECT_LIST, LB_GETTEXT, (WPARAM) itemIndex, (LPARAM) temp_buffer );
EditorGEARApp::setProjectHomeDirectory(temp_buffer);
EndDialog(hWndDlg, 2);
}
return true;
}
break;
}
break;
case WM_CLOSE:
{
return EndDialog(hWndDlg, 0);
}
break;
//commented this default block, since the SHBrowseForFolder [New project option] wont work
//default:
// return DefWindowProc(hWndDlg, Msg, wParam, lParam);
//
}
return FALSE;
}
char* browseFolder(HWND hWndParent, const char* title, const char* root_dir)
{
char* return_buffer=NULL;
BROWSEINFO bi = { 0 };
bi.hwndOwner=hWndParent;
bi.lpszTitle = title;
if(root_dir)
{
bi.pidlRoot = convertPathToLpItemIdList(root_dir);
}
bi.ulFlags=BIF_USENEWUI;// | BIF_RETURNONLYFSDIRS;
HRESULT r=OleInitialize(NULL);
LPITEMIDLIST pidl = SHBrowseForFolder ( &bi );
if ( pidl != 0 )
{
// get the name of the folder
TCHAR path[MAX_PATH];
if ( SHGetPathFromIDList ( pidl, path ) )
{
_tprintf ( _T("Selected Folder: %s\n"), path );
return_buffer = new char[strlen(path)+1];
strcpy(return_buffer, path);
return_buffer[strlen(path)]='\0';
}
// free memory used
IMalloc * imalloc = 0;
if ( SUCCEEDED( SHGetMalloc ( &imalloc )) )
{
imalloc->Free ( pidl );
imalloc->Release ( );
}
}
OleUninitialize();
if(return_buffer)
{
//win32 to unix style path
geUtil::convertPathToUnixFormat(return_buffer);
}
return return_buffer;
}
LPITEMIDLIST convertPathToLpItemIdList(const char *pszPath)
{
LPITEMIDLIST pidl = NULL;
LPSHELLFOLDER pDesktopFolder = NULL;
OLECHAR olePath[MAX_PATH];
ULONG chEaten;
HRESULT hr;
if (SUCCEEDED(SHGetDesktopFolder(&pDesktopFolder)))
{
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pszPath, -1,
olePath, MAX_PATH);
hr = pDesktopFolder->ParseDisplayName(NULL, NULL,
olePath, &chEaten, &pidl, NULL);
pDesktopFolder->Release();
return pidl;
}
return NULL;
}
#include "../macosProj/GEARInternal/GEARInternal/appEntry.h"
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
#if defined(_DEBUG) && defined(ENABLE_MEMORY_CHECK)
_CrtSetDbgFlag (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_CHECK_ALWAYS_DF);
_CrtSetReportMode ( _CRT_ERROR, _CRTDBG_MODE_DEBUG);
//SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS);
SymInitialize(GetCurrentProcess(), NULL, TRUE);
#endif
int return_val=0;
if(DialogBox(hInstance, MAKEINTRESOURCE(IDD_PROJ_DLG), NULL, reinterpret_cast<DLGPROC>(projectSelector_DlgProc))!=0)
{
monoWrapper::initDebugConsole();
return_val = macos_main();
monoWrapper::destroyDebugConsole();
}
#if defined(_DEBUG) && defined(ENABLE_MEMORY_CHECK)
SymCleanup(GetCurrentProcess());
#endif
return return_val;
}
|
[
"arun.mudhaliar@gmail.com"
] |
arun.mudhaliar@gmail.com
|
050c83f17ab2fce12449dd77b2ef8d411408b12a
|
dc9959be244ed9285a03a10fbc6046ea75f17f5d
|
/agency/detail/tuple_utility.hpp
|
9e3afc427354e7ff3df54526f56fbc4afa97a932
|
[] |
no_license
|
sali98/agency
|
09d708555bd329b32a5dd48ba339d163257ee074
|
022c69d37064542cde7d20c8401efdace08fa68e
|
refs/heads/master
| 2021-01-21T08:25:22.727368
| 2017-05-12T20:31:34
| 2017-05-12T20:31:34
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 192
|
hpp
|
#pragma once
#include <agency/detail/config.hpp>
#define TUPLE_UTILITY_ANNOTATION __AGENCY_ANNOTATION
#define TUPLE_UTILITY_NAMESPACE __tu
#include <agency/detail/tuple_utility_impl.hpp>
|
[
"jaredhoberock@gmail.com"
] |
jaredhoberock@gmail.com
|
e1ef9eed49a4a9fc0c298d0e26c2f8cfa11f4878
|
12ff2ee3e7fa18d98ee143521809da2b79f96722
|
/oak/client/authorization_bearer_token_metadata.cc
|
f707907e276729b3c66631c99a895c99f23f2a70
|
[
"Apache-2.0"
] |
permissive
|
blaxill/oak
|
c4b62723d9f82b1929cd77c2f5d54b01e361f0a7
|
0f3f00b984b8c7b34fbf414a27471390ab819f8d
|
refs/heads/master
| 2021-06-26T05:30:20.330640
| 2019-12-09T17:09:25
| 2019-12-09T17:09:25
| 224,698,021
| 0
| 0
|
Apache-2.0
| 2019-11-28T17:07:12
| 2019-11-28T17:07:11
| null |
UTF-8
|
C++
| false
| false
| 1,320
|
cc
|
/*
* Copyright 2019 The Project Oak Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "oak/client/authorization_bearer_token_metadata.h"
#include <map>
#include "oak/common/policy.h"
namespace oak {
AuthorizationBearerTokenMetadata::AuthorizationBearerTokenMetadata(
const std::string& authorization_bearer_token)
: authorization_bearer_token_(authorization_bearer_token) {}
grpc::Status AuthorizationBearerTokenMetadata::GetMetadata(
grpc::string_ref service_url, grpc::string_ref method_name,
const grpc::AuthContext& channel_auth_context,
std::multimap<grpc::string, grpc::string>* metadata) {
metadata->insert(
std::make_pair(kOakAuthorizationBearerTokenGrpcMetadataKey, authorization_bearer_token_));
return grpc::Status::OK;
}
} // namespace oak
|
[
"noreply@github.com"
] |
blaxill.noreply@github.com
|
fa4820f18e0654adde51863dddf5c1cc909f710d
|
9fbcf234409424c330eef32036c7f2acbcd4b72a
|
/movie.h
|
47c241468bc6568dad7a88085e91413355f18c94
|
[] |
no_license
|
Lazy-Y/Mini-Amazon
|
f1ecc5d7c1c58ca53eee612307f89aaca234af38
|
163b7e8457d4a293d9078332e0b87ef1e11eb492
|
refs/heads/master
| 2021-01-10T16:51:46.565705
| 2015-11-30T19:08:49
| 2015-11-30T19:08:49
| 47,139,989
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 588
|
h
|
#ifndef MOVIE_H
#define MOVIE_H
#include <iostream>
#include <string>
#include <set>
#include <fstream>
#include "product.h"
using namespace std;
class Movie : public Product
{
public:
Movie(const string category, const string name, double price,
int qty, const string genre, const string rating);
set<string> keywords() const;
string displayString() const;
//bool isMatch(vector<string>& searchTerms) const;
void dump(ostream& os) const;
const string getA() const;
const string getB() const;
private:
string genre_;
string rating_;
};
#endif
|
[
"zhenyanz@usc.edu"
] |
zhenyanz@usc.edu
|
367884af0e90d1e57605c37e22fe0ba832f8ff2c
|
433a5e2db78508aeceb6169892ac8572401af192
|
/src/shell.hpp
|
c9e55de30d1096604609db692a60b7a514ff5953
|
[] |
no_license
|
EggOetgen/seaShellOFX
|
961aa79765a05ec20604d27a720f58f93d4372cc
|
25a862f4d459fdee663e39634c0f3b190b44e83b
|
refs/heads/master
| 2021-01-01T17:54:54.250171
| 2017-07-26T15:33:27
| 2017-07-26T15:33:27
| 98,197,779
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,634
|
hpp
|
//
// shell.hpp
// seashellOFX
//
// Created by Edmund Oetgen on 18/07/2017.
//
//
#pragma once
#include "ofMain.h"
class shell{
public:
void generate(int n, int m, int D, float turns, float alpha, float beta, float A, float mu, float omega, float phi, float a, float b, float L, float P, float W1, float W2, int N);
void generateMesh(int n, int m, float turns);
void draw(int m);
void updateMesh(int n, int m, float turns);
void setNormals( ofMesh &mesh );
void move(int x, int y, ofVec2f lastMouse);
/*TAKEN FROM https://github.com/genekogan/SeashellGenerator */
// // spiral parameters
// int D = 1; //varying this stretches and compresses along an axis orthoganal to the "A" parameter
// float turns = 6 * TWO_PI;
//
// float alpha = 1.49;
// float beta = .47;
// float A = 0;
// float k = 0.86; // test variable for rate of growth
//
// // ellipse orientation parameters
// float mu = .08; // angle given in radians
// float omega = .01; // angle given in radians
// float phi = 2.6; //rotation of elipse about normal axis, angle given in radians
//
// // ellipsoid parameters
// float a = 13.13; //elipse radii
// float b = 20; //elipse radii
//
// // surface parameters
// float L = 5;
// float P = 5;
// float W1 = 5;
// float W2 = .39;
// int N = 10;
//
vector<ofPoint> spiral;
vector<vector<ofPoint>> shell;
vector<ofPoint> vertices;
ofQuaternion curRot;
ofVec3f centroid;
ofVboMesh shellMesh;
ofNode test;
// of3dPrimitive shellNode;
};
|
[
"edmundoetgen@Edmunds-MBP.home"
] |
edmundoetgen@Edmunds-MBP.home
|
1f4d6f518fd4f3fa65a790187aeeb244923e28c6
|
234b0f90cf473f091e24d972b02d67ee1c128fe8
|
/Quadrotor/Quadrotor_V06/data_update.ino
|
b985ba6c171d39a1a494260d75cda28c6ef286aa
|
[] |
no_license
|
wcleithinking/Arduino-based-Embedded-Development
|
023734553260263b0684e853fbea1bfc9c277c98
|
163879a48958751a2fbb7e931dd88e69f159c4ac
|
refs/heads/master
| 2020-03-09T17:46:32.358183
| 2018-08-30T08:42:26
| 2018-08-30T08:42:26
| 128,916,082
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 301
|
ino
|
void data_update() {
roll_ooo = roll_oo;
pitch_ooo = pitch_oo;
yaw_ooo = yaw_oo;
roll_oo = roll_o;
pitch_oo = pitch_o;
yaw_oo = yaw_o;
roll_o = roll;
pitch_o = pitch;
yaw_o = yaw;
for (int i = 0; i < 4; i++) {
u_ooo[i] = u_oo[i];
u_oo[i] = u_o[i];
u_o[i] = u[i];
}
}
|
[
"wcleithinking@gmail.com"
] |
wcleithinking@gmail.com
|
3993a06866fd52fff2e00d91322d4784690c8f28
|
ca602ac81a00ad82d539519502d764180ae57ba9
|
/Num09_11_futures.cpp
|
a308f72c227fff41f98150a3a7a7f92d8b532526
|
[] |
no_license
|
jpiccoli/Cpp_Weekly
|
8b6251b367fe2399754cddf443c29c86204f0116
|
d640ab43c18c4ecdd81eb494d5daf75d886a9b0e
|
refs/heads/master
| 2021-09-17T09:29:14.602062
| 2018-06-30T01:40:52
| 2018-06-30T01:40:52
| 110,934,144
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,865
|
cpp
|
#include <algorithm>
#include <iostream>
#include <random>
#include <set>
#include <future>
std::set<int> make_sorted_random( size_t const& num_elems )
{
std::set<int> retval;
std::random_device rd;
std::mt19937 gen( rd() );
std::uniform_int_distribution<> dis( 0, num_elems - 1 );
std::generate_n( std::inserter( retval, retval.end() ), num_elems,
[&]() { return dis(gen); });
return retval;
}
int main()
{
// std::cout << std::async( make_sorted_random(1000000).get().size() << "\n";
// std::cout << std::async( make_sorted_random, 1000000).get().size() << "\n";
// Does not block. Also may be faster since runtime should spawn new threads
//auto f1 = std::async( std::launch::async, make_sorted_random, 1000000);
//auto f2 = std::async( std::launch::async, make_sorted_random, 1000000);
//std::future<std::set<int>> f3 = std::async( std::launch::async, make_sorted_random, 1000000);
// std::launch::async not necessary but slower since does not ALWAYS spawn a new thread
// Thread creation is runtime decision
// Default is std::launch::async | std::launch::deferred if flags not included
auto f1 = std::async(make_sorted_random, 1000000);
auto f2 = std::async(make_sorted_random, 1000000);
std::future<std::set<int>> f3 = std::async( make_sorted_random, 1000000);
auto f4 = std::async( std::launch::deferred, make_sorted_random, 1000000);
auto f5 = std::async( std::launch::deferred, make_sorted_random, 1000000);
// f4 and f5 never called since not requested with std::launch::deferred
std::cout << f1.get().size() << " " << f2.get().size() << " " << f3.get().size() << "\n";
// Call to "get()" is blocking
//std::cout << std::async(make_sorted_random, 1000000).get().size();
//std::cout << " ";
//std::cout << std::async(make_sorted_random, 1000000).get().size();
//std::cout << "\n";
}
|
[
"joe13676@comcast.net"
] |
joe13676@comcast.net
|
9d52fc87e4fdedc3c0926deb505f56eada56aea4
|
3195ea3c507d958eb598c4054f2f382eb6b49ec3
|
/Object Oriented/jdo3643_HW12/jdo3643_Video_Game_Window.h
|
9b3fa1fcf126ea499e1eb94d4f06ed0d3e759ece
|
[] |
no_license
|
jdolds09/Jerry-Olds-Projects
|
3c75d5d4240cd3cccbbfdcaab238ff9735551211
|
eec161042861ef80021edba181c931dbe08ae555
|
refs/heads/master
| 2023-01-03T11:25:18.900613
| 2021-01-19T01:46:08
| 2021-01-19T01:46:08
| 243,045,245
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 444
|
h
|
#include<iostream>
#include<gtkmm.h>
#include<string>
using namespace std;
class Video_Game_Window : public Gtk::Window
{
public:
Video_Game_Window();
~Video_Game_Window();
vector<string> get_entries();
protected:
void on_button_enter();
Gtk::Box m_VBox;
Gtk::Label Title_Label;
Gtk::Entry Title_Entry;
Gtk::Label Year_Label;
Gtk::Entry Year_Entry;
Gtk::Label Studio_Label;
Gtk::Entry Studio_Entry;
Gtk::Button m_Button_Enter;
};
|
[
"jerry.olds@mavs.uta.edu"
] |
jerry.olds@mavs.uta.edu
|
9fb6b92fe2dca9a21240160cf6673ec0c0a2991d
|
fb5b25b4fbe66c532672c14dacc520b96ff90a04
|
/export/release/windows/obj/src/openfl/display/IGraphicsStroke.cpp
|
11dc37373739f4c28d1a13695b1eaabeae39f565
|
[
"Apache-2.0"
] |
permissive
|
Tyrcnex/tai-mod
|
c3849f817fe871004ed171245d63c5e447c4a9c3
|
b83152693bb3139ee2ae73002623934f07d35baf
|
refs/heads/main
| 2023-08-15T07:15:43.884068
| 2021-09-29T23:39:23
| 2021-09-29T23:39:23
| 383,313,424
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 652
|
cpp
|
#include <hxcpp.h>
#ifndef INCLUDED_openfl_display_IGraphicsStroke
#include <openfl/display/IGraphicsStroke.h>
#endif
namespace openfl{
namespace display{
::hx::Class IGraphicsStroke_obj::__mClass;
void IGraphicsStroke_obj::__register()
{
::hx::Static(__mClass) = new ::hx::Class_obj();
__mClass->mName = HX_("openfl.display.IGraphicsStroke",02,f8,be,97);
__mClass->mSuper = &super::__SGetClass();
__mClass->mMembers = ::hx::Class_obj::dupFunctions(0 /* sMemberFields */);
__mClass->mCanCast = ::hx::TIsInterface< (int)0xf088881a >;
::hx::_hx_RegisterClass(__mClass->mName, __mClass);
}
} // end namespace openfl
} // end namespace display
|
[
"72734817+khiodev@users.noreply.github.com"
] |
72734817+khiodev@users.noreply.github.com
|
f76ad927b875dc80d04d0b40433cdffebfb6f763
|
7ee38209f161837b4ccf83e3abe1cccb7991cf5a
|
/include/FileManager.hpp
|
8dd96a88c53b345ec44cd4c87a12e428933fae08
|
[] |
no_license
|
Fairbrook/dispersion
|
07e5e9a77407ab550b4ba0e4b74c8736892b8665
|
4936aa8e2eee972b641adbfcfa9e4c1f92af69ed
|
refs/heads/master
| 2023-01-23T14:29:18.973497
| 2020-12-01T18:28:12
| 2020-12-01T18:28:12
| 316,794,040
| 0
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,736
|
hpp
|
/**
* Maestro:
* Gracela Lara Lopez
*
* Materia:
* Estructura de DatosII D03
*
* Participantes:
* Arturo Carrillo Solรณrzano 218744333
* Josuรฉ Yizreel Jauregui Rodrรญguez 219293556
* Kevin Alan Martรญnez Virgen 219294382
*/
#ifndef FILE_MANAGER_INCLUDE_H
#define FILE_MANAGER_INCLUDE_H
#include <string>
#include <sstream>
#include <array>
#include <vector>
#include <fstream>
#include "Propietario.h"
//Declaraciรณn de la clase para el manejo de los archivos
class FileManager
{
private:
// Declaracion del array para guardar las direcciones
std::array<propietario*, 100> directions;
// Declaracion del array para guardar los registro obtenidos del archivo
std::vector<propietario> registries;
// Declaracion del array para guardar la frecuencia de las direcciones
std::array<short, 100> frequency;
// Declaraciรณn de la funciรณn para realizar las dipersion de folk
int dispersionFolk(char *);
public:
//Constructor
FileManager();
//Funcion para leer el archivo y almacenar sus registros
bool readFile(const std::string &);
//Aplica la funciรณn de dispersion a todos los registros leidos
bool applyDispersion();
//Guarda el arreglo de direcciones en el archivo
bool saveFile(const std::string &);
//Guarda el arreglo de frecuencia en el archivo
bool saveFrequencyToFile(const std::string &);
//devuelve el arreglo de direcciones
std::array<propietario*, 100> getDirections() const { return directions; }
//devuelve el arreglo de registros
std::vector<propietario> getResgistries() const { return registries; }
//devuelve el arreglo de frecuencias
std::array<short, 100> getFrequency() const { return frequency; }
};
#endif
|
[
"kevinvr@hotmail.es"
] |
kevinvr@hotmail.es
|
c81902a51bfac38b8c0004530e45b6eeabfa32e6
|
ef4f66a7753d09f4ed58a5486c8b6454c27db17d
|
/platek/platek.cpp
|
9e7fca1eb896cc16d48c48f93d5af2974d453eaf
|
[] |
no_license
|
Krizuu/C_Files_from_old_repo
|
7a76227b1dc8a0b26f1ffa27a0c85cbf6ab0f7b0
|
9c8e5442c41c0138d1f4add563e172ae1c1b936a
|
refs/heads/master
| 2020-06-17T03:18:08.677261
| 2019-07-08T10:03:14
| 2019-07-08T10:03:14
| 195,778,252
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,150
|
cpp
|
#include "platek.h"
platek::platek(bool * switcher, unsigned char * gimmeArray, unsigned int * sleepingTime, unsigned int x, unsigned int y) : x_(x), y_(y), arr(gimmeArray)
{
dontStopMe = switcher;
sleepingTime_ = sleepingTime;
startingX = x;
saveNewToArray();
}
std::mutex platek::mtx;
bool platek::dealWithMovement()
{
if (!getLow())
{
if (!WhereDoYouGo())
return false;
}
else
randomlyMoveLeftorRight();
return true;
}
void platek::makeTheSnowStartsFalling()
{
iMovesLikeaJagger = new std::thread(&platek::youSpinMeRoundTheThread, this);
}
void platek::eraseFromArray()
{
*(arr + (y_ * xsize) + x_) = ' ';
}
void platek::saveNewToArray()
{
*(arr + (y_ * xsize) + x_) = 'x';
}
void platek::gotxy(UINT x, UINT y)
{
COORD coord;
coord.X = static_cast<SHORT>(x);
coord.Y = static_cast<SHORT>(y);
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
}
void platek::randomlyMoveLeftorRight()
{
srand(time(nullptr));
if (80 < (rand() % 101)) // 20% szans na poruszenie
{
if (*(arr + (y_ * xsize) + x_ + 1) != 'x' && *(arr + (y_ * xsize) + x_ - 1) != 'x')
{
if ((rand() % 3) == 1)
{
moveToTheLeft();
}
else
{
moveToTheRight();
}
}
else if (*(arr + (y_ * xsize) + x_ + 1) != 'x')
moveToTheRight();
else
moveToTheLeft();
}
}
bool platek::WhereDoYouGo()
{
bool howDoYouDo = false;
if (y_ < ysize)
{
if (*(arr + ((y_ + 1) * xsize) + x_ - 1) != 'x' && *(arr + ((y_ + 1) * xsize) + x_ + 1) != 'x' && x_ > 1 && x_ < xsize)
{
if ((rand() % 3) == 1)
{
howDoYouDo = moveToTheLeft();
}
else
{
howDoYouDo = moveToTheRight();
}
}
else if (*(arr + ((y_ + 1) * xsize) + x_ - 1) != 'x' && x_ > 1)
howDoYouDo = moveToTheLeft();
else if (*(arr + ((y_ + 1) * xsize) + x_ + 1) != 'x' && x_ < xsize)
howDoYouDo = moveToTheRight();
}
return howDoYouDo;
}
bool platek::moveToTheRight()
{
mtx.lock();
if (x_ < xsize - 1 && *(arr + (y_ * xsize) + x_ + 1) != 'x')
{
eraseFromArray();
gotxy(x_, y_);
std::cout << ' ';
x_++;
gotxy(x_, y_);
std::cout << 'x';
saveNewToArray();
mtx.unlock();
return true;
}
mtx.unlock();
return false;
}
bool platek::moveToTheLeft()
{
mtx.lock();
if (x_ > 1 && *(arr + (y_ * xsize) + x_ - 1) != 'x')
{
eraseFromArray();
gotxy(x_, y_);
std::cout << ' ';
x_--;
gotxy(x_, y_);
std::cout << 'x';
saveNewToArray();
mtx.unlock();
return true;
}
mtx.unlock();
return false;
}
bool platek::getLow()
{
mtx.lock();
if (*(arr + ((y_ + 1) * xsize) + x_) != 'x' && y_ < ysize)
{
eraseFromArray();
gotxy(x_, y_);
std::cout << " ";
y_++;
saveNewToArray();
gotxy(x_, y_);
std::cout << "x";
Sleep(30);
mtx.unlock();
return true;
}
mtx.unlock();
return false;
}
void platek::spawnNewBeautifulPieceOfSnow()
{
mtx.lock();
y_ = 0;
x_ = startingX;
saveNewToArray();
mtx.unlock();
}
void platek::youSpinMeRoundTheThread()
{
while (!*dontStopMe)
{
if (!dealWithMovement())
spawnNewBeautifulPieceOfSnow();
Sleep(*sleepingTime_);
}
}
void platek::waitToStop()
{
iMovesLikeaJagger->join();
}
platek::~platek()
{
delete iMovesLikeaJagger;
}
|
[
"krzysztof.agas.lange@gmail.com"
] |
krzysztof.agas.lange@gmail.com
|
fb4d9431dfc8a1527c4bc6f561e3c618da2794ab
|
118b042a28eebf624eb76152614a6066933cef7a
|
/lib/Logger/src/Logger.cpp
|
9d011f68712229f9b850f5266ce1333e60bf859c
|
[] |
no_license
|
windymar/monitoring_server_nodemcu
|
de0ada4972cef717e022708c9a2b2172a9bb77d4
|
2c96e2250883da060dc1a62fd888c06118ef7f53
|
refs/heads/master
| 2020-09-21T05:01:54.012797
| 2019-11-28T16:11:47
| 2019-11-28T16:11:47
| 224,686,574
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 354
|
cpp
|
#include <WString.h>
#include <HardwareSerial.h>
void serial_log(const __FlashStringHelper* p_text)
{
Serial.print(p_text);
}
void serial_logln(const __FlashStringHelper* p_text)
{
Serial.println(p_text);
}
void serial_logln(const __FlashStringHelper* p_text, const String& p_option)
{
Serial.print(p_text);
Serial.println(p_option);
}
|
[
"marcin.windys@gmail.com"
] |
marcin.windys@gmail.com
|
2dc7282613c6c8293b1c1ed6a968bf4629b8a49b
|
c247f9e644f0445ab3d92a82ae9f963dbe9eccb5
|
/src/PlayerStatus.h
|
8e4d296cc6c2bdf2c99dca4bef439150bcdd1c69
|
[] |
no_license
|
Edwin-Silerio/TofuWarrior
|
0ae8ee2ace3b2d0be48618a6e4e89cf7cdd99b56
|
7eae6ac4b5eac5a3dc5ec179244c342439d414cb
|
refs/heads/master
| 2022-10-30T21:19:36.351649
| 2020-06-11T01:58:21
| 2020-06-11T01:58:21
| 271,427,071
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 3,848
|
h
|
/*
* PlayerStatus is a class created to keep track of the Player's State,
* outside of the Player object itself. This will allow a Player's state
* to persist between scene changes, which will be necessary for implementing
* a round system that the game will use.
*
* This class will be responsible for maintaining player information like HP,
* gold, attack, collected items, and stuff like that. The Player object itself
* will no longer contain that information and will instead get it from this
* "singleton" when it needs it.
*
* This "singleton" will be auto-loaded at the start of the game. When it is,
* all of its member variables will be set to zero or their zero-equivalent.
* When starting a single player game, creating a multiplayer game, or joining
* a multiplayer game, this "singleton" will have its member variables initialized
* to their default values. When that game is left for any reason (winning or losing),
* this "singleton" will have its member variables reset to zero or their
* zero-equivalent. This will ensure that state persists between rounds (if the game
* mode has them), but not between "play-throughs" of the game.
*/
#ifndef _PLAYER_STATUS_
#define _PLAYER_STATUS_
#include "constants.h"
#include <Godot.hpp>
#include <Node.hpp>
#include <Array.hpp>
namespace godot {
class PlayerStatus : public Node {
GODOT_CLASS(PlayerStatus, Node)
private:
/* stats */
int hp;
int maxHp;
int gold;
int attack;
int attackSpeed;
int attackRange;
int maxJumps;
int moveSpeed;
/* inventory */
bool hasGlider;
bool hasSword;
bool hasFamiliarBell;
bool hasFamiliar;
bool hasFinalWeapon;
String finalWeapon;
bool hasFinalArmor;
String finalArmor;
bool hasFinalBoots;
String finalBoots;
Array collectedWeapons;
Array collectedArmor;
Array collectedBoots;
Array collectedMisc;
public:
static void _register_methods();
PlayerStatus();
~PlayerStatus();
void _init();
void _ready();
//this is used to start using the PlayerStatus
void new_status();
//this is used to reset the PlayerStatus, so the game
//can be played again without restarting it
void reset_status();
/* stat modifiers and getters */
int get_hp();
void change_hp(int delta);
void restore_hp();
int get_max_hp();
void change_max_hp(int delta);
int get_gold();
void change_gold(int delta);
int get_attack();
void change_attack(int delta);
int get_attack_speed();
void change_attack_speed(int delta);
int get_attack_range();
void change_attack_range(int delta);
int get_max_jumps();
void change_max_jumps(int delta);
int get_move_speed();
void change_move_speed(int delta);
/* inventory list functions */
Array get_collected_weapons();
void add_to_collected_weapons(String newWeapon);
Array get_collected_armor();
void add_to_collected_armor(String newArmor);
Array get_collected_boots();
void add_to_collected_boots(String newBoots);
Array get_collected_misc();
void add_to_collected_misc(String newMisc);
/* item flag getters and setters */
bool check_has_glider();
void pickup_glider();
bool check_has_sword();
void pickup_sword();
bool check_has_familiar_bell();
void pickup_familiar_bell();
bool check_has_familiar();
void collect_familiar();
bool check_has_final_weapon();
String check_which_final_weapon();
void collect_final_weapon(String newFinalWeapon);
bool check_has_final_armor();
String check_which_final_armor();
void collect_final_armor(String newFinalArmor);
bool check_has_final_boots();
String check_which_final_boots();
void collect_final_boots(String newFinalBoots);
};
}
#endif //_PLAYER_STATUS_
|
[
"edwin_silerio@utexas.edu"
] |
edwin_silerio@utexas.edu
|
32d32753c780930c6fb1f84997daa0c3e7c63f50
|
cf7bef5a4b8774c2f4c1f7782645e347d09d6c62
|
/src/util/Math.cpp
|
4b3035883478b716e5ac71dbe75dce01670e5b98
|
[] |
no_license
|
DreadedX/DungeonCrawler
|
1a8d027f93e5b5d67d62713db9931fa52428c3f9
|
c4167939e6f2c5a802838c8f5d65ba996aee0499
|
refs/heads/master
| 2020-12-31T07:19:23.620797
| 2015-10-02T20:52:43
| 2015-10-02T20:52:43
| 39,522,272
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 384
|
cpp
|
#include "Standard.h"
float Math::pointAngle(glm::vec4 position1, glm::vec4 position2) {
// TODO: Check if this still works with other scales
float dx = position2.x - position1.x;
float dy = position1.y - position2.y;
// #define TYPE 360
#define TYPE 2*3.1415
float angle = atan2(dy, dx) * (TYPE/(2*3.1415));
return (angle < 0 ? angle+TYPE : angle);
}
|
[
"tim.huizinga@gmail.com"
] |
tim.huizinga@gmail.com
|
50216b34b6527e052ff273a856a0c4a5a14f285e
|
51635684d03e47ebad12b8872ff469b83f36aa52
|
/external/gcc-12.1.0/libstdc++-v3/testsuite/23_containers/unordered_set/debug/debug_functions.cc
|
84c98d3eba93e8f76ded831d85be44e107dca08b
|
[
"LGPL-2.1-only",
"GPL-3.0-only",
"GCC-exception-3.1",
"GPL-2.0-only",
"LGPL-3.0-only",
"LGPL-2.0-or-later",
"Zlib",
"LicenseRef-scancode-public-domain"
] |
permissive
|
zhmu/ananas
|
8fb48ddfe3582f85ff39184fc7a3c58725fe731a
|
30850c1639f03bccbfb2f2b03361792cc8fae52e
|
refs/heads/master
| 2022-06-25T10:44:46.256604
| 2022-06-12T17:04:40
| 2022-06-12T17:04:40
| 30,108,381
| 59
| 8
|
Zlib
| 2021-09-26T17:30:30
| 2015-01-31T09:44:33
|
C
|
UTF-8
|
C++
| false
| false
| 1,640
|
cc
|
// Copyright (C) 2013-2022 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library 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 3, or (at your option)
// any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
//
// { dg-do run { target c++11 } }
// { dg-require-debug-mode "" }
#include <unordered_set>
#include <testsuite_hooks.h>
void test02()
{
using namespace __gnu_debug;
std::unordered_set<int> u = { 0, 1, 2 };
VERIFY( !__check_singular(u.end()) );
auto it = u.end();
VERIFY( !__check_singular(it) );
VERIFY( !__check_singular(u.begin()) );
it = u.begin();
VERIFY( !__check_singular(it) );
u.clear();
VERIFY( it._M_singular() );
VERIFY( __check_singular(it) );
it = u.end();
VERIFY( !it._M_singular() );
VERIFY( !__check_singular(it) );
u = { 0, 1, 2 };
auto bucket = u.bucket(0);
VERIFY( !__check_singular(u.begin(bucket)) );
auto lit = u.begin(bucket);
VERIFY( !__check_singular(lit) );
VERIFY( !__check_singular(u.end(bucket)) );
u.clear();
VERIFY( __check_singular(lit) );
}
int main()
{
test02();
return 0;
}
|
[
"rink@rink.nu"
] |
rink@rink.nu
|
3d63520db291b237da9274b926daa1c75bf167c8
|
564c21649799b8b59f47d6282865f0cf745b1f87
|
/services/ui/ws/window_manager_state.h
|
0e04d0bec8bfe53f89efdab8e4012799c25576fc
|
[
"Apache-2.0",
"BSD-3-Clause"
] |
permissive
|
pablosalazar7/WebARonARCore
|
e41f6277dd321c60084abad635819e0f70f2e9ff
|
43c5db480e89b59e4ae6349e36d8f375ee12cc0d
|
refs/heads/webarcore_57.0.2987.5
| 2023-02-23T04:58:12.756320
| 2018-01-17T17:40:20
| 2018-01-24T04:14:02
| 454,492,900
| 1
| 0
|
NOASSERTION
| 2022-02-01T17:56:03
| 2022-02-01T17:56:02
| null |
UTF-8
|
C++
| false
| false
| 10,144
|
h
|
// Copyright 2016 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 SERVICES_UI_WS_WINDOW_MANAGER_STATE_H_
#define SERVICES_UI_WS_WINDOW_MANAGER_STATE_H_
#include <stdint.h>
#include <memory>
#include <queue>
#include <vector>
#include "base/memory/weak_ptr.h"
#include "base/timer/timer.h"
#include "services/ui/public/interfaces/display_manager.mojom.h"
#include "services/ui/ws/event_dispatcher.h"
#include "services/ui/ws/event_dispatcher_delegate.h"
#include "services/ui/ws/server_window_observer.h"
#include "services/ui/ws/user_id.h"
#include "services/ui/ws/window_server.h"
namespace ui {
namespace ws {
class DisplayManager;
class WindowManagerDisplayRoot;
class WindowTree;
namespace test {
class WindowManagerStateTestApi;
}
// Manages state specific to a WindowManager that is shared across displays.
// WindowManagerState is owned by the WindowTree the window manager is
// associated with.
class WindowManagerState : public EventDispatcherDelegate,
public ServerWindowObserver {
public:
explicit WindowManagerState(WindowTree* window_tree);
~WindowManagerState() override;
const UserId& user_id() const;
WindowTree* window_tree() { return window_tree_; }
const WindowTree* window_tree() const { return window_tree_; }
void OnWillDestroyTree(WindowTree* tree);
void SetFrameDecorationValues(mojom::FrameDecorationValuesPtr values);
const mojom::FrameDecorationValues& frame_decoration_values() const {
return *frame_decoration_values_;
}
bool got_frame_decoration_values() const {
return got_frame_decoration_values_;
}
bool SetCapture(ServerWindow* window, ClientSpecificId client_id);
ServerWindow* capture_window() { return event_dispatcher_.capture_window(); }
const ServerWindow* capture_window() const {
return event_dispatcher_.capture_window();
}
void ReleaseCaptureBlockedByModalWindow(const ServerWindow* modal_window);
void ReleaseCaptureBlockedByAnyModalWindow();
void SetDragDropSourceWindow(
DragSource* drag_source,
ServerWindow* window,
DragTargetConnection* source_connection,
const std::unordered_map<std::string, std::vector<uint8_t>>& drag_data,
uint32_t drag_operation);
void CancelDragDrop();
void EndDragDrop();
void AddSystemModalWindow(ServerWindow* window);
// Returns the ServerWindow corresponding to an orphaned root with the
// specified id. See |orphaned_window_manager_display_roots_| for details on
// what on orphaned root is.
ServerWindow* GetOrphanedRootWithId(const WindowId& id);
// TODO(sky): EventDispatcher is really an implementation detail and should
// not be exposed.
EventDispatcher* event_dispatcher() { return &event_dispatcher_; }
// Returns true if this is the WindowManager of the active user.
bool IsActive() const;
void Activate(const gfx::Point& mouse_location_on_screen);
void Deactivate();
// Processes an event from PlatformDisplay.
void ProcessEvent(const ui::Event& event);
// Called when the ack from an event dispatched to WindowTree |tree| is
// received.
// TODO(sky): make this private and use a callback.
void OnEventAck(mojom::WindowTree* tree, mojom::EventResult result);
// Called when the WindowManager acks an accelerator.
void OnAcceleratorAck(mojom::EventResult result);
private:
class ProcessedEventTarget;
friend class Display;
friend class test::WindowManagerStateTestApi;
// Set of display roots. This is a vector rather than a set to support removal
// without deleting.
using WindowManagerDisplayRoots =
std::vector<std::unique_ptr<WindowManagerDisplayRoot>>;
enum class DebugAcceleratorType {
PRINT_WINDOWS,
};
struct DebugAccelerator {
bool Matches(const ui::KeyEvent& event) const;
DebugAcceleratorType type;
ui::KeyboardCode key_code;
int event_flags;
};
enum class EventDispatchPhase {
// Not actively dispatching.
NONE,
// A PRE_TARGET accelerator has been encountered and we're awaiting the ack.
PRE_TARGET_ACCELERATOR,
// Dispatching to the target, awaiting the ack.
TARGET,
};
// There are two types of events that may be queued, both occur only when
// waiting for an ack from a client.
// . We get an event from the PlatformDisplay. This results in |event| being
// set, but |processed_target| is null.
// . We get an event from the EventDispatcher. In this case both |event| and
// |processed_target| are valid.
// The second case happens if EventDispatcher generates more than one event
// at a time.
struct QueuedEvent {
QueuedEvent();
~QueuedEvent();
std::unique_ptr<ui::Event> event;
std::unique_ptr<ProcessedEventTarget> processed_target;
};
const WindowServer* window_server() const;
WindowServer* window_server();
DisplayManager* display_manager();
const DisplayManager* display_manager() const;
// Adds |display_root| to the set of WindowManagerDisplayRoots owned by this
// WindowManagerState.
void AddWindowManagerDisplayRoot(
std::unique_ptr<WindowManagerDisplayRoot> display_root);
// Called when a Display is deleted.
void OnDisplayDestroying(Display* display);
// Sets the visibility of all window manager roots windows to |value|.
void SetAllRootWindowsVisible(bool value);
// Returns the ServerWindow that is the root of the WindowManager for
// |window|. |window| corresponds to the root of a Display.
ServerWindow* GetWindowManagerRoot(ServerWindow* window);
// Called if the client doesn't ack an event in the appropriate amount of
// time.
void OnEventAckTimeout(ClientSpecificId client_id);
// Implemenation of processing an event with a match phase of all. This
// handles debug accelerators and forwards to EventDispatcher.
void ProcessEventImpl(const ui::Event& event);
// Schedules an event to be processed later.
void QueueEvent(const ui::Event& event,
std::unique_ptr<ProcessedEventTarget> processed_event_target);
// Processes the next valid event in |event_queue_|. If the event has already
// been processed it is dispatched, otherwise the event is passed to the
// EventDispatcher for processing.
void ProcessNextEventFromQueue();
// Dispatches the event to the appropriate client and starts the ack timer.
void DispatchInputEventToWindowImpl(ServerWindow* target,
ClientSpecificId client_id,
const ui::Event& event,
base::WeakPtr<Accelerator> accelerator);
// Registers accelerators used internally for debugging.
void AddDebugAccelerators();
// Finds the debug accelerator for |event| and if one is found calls
// HandleDebugAccelerator().
void ProcessDebugAccelerator(const ui::Event& event);
// Runs the specified debug accelerator.
void HandleDebugAccelerator(DebugAcceleratorType type);
// Called when waiting for an event or accelerator to be processed by |tree|.
void ScheduleInputEventTimeout(WindowTree* tree);
// EventDispatcherDelegate:
void OnAccelerator(uint32_t accelerator_id,
const ui::Event& event,
AcceleratorPhase phase) override;
void SetFocusedWindowFromEventDispatcher(ServerWindow* window) override;
ServerWindow* GetFocusedWindowForEventDispatcher() override;
void SetNativeCapture(ServerWindow* window) override;
void ReleaseNativeCapture() override;
void UpdateNativeCursorFromDispatcher() override;
void OnCaptureChanged(ServerWindow* new_capture,
ServerWindow* old_capture) override;
void OnMouseCursorLocationChanged(const gfx::Point& point) override;
void DispatchInputEventToWindow(ServerWindow* target,
ClientSpecificId client_id,
const ui::Event& event,
Accelerator* accelerator) override;
ClientSpecificId GetEventTargetClientId(const ServerWindow* window,
bool in_nonclient_area) override;
ServerWindow* GetRootWindowContaining(gfx::Point* location) override;
void OnEventTargetNotFound(const ui::Event& event) override;
// ServerWindowObserver:
void OnWindowEmbeddedAppDisconnected(ServerWindow* window) override;
// The single WindowTree this WindowManagerState is associated with.
// |window_tree_| owns this.
WindowTree* window_tree_;
// Set to true the first time SetFrameDecorationValues() is called.
bool got_frame_decoration_values_ = false;
mojom::FrameDecorationValuesPtr frame_decoration_values_;
EventDispatchPhase event_dispatch_phase_ = EventDispatchPhase::NONE;
// The tree we're waiting to process the current accelerator or event.
WindowTree* tree_awaiting_input_ack_ = nullptr;
// The event we're awaiting an accelerator or input ack from.
std::unique_ptr<ui::Event> event_awaiting_input_ack_;
base::WeakPtr<Accelerator> post_target_accelerator_;
std::queue<std::unique_ptr<QueuedEvent>> event_queue_;
base::OneShotTimer event_ack_timer_;
std::vector<DebugAccelerator> debug_accelerators_;
EventDispatcher event_dispatcher_;
// PlatformDisplay that currently has capture.
PlatformDisplay* platform_display_with_capture_ = nullptr;
// All the active WindowManagerDisplayRoots.
WindowManagerDisplayRoots window_manager_display_roots_;
// Set of WindowManagerDisplayRoots corresponding to Displays that have been
// destroyed. WindowManagerDisplayRoots are not destroyed immediately when
// the Display is destroyed to allow the client to destroy the window when it
// wants to. Once the client destroys the window WindowManagerDisplayRoots is
// destroyed.
WindowManagerDisplayRoots orphaned_window_manager_display_roots_;
base::WeakPtrFactory<WindowManagerState> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(WindowManagerState);
};
} // namespace ws
} // namespace ui
#endif // SERVICES_UI_WS_WINDOW_MANAGER_STATE_H_
|
[
"commit-bot@chromium.org"
] |
commit-bot@chromium.org
|
8b2ab7563cd2749f50b4bd3a154a886efe43bad2
|
602dab0925af232f18be0c2fb9dddb287385bf3e
|
/codechef programs/Polynomial.cpp
|
6e1f6beab6e29ff25dd9e7c49977fbb75af992b5
|
[] |
no_license
|
srnit/codeon
|
c5af9cd3de6f5f7e2bd63251451fc1e1e3b2b23e
|
fa51c809d263fb99d947d58a1a838dd9e1c2e7ad
|
refs/heads/master
| 2021-01-12T12:40:55.879728
| 2018-01-14T20:06:40
| 2018-01-14T20:06:40
| 69,899,399
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 853
|
cpp
|
//#include<stdio.h>
#include<bits/stdc++.h>
//#define M 786433
long long int fast_pow(long long base, long long n,long long M)
{
if(n==0)
return 1;
if(n==1)
return base;
long long halfn=fast_pow(base,n/2,M);
if(n%2==0)
return ( halfn * halfn ) % M;
else
return ( ( ( halfn * halfn ) % M ) * base ) % M;
}
int findMMI_fermat(int n,int M)
{
return fast_pow(n,M-2,M);
}
int main()
{
long long int M=786433;
long long int result;
long long int n,q,x,i,p,pa;
//long long int a[];
scanf("%lld",&n);
long long int a[n+1];
//a=(long int *)malloc(n*sizeof(long int));
//a=new long int(n);
for(i=0;i<=n;i++)
{
scanf("%lld",&a[i]);
}
scanf("%lld",&q);
while(q--)
{
result=0;
scanf("%lld",&x);
for(i=0;i<=n;i++)
{
p=fast_pow(x,i,M);
p=p%M;
pa=(a[i]*p)%M;
result=(result%M+pa%M)%M;
}
printf("%lld\n",result);
}
}
|
[
"ramansudhanshu150@gmail.com"
] |
ramansudhanshu150@gmail.com
|
88a35fb98409165a97f50a8c992dba285994c378
|
4c6bddbe93a8d3d525184a80548d0d7e76d51084
|
/GVRf/Framework/framework/src/main/jni/objects/components/component_types.h
|
344e4c7be445bb96c65ad27f4e31ee588ee1e5a9
|
[
"Apache-2.0"
] |
permissive
|
corgiflash/GearVRf
|
c54b8a8932159a1fa8ec7315ddc765d88fa9e3da
|
54135fc7bd961ab47aba599e60ced3ea0c7e43b1
|
refs/heads/master
| 2020-05-21T06:07:06.766759
| 2017-03-10T16:04:52
| 2017-03-10T16:04:52
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,458
|
h
|
/* Copyright 2015 Samsung Electronics Co., LTD
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef COMPONENT_TYPES_H
#define COMPONENT_TYPES_H
namespace gvr {
static const long long COMPONENT_TYPE_TRANSFORM = 10001;
static const long long COMPONENT_TYPE_LIGHT = 10002;
static const long long COMPONENT_TYPE_BONE = 10003;
static const long long COMPONENT_TYPE_BONE_WEIGHT = 10004;
static const long long COMPONENT_TYPE_CAMERA = 10005;
static const long long COMPONENT_TYPE_CAMERA_RIG = 10006;
static const long long COMPONENT_TYPE_COLLIDER = 10007;
static const long long COMPONENT_TYPE_RENDER_DATA = 10008;
static const long long COMPONENT_TYPE_TEXTURE_CAPTURER = 10009;
static const long long COMPONENT_TYPE_PHYSICS_RIGID_BODY = 10010;
static const long long COMPONENT_TYPE_PHYSICS_WORLD = 10011;
}
#endif
|
[
"m.marinov@samsung.com"
] |
m.marinov@samsung.com
|
ecec8a68c11523b516da2b336a2b93abde9d627b
|
f703bebbc497e6c91b8da9c19d26cbcc98a897fb
|
/acmp.ru/1161/1161.cpp
|
94a71fd698761316d5d1c6e995036a737a4ec1f9
|
[
"MIT"
] |
permissive
|
mstrechen/competitive-programming
|
1dc48163fc2960c54099077b7bfc0ed84912d2c2
|
ffac439840a71f70580a0ef197e47479e167a0eb
|
refs/heads/master
| 2021-09-22T21:09:24.340863
| 2018-09-16T13:48:51
| 2018-09-16T13:48:51
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 741
|
cpp
|
#include<iostream>
#include<vector>
using namespace std;
vector<int> zFunction(const string & s)
{
vector<int> z(s.size());
z[0] = 0;
int l = 0, r = 0;
for(int i = 1; i<(int)z.size(); i++)
{
int val = 0;
if(i<=r)
val = min(r-i+1, z[i-l]);
while(i+val < (int)s.size() && s[val] == s[i+val])
val++;
z[i] = val;
if(i + val > r)
{
l = i;
r = i+val-1;
}
}
return z;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
vector<int> z = zFunction(s);
for(auto i : z)
cout << i << ' ';
return 0;
}
|
[
"mvstrechen@gmail.com"
] |
mvstrechen@gmail.com
|
f9953f24a36e419415c3ac1be27839a2dfc223b4
|
16ebac78d01241c999ea11bd3e7ab73d11bea51e
|
/src/Scene2.h
|
8323407bacd378af4f0763ad3dd33fd97df72818
|
[] |
no_license
|
qingqhua/draw_the_world
|
1dcf904a15f4b6d5cdac755dc50d30be2fa181fe
|
4189778b5b4adc1949d168cad79eb2d730960a15
|
refs/heads/master
| 2021-06-23T21:00:46.641813
| 2017-09-04T06:40:03
| 2017-09-04T06:40:03
| 83,887,038
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 769
|
h
|
#pragma once
#include "ofApp.h"
#include "baseScene.h"
class Scene2 : public baseScene {
public:
void setup();
void update();
void draw();
void keyPressed(int key);
void keyReleased(int key);
void mouseMoved(int x, int y);
void mouseDragged(int x, int y, int button);
void mousePressed(int x, int y, int button);
void mouseReleased(int x, int y, int button);
void windowResized(int w, int h);
void initSequenceClimb();
void drawSequenceClimb();
private:
ofImage Background;//็ฌฌไธๅผ ่ๆฏ
ofRectangle AreaUp;//ๅไธ็็ฎญๅคดไฝ็ฝฎ
ofRectangle AreaLeft;//ๅๅทฆ็็ฎญๅคดไฝ็ฝฎ
ofRectangle AreaRight;//ๅๅณ็็ฎญๅคดไฝ็ฝฎ
vector <ofImage> climb;
int climbIndex;
bool ClimbAni,HasClimb;
ofSoundPlayer Tree;
EffectTree effect_Tree;
};
|
[
"ferhua.coder@outlook.com"
] |
ferhua.coder@outlook.com
|
37ebd2c194b83311a35c34c896300700314e245b
|
82fa7771ec3122a8e6b4b50495ecbcfd2f861639
|
/functions.hpp
|
bbe84f396e55b3de42be49d6af344f47d349c611
|
[
"Unlicense"
] |
permissive
|
michpolicht/BdfCGAL
|
4fc05a5026534296499fd7f2436f400a5b4938b5
|
0ceba33bee8a017c1f37cffcaae5fab8183f01ff
|
refs/heads/master
| 2022-12-17T10:25:08.430513
| 2020-09-20T16:20:45
| 2020-09-20T16:20:45
| 296,093,271
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 404
|
hpp
|
#ifndef FUNCTIONS_HPP
#define FUNCTIONS_HPP
#include <vector>
#include <utility>
inline
int squashIndex(int i, const std::vector<std::pair<int, int>> & ranges)
{
int squashed = i;
for (auto range : ranges) {
if (i > range.second)
squashed -= range.second - range.first;
else if ((i <= range.second) && (i >= range.first))
return squashed - (i - range.first);
}
return squashed;
}
#endif
|
[
"michpolicht@gmail.com"
] |
michpolicht@gmail.com
|
d2f2b220d6e2aadd6919d9c1ffc3cd1c8e41fa3f
|
ef35bb53fe910f8aab77600adbaa5a7370c479da
|
/src/net.cpp
|
ce73e014c652e53faf6b357ef9f9f0a712db3320
|
[
"MIT"
] |
permissive
|
jboss008/trollcoin
|
41eaf23c09fe4c50b2116b45590681cb84d8895d
|
d44de9bafc384b2d9cba39b742724a5d6b646d00
|
refs/heads/master
| 2021-01-01T17:04:59.583904
| 2014-01-06T11:52:36
| 2014-01-06T11:52:36
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 57,970
|
cpp
|
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Copyright (c) 2011-2012 Litecoin Developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "irc.h"
#include "db.h"
#include "net.h"
#include "init.h"
#include "strlcpy.h"
#include "addrman.h"
#include "ui_interface.h"
#ifdef WIN32
#include <string.h>
#endif
#ifdef USE_UPNP
#include <miniupnpc/miniwget.h>
#include <miniupnpc/miniupnpc.h>
#include <miniupnpc/upnpcommands.h>
#include <miniupnpc/upnperrors.h>
#endif
using namespace std;
using namespace boost;
static const int MAX_OUTBOUND_CONNECTIONS = 8;
void ThreadMessageHandler2(void* parg);
void ThreadSocketHandler2(void* parg);
void ThreadOpenConnections2(void* parg);
void ThreadOpenAddedConnections2(void* parg);
#ifdef USE_UPNP
void ThreadMapPort2(void* parg);
#endif
void ThreadDNSAddressSeed2(void* parg);
bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound = NULL, const char *strDest = NULL, bool fOneShot = false);
struct LocalServiceInfo {
int nScore;
int nPort;
};
//
// Global state variables
//
bool fClient = false;
bool fDiscover = true;
bool fUseUPnP = false;
uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
static CCriticalSection cs_mapLocalHost;
static map<CNetAddr, LocalServiceInfo> mapLocalHost;
static bool vfReachable[NET_MAX] = {};
static bool vfLimited[NET_MAX] = {};
static CNode* pnodeLocalHost = NULL;
uint64 nLocalHostNonce = 0;
array<int, THREAD_MAX> vnThreadsRunning;
static std::vector<SOCKET> vhListenSocket;
CAddrMan addrman;
vector<CNode*> vNodes;
CCriticalSection cs_vNodes;
map<CInv, CDataStream> mapRelay;
deque<pair<int64, CInv> > vRelayExpiration;
CCriticalSection cs_mapRelay;
map<CInv, int64> mapAlreadyAskedFor;
static deque<string> vOneShots;
CCriticalSection cs_vOneShots;
set<CNetAddr> setservAddNodeAddresses;
CCriticalSection cs_setservAddNodeAddresses;
static CSemaphore *semOutbound = NULL;
void AddOneShot(string strDest)
{
LOCK(cs_vOneShots);
vOneShots.push_back(strDest);
}
unsigned short GetListenPort()
{
return (unsigned short)(GetArg("-port", GetDefaultPort()));
}
void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
{
// Filter out duplicate requests
if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
return;
pindexLastGetBlocksBegin = pindexBegin;
hashLastGetBlocksEnd = hashEnd;
PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
}
// find 'best' local address for a particular peer
bool GetLocal(CService& addr, const CNetAddr *paddrPeer)
{
if (fNoListen)
return false;
int nBestScore = -1;
int nBestReachability = -1;
{
LOCK(cs_mapLocalHost);
for (map<CNetAddr, LocalServiceInfo>::iterator it = mapLocalHost.begin(); it != mapLocalHost.end(); it++)
{
int nScore = (*it).second.nScore;
int nReachability = (*it).first.GetReachabilityFrom(paddrPeer);
if (nReachability > nBestReachability || (nReachability == nBestReachability && nScore > nBestScore))
{
addr = CService((*it).first, (*it).second.nPort);
nBestReachability = nReachability;
nBestScore = nScore;
}
}
}
return nBestScore >= 0;
}
// get best local address for a particular peer as a CAddress
CAddress GetLocalAddress(const CNetAddr *paddrPeer)
{
CAddress ret(CService("0.0.0.0",0),0);
CService addr;
if (GetLocal(addr, paddrPeer))
{
ret = CAddress(addr);
ret.nServices = nLocalServices;
ret.nTime = GetAdjustedTime();
}
return ret;
}
bool RecvLine(SOCKET hSocket, string& strLine)
{
strLine = "";
loop
{
char c;
int nBytes = recv(hSocket, &c, 1, 0);
if (nBytes > 0)
{
if (c == '\n')
continue;
if (c == '\r')
return true;
strLine += c;
if (strLine.size() >= 9000)
return true;
}
else if (nBytes <= 0)
{
if (fShutdown)
return false;
if (nBytes < 0)
{
int nErr = WSAGetLastError();
if (nErr == WSAEMSGSIZE)
continue;
if (nErr == WSAEWOULDBLOCK || nErr == WSAEINTR || nErr == WSAEINPROGRESS)
{
Sleep(10);
continue;
}
}
if (!strLine.empty())
return true;
if (nBytes == 0)
{
// socket closed
printf("socket closed\n");
return false;
}
else
{
// socket error
int nErr = WSAGetLastError();
printf("recv failed: %d\n", nErr);
return false;
}
}
}
}
// used when scores of local addresses may have changed
// pushes better local address to peers
void static AdvertizeLocal()
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
{
if (pnode->fSuccessfullyConnected)
{
CAddress addrLocal = GetLocalAddress(&pnode->addr);
if (addrLocal.IsRoutable() && (CService)addrLocal != (CService)pnode->addrLocal)
{
pnode->PushAddress(addrLocal);
pnode->addrLocal = addrLocal;
}
}
}
}
void SetReachable(enum Network net, bool fFlag)
{
LOCK(cs_mapLocalHost);
vfReachable[net] = fFlag;
if (net == NET_IPV6 && fFlag)
vfReachable[NET_IPV4] = true;
}
// learn a new local address
bool AddLocal(const CService& addr, int nScore)
{
if (!addr.IsRoutable())
return false;
if (!fDiscover && nScore < LOCAL_MANUAL)
return false;
if (IsLimited(addr))
return false;
printf("AddLocal(%s,%i)\n", addr.ToString().c_str(), nScore);
{
LOCK(cs_mapLocalHost);
bool fAlready = mapLocalHost.count(addr) > 0;
LocalServiceInfo &info = mapLocalHost[addr];
if (!fAlready || nScore >= info.nScore) {
info.nScore = nScore;
info.nPort = addr.GetPort() + (fAlready ? 1 : 0);
}
SetReachable(addr.GetNetwork());
}
AdvertizeLocal();
return true;
}
bool AddLocal(const CNetAddr &addr, int nScore)
{
return AddLocal(CService(addr, GetListenPort()), nScore);
}
/** Make a particular network entirely off-limits (no automatic connects to it) */
void SetLimited(enum Network net, bool fLimited)
{
if (net == NET_UNROUTABLE)
return;
LOCK(cs_mapLocalHost);
vfLimited[net] = fLimited;
}
bool IsLimited(enum Network net)
{
LOCK(cs_mapLocalHost);
return vfLimited[net];
}
bool IsLimited(const CNetAddr &addr)
{
return IsLimited(addr.GetNetwork());
}
/** vote for a local address */
bool SeenLocal(const CService& addr)
{
{
LOCK(cs_mapLocalHost);
if (mapLocalHost.count(addr) == 0)
return false;
mapLocalHost[addr].nScore++;
}
AdvertizeLocal();
return true;
}
/** check whether a given address is potentially local */
bool IsLocal(const CService& addr)
{
LOCK(cs_mapLocalHost);
return mapLocalHost.count(addr) > 0;
}
/** check whether a given address is in a network we can probably connect to */
bool IsReachable(const CNetAddr& addr)
{
LOCK(cs_mapLocalHost);
enum Network net = addr.GetNetwork();
return vfReachable[net] && !vfLimited[net];
}
bool GetMyExternalIP2(const CService& addrConnect, const char* pszGet, const char* pszKeyword, CNetAddr& ipRet)
{
SOCKET hSocket;
if (!ConnectSocket(addrConnect, hSocket))
return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
string strLine;
while (RecvLine(hSocket, strLine))
{
if (strLine.empty()) // HTTP response is separated from headers by blank line
{
loop
{
if (!RecvLine(hSocket, strLine))
{
closesocket(hSocket);
return false;
}
if (pszKeyword == NULL)
break;
if (strLine.find(pszKeyword) != string::npos)
{
strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
break;
}
}
closesocket(hSocket);
if (strLine.find("<") != string::npos)
strLine = strLine.substr(0, strLine.find("<"));
strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
strLine.resize(strLine.size()-1);
CService addr(strLine,0,true);
printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
if (!addr.IsValid() || !addr.IsRoutable())
return false;
ipRet.SetIP(addr);
return true;
}
}
closesocket(hSocket);
return error("GetMyExternalIP() : connection closed");
}
// We now get our external IP from the IRC server first and only use this as a backup
bool GetMyExternalIP(CNetAddr& ipRet)
{
CService addrConnect;
const char* pszGet;
const char* pszKeyword;
for (int nLookup = 0; nLookup <= 1; nLookup++)
for (int nHost = 1; nHost <= 2; nHost++)
{
// We should be phasing out our use of sites like these. If we need
// replacements, we should ask for volunteers to put this simple
// php file on their webserver that prints the client IP:
// <?php echo $_SERVER["REMOTE_ADDR"]; ?>
if (nHost == 1)
{
addrConnect = CService("91.198.22.70",80); // checkip.dyndns.org
if (nLookup == 1)
{
CService addrIP("checkip.dyndns.org", 80, true);
if (addrIP.IsValid())
addrConnect = addrIP;
}
pszGet = "GET / HTTP/1.1\r\n"
"Host: checkip.dyndns.org\r\n"
"User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
"Connection: close\r\n"
"\r\n";
pszKeyword = "Address:";
}
else if (nHost == 2)
{
addrConnect = CService("74.208.43.192", 80); // www.showmyip.com
if (nLookup == 1)
{
CService addrIP("www.showmyip.com", 80, true);
if (addrIP.IsValid())
addrConnect = addrIP;
}
pszGet = "GET /simple/ HTTP/1.1\r\n"
"Host: www.showmyip.com\r\n"
"User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
"Connection: close\r\n"
"\r\n";
pszKeyword = NULL; // Returns just IP address
}
if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
return true;
}
return false;
}
void ThreadGetMyExternalIP(void* parg)
{
// Make this thread recognisable as the external IP detection thread
RenameThread("bitcoin-ext-ip");
CNetAddr addrLocalHost;
if (GetMyExternalIP(addrLocalHost))
{
printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
AddLocal(addrLocalHost, LOCAL_HTTP);
}
}
void AddressCurrentlyConnected(const CService& addr)
{
addrman.Connected(addr);
}
CNode* FindNode(const CNetAddr& ip)
{
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
if ((CNetAddr)pnode->addr == ip)
return (pnode);
}
return NULL;
}
CNode* FindNode(std::string addrName)
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
if (pnode->addrName == addrName)
return (pnode);
return NULL;
}
CNode* FindNode(const CService& addr)
{
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
if ((CService)pnode->addr == addr)
return (pnode);
}
return NULL;
}
CNode* ConnectNode(CAddress addrConnect, const char *pszDest, int64 nTimeout)
{
if (pszDest == NULL) {
if (IsLocal(addrConnect))
return NULL;
// Look for an existing connection
CNode* pnode = FindNode((CService)addrConnect);
if (pnode)
{
if (nTimeout != 0)
pnode->AddRef(nTimeout);
else
pnode->AddRef();
return pnode;
}
}
/// debug print
printf("trying connection %s lastseen=%.1fhrs\n",
pszDest ? pszDest : addrConnect.ToString().c_str(),
pszDest ? 0 : (double)(GetAdjustedTime() - addrConnect.nTime)/3600.0);
// Connect
SOCKET hSocket;
if (pszDest ? ConnectSocketByName(addrConnect, hSocket, pszDest, GetDefaultPort()) : ConnectSocket(addrConnect, hSocket))
{
addrman.Attempt(addrConnect);
/// debug print
printf("connected %s\n", pszDest ? pszDest : addrConnect.ToString().c_str());
// Set to nonblocking
#ifdef WIN32
u_long nOne = 1;
if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
#else
if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
#endif
// Add node
CNode* pnode = new CNode(hSocket, addrConnect, pszDest ? pszDest : "", false);
if (nTimeout != 0)
pnode->AddRef(nTimeout);
else
pnode->AddRef();
{
LOCK(cs_vNodes);
vNodes.push_back(pnode);
}
pnode->nTimeConnected = GetTime();
return pnode;
}
else
{
return NULL;
}
}
void CNode::CloseSocketDisconnect()
{
fDisconnect = true;
if (hSocket != INVALID_SOCKET)
{
printf("disconnecting node %s\n", addrName.c_str());
closesocket(hSocket);
hSocket = INVALID_SOCKET;
vRecv.clear();
}
}
void CNode::Cleanup()
{
}
void CNode::PushVersion()
{
/// when NTP implemented, change to just nTime = GetAdjustedTime()
int64 nTime = (fInbound ? GetAdjustedTime() : GetTime());
CAddress addrYou = (addr.IsRoutable() && !IsProxy(addr) ? addr : CAddress(CService("0.0.0.0",0)));
CAddress addrMe = GetLocalAddress(&addr);
RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
printf("send version message: version %d, blocks=%d, us=%s, them=%s, peer=%s\n", PROTOCOL_VERSION, nBestHeight, addrMe.ToString().c_str(), addrYou.ToString().c_str(), addr.ToString().c_str());
PushMessage("version", PROTOCOL_VERSION, nLocalServices, nTime, addrYou, addrMe,
nLocalHostNonce, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<string>()), nBestHeight);
}
std::map<CNetAddr, int64> CNode::setBanned;
CCriticalSection CNode::cs_setBanned;
void CNode::ClearBanned()
{
setBanned.clear();
}
bool CNode::IsBanned(CNetAddr ip)
{
bool fResult = false;
{
LOCK(cs_setBanned);
std::map<CNetAddr, int64>::iterator i = setBanned.find(ip);
if (i != setBanned.end())
{
int64 t = (*i).second;
if (GetTime() < t)
fResult = true;
}
}
return fResult;
}
bool CNode::Misbehaving(int howmuch)
{
if (addr.IsLocal())
{
printf("Warning: local node %s misbehaving\n", addrName.c_str());
return false;
}
nMisbehavior += howmuch;
if (nMisbehavior >= GetArg("-banscore", 100))
{
int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
{
LOCK(cs_setBanned);
if (setBanned[addr] < banTime)
setBanned[addr] = banTime;
}
CloseSocketDisconnect();
printf("Disconnected %s for misbehavior (score=%d)\n", addrName.c_str(), nMisbehavior);
return true;
}
return false;
}
#undef X
#define X(name) stats.name = name
void CNode::copyStats(CNodeStats &stats)
{
X(nServices);
X(nLastSend);
X(nLastRecv);
X(nTimeConnected);
X(addrName);
X(nVersion);
X(strSubVer);
X(fInbound);
X(nReleaseTime);
X(nStartingHeight);
X(nMisbehavior);
}
#undef X
void ThreadSocketHandler(void* parg)
{
IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
// Make this thread recognisable as the networking thread
RenameThread("bitcoin-net");
try
{
vnThreadsRunning[THREAD_SOCKETHANDLER]++;
ThreadSocketHandler2(parg);
vnThreadsRunning[THREAD_SOCKETHANDLER]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_SOCKETHANDLER]--;
PrintException(&e, "ThreadSocketHandler()");
} catch (...) {
vnThreadsRunning[THREAD_SOCKETHANDLER]--;
throw; // support pthread_cancel()
}
printf("ThreadSocketHandler exited\n");
}
void ThreadSocketHandler2(void* parg)
{
printf("ThreadSocketHandler started\n");
list<CNode*> vNodesDisconnected;
unsigned int nPrevNodeCount = 0;
loop
{
//
// Disconnect nodes
//
{
LOCK(cs_vNodes);
// Disconnect unused nodes
vector<CNode*> vNodesCopy = vNodes;
BOOST_FOREACH(CNode* pnode, vNodesCopy)
{
if (pnode->fDisconnect ||
(pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
{
// remove from vNodes
vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
// release outbound grant (if any)
pnode->grantOutbound.Release();
// close socket and cleanup
pnode->CloseSocketDisconnect();
pnode->Cleanup();
// hold in disconnected pool until all refs are released
pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
if (pnode->fNetworkNode || pnode->fInbound)
pnode->Release();
vNodesDisconnected.push_back(pnode);
}
}
// Delete disconnected nodes
list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
{
// wait until threads are done using it
if (pnode->GetRefCount() <= 0)
{
bool fDelete = false;
{
TRY_LOCK(pnode->cs_vSend, lockSend);
if (lockSend)
{
TRY_LOCK(pnode->cs_vRecv, lockRecv);
if (lockRecv)
{
TRY_LOCK(pnode->cs_mapRequests, lockReq);
if (lockReq)
{
TRY_LOCK(pnode->cs_inventory, lockInv);
if (lockInv)
fDelete = true;
}
}
}
}
if (fDelete)
{
vNodesDisconnected.remove(pnode);
delete pnode;
}
}
}
}
if (vNodes.size() != nPrevNodeCount)
{
nPrevNodeCount = vNodes.size();
uiInterface.NotifyNumConnectionsChanged(vNodes.size());
}
//
// Find which sockets have data to receive
//
struct timeval timeout;
timeout.tv_sec = 0;
timeout.tv_usec = 50000; // frequency to poll pnode->vSend
fd_set fdsetRecv;
fd_set fdsetSend;
fd_set fdsetError;
FD_ZERO(&fdsetRecv);
FD_ZERO(&fdsetSend);
FD_ZERO(&fdsetError);
SOCKET hSocketMax = 0;
BOOST_FOREACH(SOCKET hListenSocket, vhListenSocket) {
FD_SET(hListenSocket, &fdsetRecv);
hSocketMax = max(hSocketMax, hListenSocket);
}
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
{
if (pnode->hSocket == INVALID_SOCKET)
continue;
FD_SET(pnode->hSocket, &fdsetRecv);
FD_SET(pnode->hSocket, &fdsetError);
hSocketMax = max(hSocketMax, pnode->hSocket);
{
TRY_LOCK(pnode->cs_vSend, lockSend);
if (lockSend && !pnode->vSend.empty())
FD_SET(pnode->hSocket, &fdsetSend);
}
}
}
vnThreadsRunning[THREAD_SOCKETHANDLER]--;
int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
vnThreadsRunning[THREAD_SOCKETHANDLER]++;
if (fShutdown)
return;
if (nSelect == SOCKET_ERROR)
{
int nErr = WSAGetLastError();
if (hSocketMax != INVALID_SOCKET)
{
printf("socket select error %d\n", nErr);
for (unsigned int i = 0; i <= hSocketMax; i++)
FD_SET(i, &fdsetRecv);
}
FD_ZERO(&fdsetSend);
FD_ZERO(&fdsetError);
Sleep(timeout.tv_usec/1000);
}
//
// Accept new connections
//
BOOST_FOREACH(SOCKET hListenSocket, vhListenSocket)
if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
{
#ifdef USE_IPV6
struct sockaddr_storage sockaddr;
#else
struct sockaddr sockaddr;
#endif
socklen_t len = sizeof(sockaddr);
SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
CAddress addr;
int nInbound = 0;
if (hSocket != INVALID_SOCKET)
if (!addr.SetSockAddr((const struct sockaddr*)&sockaddr))
printf("warning: unknown socket family\n");
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
if (pnode->fInbound)
nInbound++;
}
if (hSocket == INVALID_SOCKET)
{
if (WSAGetLastError() != WSAEWOULDBLOCK)
printf("socket error accept failed: %d\n", WSAGetLastError());
}
else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
{
{
LOCK(cs_setservAddNodeAddresses);
if (!setservAddNodeAddresses.count(addr))
closesocket(hSocket);
}
}
else if (CNode::IsBanned(addr))
{
printf("connection from %s dropped (banned)\n", addr.ToString().c_str());
closesocket(hSocket);
}
else
{
printf("accepted connection %s\n", addr.ToString().c_str());
CNode* pnode = new CNode(hSocket, addr, "", true);
pnode->AddRef();
{
LOCK(cs_vNodes);
vNodes.push_back(pnode);
}
}
}
//
// Service each socket
//
vector<CNode*> vNodesCopy;
{
LOCK(cs_vNodes);
vNodesCopy = vNodes;
BOOST_FOREACH(CNode* pnode, vNodesCopy)
pnode->AddRef();
}
BOOST_FOREACH(CNode* pnode, vNodesCopy)
{
if (fShutdown)
return;
//
// Receive
//
if (pnode->hSocket == INVALID_SOCKET)
continue;
if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
{
TRY_LOCK(pnode->cs_vRecv, lockRecv);
if (lockRecv)
{
CDataStream& vRecv = pnode->vRecv;
unsigned int nPos = vRecv.size();
if (nPos > ReceiveBufferSize()) {
if (!pnode->fDisconnect)
printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
pnode->CloseSocketDisconnect();
}
else {
// typical socket buffer is 8K-64K
char pchBuf[0x10000];
int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
if (nBytes > 0)
{
vRecv.resize(nPos + nBytes);
memcpy(&vRecv[nPos], pchBuf, nBytes);
pnode->nLastRecv = GetTime();
}
else if (nBytes == 0)
{
// socket closed gracefully
if (!pnode->fDisconnect)
printf("socket closed\n");
pnode->CloseSocketDisconnect();
}
else if (nBytes < 0)
{
// error
int nErr = WSAGetLastError();
if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
{
if (!pnode->fDisconnect)
printf("socket recv error %d\n", nErr);
pnode->CloseSocketDisconnect();
}
}
}
}
}
//
// Send
//
if (pnode->hSocket == INVALID_SOCKET)
continue;
if (FD_ISSET(pnode->hSocket, &fdsetSend))
{
TRY_LOCK(pnode->cs_vSend, lockSend);
if (lockSend)
{
CDataStream& vSend = pnode->vSend;
if (!vSend.empty())
{
int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
if (nBytes > 0)
{
vSend.erase(vSend.begin(), vSend.begin() + nBytes);
pnode->nLastSend = GetTime();
}
else if (nBytes < 0)
{
// error
int nErr = WSAGetLastError();
if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
{
printf("socket send error %d\n", nErr);
pnode->CloseSocketDisconnect();
}
}
}
}
}
//
// Inactivity checking
//
if (pnode->vSend.empty())
pnode->nLastSendEmpty = GetTime();
if (GetTime() - pnode->nTimeConnected > 60)
{
if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
{
printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
pnode->fDisconnect = true;
}
else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
{
printf("socket not sending\n");
pnode->fDisconnect = true;
}
else if (GetTime() - pnode->nLastRecv > 90*60)
{
printf("socket inactivity timeout\n");
pnode->fDisconnect = true;
}
}
}
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodesCopy)
pnode->Release();
}
Sleep(10);
}
}
#ifdef USE_UPNP
void ThreadMapPort(void* parg)
{
IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
// Make this thread recognisable as the UPnP thread
RenameThread("bitcoin-UPnP");
try
{
vnThreadsRunning[THREAD_UPNP]++;
ThreadMapPort2(parg);
vnThreadsRunning[THREAD_UPNP]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_UPNP]--;
PrintException(&e, "ThreadMapPort()");
} catch (...) {
vnThreadsRunning[THREAD_UPNP]--;
PrintException(NULL, "ThreadMapPort()");
}
printf("ThreadMapPort exited\n");
}
void ThreadMapPort2(void* parg)
{
printf("ThreadMapPort started\n");
char port[6];
sprintf(port, "%d", GetListenPort());
const char * multicastif = 0;
const char * minissdpdpath = 0;
struct UPNPDev * devlist = 0;
char lanaddr[64];
#ifndef UPNPDISCOVER_SUCCESS
/* miniupnpc 1.5 */
devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
#else
/* miniupnpc 1.6 */
int error = 0;
devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
#endif
struct UPNPUrls urls;
struct IGDdatas data;
int r;
r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
if (r == 1)
{
if (fDiscover) {
char externalIPAddress[40];
r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
if(r != UPNPCOMMAND_SUCCESS)
printf("UPnP: GetExternalIPAddress() returned %d\n", r);
else
{
if(externalIPAddress[0])
{
printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
AddLocal(CNetAddr(externalIPAddress), LOCAL_UPNP);
}
else
printf("UPnP: GetExternalIPAddress failed.\n");
}
}
string strDesc = "TrollCoin " + FormatFullVersion();
#ifndef UPNPDISCOVER_SUCCESS
/* miniupnpc 1.5 */
r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
port, port, lanaddr, strDesc.c_str(), "TCP", 0);
#else
/* miniupnpc 1.6 */
r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
#endif
if(r!=UPNPCOMMAND_SUCCESS)
printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
port, port, lanaddr, r, strupnperror(r));
else
printf("UPnP Port Mapping successful.\n");
int i = 1;
loop {
if (fShutdown || !fUseUPnP)
{
r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
printf("UPNP_DeletePortMapping() returned : %d\n", r);
freeUPNPDevlist(devlist); devlist = 0;
FreeUPNPUrls(&urls);
return;
}
if (i % 600 == 0) // Refresh every 20 minutes
{
#ifndef UPNPDISCOVER_SUCCESS
/* miniupnpc 1.5 */
r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
port, port, lanaddr, strDesc.c_str(), "TCP", 0);
#else
/* miniupnpc 1.6 */
r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
#endif
if(r!=UPNPCOMMAND_SUCCESS)
printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
port, port, lanaddr, r, strupnperror(r));
else
printf("UPnP Port Mapping successful.\n");;
}
Sleep(2000);
i++;
}
} else {
printf("No valid UPnP IGDs found\n");
freeUPNPDevlist(devlist); devlist = 0;
if (r != 0)
FreeUPNPUrls(&urls);
loop {
if (fShutdown || !fUseUPnP)
return;
Sleep(2000);
}
}
}
void MapPort()
{
if (fUseUPnP && vnThreadsRunning[THREAD_UPNP] < 1)
{
if (!CreateThread(ThreadMapPort, NULL))
printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
}
}
#else
void MapPort()
{
// Intentionally left blank.
}
#endif
// DNS seeds
// Each pair gives a source name and a seed name.
// The first name is used as information source for addrman.
// The second name should resolve to a list of seed addresses.
static const char *strDNSSeed[][2] = {
{"cpool1.cryptminer.net", "dnsseed.cryptminer.net"},
//{"bytesized-vps.com", "dnsseed.bytesized-vps.com"},
//{"xurious.com", "dnsseed.ltc.xurious.com"},
};
void ThreadDNSAddressSeed(void* parg)
{
IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
// Make this thread recognisable as the DNS seeding thread
RenameThread("bitcoin-dnsseed");
try
{
vnThreadsRunning[THREAD_DNSSEED]++;
ThreadDNSAddressSeed2(parg);
vnThreadsRunning[THREAD_DNSSEED]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_DNSSEED]--;
PrintException(&e, "ThreadDNSAddressSeed()");
} catch (...) {
vnThreadsRunning[THREAD_DNSSEED]--;
throw; // support pthread_cancel()
}
printf("ThreadDNSAddressSeed exited\n");
}
void ThreadDNSAddressSeed2(void* parg)
{
printf("ThreadDNSAddressSeed started\n");
int found = 0;
if (!fTestNet)
{
printf("Loading addresses from DNS seeds (could take a while)\n");
for (unsigned int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
if (GetNameProxy()) {
AddOneShot(strDNSSeed[seed_idx][1]);
} else {
vector<CNetAddr> vaddr;
vector<CAddress> vAdd;
if (LookupHost(strDNSSeed[seed_idx][1], vaddr))
{
BOOST_FOREACH(CNetAddr& ip, vaddr)
{
int nOneDay = 24*3600;
CAddress addr = CAddress(CService(ip, GetDefaultPort()));
addr.nTime = GetTime() - 3*nOneDay - GetRand(4*nOneDay); // use a random age between 3 and 7 days old
vAdd.push_back(addr);
found++;
}
}
addrman.Add(vAdd, CNetAddr(strDNSSeed[seed_idx][0], true));
}
}
}
printf("%d addresses found from DNS seeds\n", found);
}
unsigned int pnSeed[] =
{
0x2EFDCB71, 0xCC1B3AD6, 0xADA77149,
};
void DumpAddresses()
{
int64 nStart = GetTimeMillis();
CAddrDB adb;
adb.Write(addrman);
printf("Flushed %d addresses to peers.dat %"PRI64d"ms\n",
addrman.size(), GetTimeMillis() - nStart);
}
void ThreadDumpAddress2(void* parg)
{
vnThreadsRunning[THREAD_DUMPADDRESS]++;
while (!fShutdown)
{
DumpAddresses();
vnThreadsRunning[THREAD_DUMPADDRESS]--;
Sleep(100000);
vnThreadsRunning[THREAD_DUMPADDRESS]++;
}
vnThreadsRunning[THREAD_DUMPADDRESS]--;
}
void ThreadDumpAddress(void* parg)
{
IMPLEMENT_RANDOMIZE_STACK(ThreadDumpAddress(parg));
// Make this thread recognisable as the address dumping thread
RenameThread("bitcoin-adrdump");
try
{
ThreadDumpAddress2(parg);
}
catch (std::exception& e) {
PrintException(&e, "ThreadDumpAddress()");
}
printf("ThreadDumpAddress exited\n");
}
void ThreadOpenConnections(void* parg)
{
IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
// Make this thread recognisable as the connection opening thread
RenameThread("bitcoin-opencon");
try
{
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
ThreadOpenConnections2(parg);
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
PrintException(&e, "ThreadOpenConnections()");
} catch (...) {
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
PrintException(NULL, "ThreadOpenConnections()");
}
printf("ThreadOpenConnections exited\n");
}
void static ProcessOneShot()
{
string strDest;
{
LOCK(cs_vOneShots);
if (vOneShots.empty())
return;
strDest = vOneShots.front();
vOneShots.pop_front();
}
CAddress addr;
CSemaphoreGrant grant(*semOutbound, true);
if (grant) {
if (!OpenNetworkConnection(addr, &grant, strDest.c_str(), true))
AddOneShot(strDest);
}
}
void ThreadOpenConnections2(void* parg)
{
printf("ThreadOpenConnections started\n");
// Connect to specific addresses
if (mapArgs.count("-connect"))
{
for (int64 nLoop = 0;; nLoop++)
{
ProcessOneShot();
BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
{
CAddress addr;
OpenNetworkConnection(addr, NULL, strAddr.c_str());
for (int i = 0; i < 10 && i < nLoop; i++)
{
Sleep(500);
if (fShutdown)
return;
}
}
}
}
// Initiate network connections
int64 nStart = GetTime();
loop
{
ProcessOneShot();
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
Sleep(500);
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
if (fShutdown)
return;
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
CSemaphoreGrant grant(*semOutbound);
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
if (fShutdown)
return;
// Add seed nodes if IRC isn't working
if (addrman.size()==0 && (GetTime() - nStart > 60) && !fTestNet)
{
std::vector<CAddress> vAdd;
for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++)
{
// It'll only connect to one or two seed nodes because once it connects,
// it'll get a pile of addresses with newer timestamps.
// Seed nodes are given a random 'last seen time' of between one and two
// weeks ago.
const int64 nOneWeek = 7*24*60*60;
struct in_addr ip;
memcpy(&ip, &pnSeed[i], sizeof(ip));
CAddress addr(CService(ip, GetDefaultPort()));
addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
vAdd.push_back(addr);
}
addrman.Add(vAdd, CNetAddr("127.0.0.1"));
}
//
// Choose an address to connect to based on most recently seen
//
CAddress addrConnect;
// Only connect out to one peer per network group (/16 for IPv4).
// Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
int nOutbound = 0;
set<vector<unsigned char> > setConnected;
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes) {
if (!pnode->fInbound) {
setConnected.insert(pnode->addr.GetGroup());
nOutbound++;
}
}
}
int64 nANow = GetAdjustedTime();
int nTries = 0;
loop
{
// use an nUnkBias between 10 (no outgoing connections) and 90 (8 outgoing connections)
CAddress addr = addrman.Select(10 + min(nOutbound,8)*10);
// if we selected an invalid address, restart
if (!addr.IsValid() || setConnected.count(addr.GetGroup()) || IsLocal(addr))
break;
nTries++;
if (IsLimited(addr))
continue;
// only consider very recently tried nodes after 30 failed attempts
if (nANow - addr.nLastTry < 600 && nTries < 30)
continue;
// do not allow non-default ports, unless after 50 invalid addresses selected already
if (addr.GetPort() != GetDefaultPort() && nTries < 50)
continue;
addrConnect = addr;
break;
}
if (addrConnect.IsValid())
OpenNetworkConnection(addrConnect, &grant);
}
}
void ThreadOpenAddedConnections(void* parg)
{
IMPLEMENT_RANDOMIZE_STACK(ThreadOpenAddedConnections(parg));
// Make this thread recognisable as the connection opening thread
RenameThread("bitcoin-opencon");
try
{
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]++;
ThreadOpenAddedConnections2(parg);
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
PrintException(&e, "ThreadOpenAddedConnections()");
} catch (...) {
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
PrintException(NULL, "ThreadOpenAddedConnections()");
}
printf("ThreadOpenAddedConnections exited\n");
}
void ThreadOpenAddedConnections2(void* parg)
{
printf("ThreadOpenAddedConnections started\n");
if (mapArgs.count("-addnode") == 0)
return;
if (GetNameProxy()) {
while(!fShutdown) {
BOOST_FOREACH(string& strAddNode, mapMultiArgs["-addnode"]) {
CAddress addr;
CSemaphoreGrant grant(*semOutbound);
OpenNetworkConnection(addr, &grant, strAddNode.c_str());
Sleep(500);
}
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
Sleep(120000); // Retry every 2 minutes
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]++;
}
return;
}
vector<vector<CService> > vservAddressesToAdd(0);
BOOST_FOREACH(string& strAddNode, mapMultiArgs["-addnode"])
{
vector<CService> vservNode(0);
if(Lookup(strAddNode.c_str(), vservNode, GetDefaultPort(), fNameLookup, 0))
{
vservAddressesToAdd.push_back(vservNode);
{
LOCK(cs_setservAddNodeAddresses);
BOOST_FOREACH(CService& serv, vservNode)
setservAddNodeAddresses.insert(serv);
}
}
}
loop
{
vector<vector<CService> > vservConnectAddresses = vservAddressesToAdd;
// Attempt to connect to each IP for each addnode entry until at least one is successful per addnode entry
// (keeping in mind that addnode entries can have many IPs if fNameLookup)
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes)
for (vector<vector<CService> >::iterator it = vservConnectAddresses.begin(); it != vservConnectAddresses.end(); it++)
BOOST_FOREACH(CService& addrNode, *(it))
if (pnode->addr == addrNode)
{
it = vservConnectAddresses.erase(it);
it--;
break;
}
}
BOOST_FOREACH(vector<CService>& vserv, vservConnectAddresses)
{
CSemaphoreGrant grant(*semOutbound);
OpenNetworkConnection(CAddress(*(vserv.begin())), &grant);
Sleep(500);
if (fShutdown)
return;
}
if (fShutdown)
return;
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]--;
Sleep(120000); // Retry every 2 minutes
vnThreadsRunning[THREAD_ADDEDCONNECTIONS]++;
if (fShutdown)
return;
}
}
// if succesful, this moves the passed grant to the constructed node
bool OpenNetworkConnection(const CAddress& addrConnect, CSemaphoreGrant *grantOutbound, const char *strDest, bool fOneShot)
{
//
// Initiate outbound network connection
//
if (fShutdown)
return false;
if (!strDest)
if (IsLocal(addrConnect) ||
FindNode((CNetAddr)addrConnect) || CNode::IsBanned(addrConnect) ||
FindNode(addrConnect.ToStringIPPort().c_str()))
return false;
if (strDest && FindNode(strDest))
return false;
vnThreadsRunning[THREAD_OPENCONNECTIONS]--;
CNode* pnode = ConnectNode(addrConnect, strDest);
vnThreadsRunning[THREAD_OPENCONNECTIONS]++;
if (fShutdown)
return false;
if (!pnode)
return false;
if (grantOutbound)
grantOutbound->MoveTo(pnode->grantOutbound);
pnode->fNetworkNode = true;
if (fOneShot)
pnode->fOneShot = true;
return true;
}
void ThreadMessageHandler(void* parg)
{
IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
// Make this thread recognisable as the message handling thread
RenameThread("bitcoin-msghand");
try
{
vnThreadsRunning[THREAD_MESSAGEHANDLER]++;
ThreadMessageHandler2(parg);
vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
}
catch (std::exception& e) {
vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
PrintException(&e, "ThreadMessageHandler()");
} catch (...) {
vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
PrintException(NULL, "ThreadMessageHandler()");
}
printf("ThreadMessageHandler exited\n");
}
void ThreadMessageHandler2(void* parg)
{
printf("ThreadMessageHandler started\n");
SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
while (!fShutdown)
{
vector<CNode*> vNodesCopy;
{
LOCK(cs_vNodes);
vNodesCopy = vNodes;
BOOST_FOREACH(CNode* pnode, vNodesCopy)
pnode->AddRef();
}
// Poll the connected nodes for messages
CNode* pnodeTrickle = NULL;
if (!vNodesCopy.empty())
pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
BOOST_FOREACH(CNode* pnode, vNodesCopy)
{
// Receive messages
{
TRY_LOCK(pnode->cs_vRecv, lockRecv);
if (lockRecv)
ProcessMessages(pnode);
}
if (fShutdown)
return;
// Send messages
{
TRY_LOCK(pnode->cs_vSend, lockSend);
if (lockSend)
SendMessages(pnode, pnode == pnodeTrickle);
}
if (fShutdown)
return;
}
{
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodesCopy)
pnode->Release();
}
// Wait and allow messages to bunch up.
// Reduce vnThreadsRunning so StopNode has permission to exit while
// we're sleeping, but we must always check fShutdown after doing this.
vnThreadsRunning[THREAD_MESSAGEHANDLER]--;
Sleep(100);
if (fRequestShutdown)
StartShutdown();
vnThreadsRunning[THREAD_MESSAGEHANDLER]++;
if (fShutdown)
return;
}
}
bool BindListenPort(const CService &addrBind, string& strError)
{
strError = "";
int nOne = 1;
#ifdef WIN32
// Initialize Windows Sockets
WSADATA wsadata;
int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
if (ret != NO_ERROR)
{
strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
printf("%s\n", strError.c_str());
return false;
}
#endif
// Create socket for listening for incoming connections
#ifdef USE_IPV6
struct sockaddr_storage sockaddr;
#else
struct sockaddr sockaddr;
#endif
socklen_t len = sizeof(sockaddr);
if (!addrBind.GetSockAddr((struct sockaddr*)&sockaddr, &len))
{
strError = strprintf("Error: bind address family for %s not supported", addrBind.ToString().c_str());
printf("%s\n", strError.c_str());
return false;
}
SOCKET hListenSocket = socket(((struct sockaddr*)&sockaddr)->sa_family, SOCK_STREAM, IPPROTO_TCP);
if (hListenSocket == INVALID_SOCKET)
{
strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
printf("%s\n", strError.c_str());
return false;
}
#ifdef SO_NOSIGPIPE
// Different way of disabling SIGPIPE on BSD
setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
#endif
#ifndef WIN32
// Allow binding if the port is still in TIME_WAIT state after
// the program was closed and restarted. Not an issue on windows.
setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
#endif
#ifdef WIN32
// Set to nonblocking, incoming connections will also inherit this
if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
#else
if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
#endif
{
strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
printf("%s\n", strError.c_str());
return false;
}
#ifdef USE_IPV6
// some systems don't have IPV6_V6ONLY but are always v6only; others do have the option
// and enable it by default or not. Try to enable it, if possible.
if (addrBind.IsIPv6()) {
#ifdef IPV6_V6ONLY
setsockopt(hListenSocket, IPPROTO_IPV6, IPV6_V6ONLY, (void*)&nOne, sizeof(int));
#endif
#ifdef WIN32
int nProtLevel = 10 /* PROTECTION_LEVEL_UNRESTRICTED */;
int nParameterId = 23 /* IPV6_PROTECTION_LEVEl */;
// this call is allowed to fail
setsockopt(hListenSocket, IPPROTO_IPV6, nParameterId, (const char*)&nProtLevel, sizeof(int));
#endif
}
#endif
if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, len) == SOCKET_ERROR)
{
int nErr = WSAGetLastError();
if (nErr == WSAEADDRINUSE)
strError = strprintf(_("Unable to bind to %s on this computer. TrollCoin is probably already running."), addrBind.ToString().c_str());
else
strError = strprintf(_("Unable to bind to %s on this computer (bind returned error %d, %s)"), addrBind.ToString().c_str(), nErr, strerror(nErr));
printf("%s\n", strError.c_str());
return false;
}
printf("Bound to %s\n", addrBind.ToString().c_str());
// Listen for incoming connections
if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
{
strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
printf("%s\n", strError.c_str());
return false;
}
vhListenSocket.push_back(hListenSocket);
if (addrBind.IsRoutable() && fDiscover)
AddLocal(addrBind, LOCAL_BIND);
return true;
}
void static Discover()
{
if (!fDiscover)
return;
#ifdef WIN32
// Get local host ip
char pszHostName[1000] = "";
if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
{
vector<CNetAddr> vaddr;
if (LookupHost(pszHostName, vaddr))
{
BOOST_FOREACH (const CNetAddr &addr, vaddr)
{
AddLocal(addr, LOCAL_IF);
}
}
}
#else
// Get local host ip
struct ifaddrs* myaddrs;
if (getifaddrs(&myaddrs) == 0)
{
for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
{
if (ifa->ifa_addr == NULL) continue;
if ((ifa->ifa_flags & IFF_UP) == 0) continue;
if (strcmp(ifa->ifa_name, "lo") == 0) continue;
if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
if (ifa->ifa_addr->sa_family == AF_INET)
{
struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
CNetAddr addr(s4->sin_addr);
if (AddLocal(addr, LOCAL_IF))
printf("IPv4 %s: %s\n", ifa->ifa_name, addr.ToString().c_str());
}
#ifdef USE_IPV6
else if (ifa->ifa_addr->sa_family == AF_INET6)
{
struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
CNetAddr addr(s6->sin6_addr);
if (AddLocal(addr, LOCAL_IF))
printf("IPv6 %s: %s\n", ifa->ifa_name, addr.ToString().c_str());
}
#endif
}
freeifaddrs(myaddrs);
}
#endif
CreateThread(ThreadGetMyExternalIP, NULL);
}
void StartNode(void* parg)
{
// Make this thread recognisable as the startup thread
RenameThread("bitcoin-start");
if (semOutbound == NULL) {
// initialize semaphore
int nMaxOutbound = min(MAX_OUTBOUND_CONNECTIONS, (int)GetArg("-maxconnections", 125));
semOutbound = new CSemaphore(nMaxOutbound);
}
if (pnodeLocalHost == NULL)
pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress(CService("127.0.0.1", 0), nLocalServices));
Discover();
//
// Start threads
//
if (!GetBoolArg("-dnsseed", true))
printf("DNS seeding disabled\n");
else
if (!CreateThread(ThreadDNSAddressSeed, NULL))
printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
// Map ports with UPnP
if (fUseUPnP)
MapPort();
// Get addresses from IRC and advertise ours
if (!CreateThread(ThreadIRCSeed, NULL))
printf("Error: CreateThread(ThreadIRCSeed) failed\n");
// Send and receive from sockets, accept connections
if (!CreateThread(ThreadSocketHandler, NULL))
printf("Error: CreateThread(ThreadSocketHandler) failed\n");
// Initiate outbound connections from -addnode
if (!CreateThread(ThreadOpenAddedConnections, NULL))
printf("Error: CreateThread(ThreadOpenAddedConnections) failed\n");
// Initiate outbound connections
if (!CreateThread(ThreadOpenConnections, NULL))
printf("Error: CreateThread(ThreadOpenConnections) failed\n");
// Process messages
if (!CreateThread(ThreadMessageHandler, NULL))
printf("Error: CreateThread(ThreadMessageHandler) failed\n");
// Dump network addresses
if (!CreateThread(ThreadDumpAddress, NULL))
printf("Error; CreateThread(ThreadDumpAddress) failed\n");
// Generate coins in the background
GenerateBitcoins(GetBoolArg("-gen", false), pwalletMain);
}
bool StopNode()
{
printf("StopNode()\n");
fShutdown = true;
nTransactionsUpdated++;
int64 nStart = GetTime();
if (semOutbound)
for (int i=0; i<MAX_OUTBOUND_CONNECTIONS; i++)
semOutbound->post();
do
{
int nThreadsRunning = 0;
for (int n = 0; n < THREAD_MAX; n++)
nThreadsRunning += vnThreadsRunning[n];
if (nThreadsRunning == 0)
break;
if (GetTime() - nStart > 20)
break;
Sleep(20);
} while(true);
if (vnThreadsRunning[THREAD_SOCKETHANDLER] > 0) printf("ThreadSocketHandler still running\n");
if (vnThreadsRunning[THREAD_OPENCONNECTIONS] > 0) printf("ThreadOpenConnections still running\n");
if (vnThreadsRunning[THREAD_MESSAGEHANDLER] > 0) printf("ThreadMessageHandler still running\n");
if (vnThreadsRunning[THREAD_MINER] > 0) printf("ThreadBitcoinMiner still running\n");
if (vnThreadsRunning[THREAD_RPCLISTENER] > 0) printf("ThreadRPCListener still running\n");
if (vnThreadsRunning[THREAD_RPCHANDLER] > 0) printf("ThreadsRPCServer still running\n");
#ifdef USE_UPNP
if (vnThreadsRunning[THREAD_UPNP] > 0) printf("ThreadMapPort still running\n");
#endif
if (vnThreadsRunning[THREAD_DNSSEED] > 0) printf("ThreadDNSAddressSeed still running\n");
if (vnThreadsRunning[THREAD_ADDEDCONNECTIONS] > 0) printf("ThreadOpenAddedConnections still running\n");
if (vnThreadsRunning[THREAD_DUMPADDRESS] > 0) printf("ThreadDumpAddresses still running\n");
while (vnThreadsRunning[THREAD_MESSAGEHANDLER] > 0 || vnThreadsRunning[THREAD_RPCHANDLER] > 0)
Sleep(20);
Sleep(50);
DumpAddresses();
return true;
}
class CNetCleanup
{
public:
CNetCleanup()
{
}
~CNetCleanup()
{
// Close sockets
BOOST_FOREACH(CNode* pnode, vNodes)
if (pnode->hSocket != INVALID_SOCKET)
closesocket(pnode->hSocket);
BOOST_FOREACH(SOCKET hListenSocket, vhListenSocket)
if (hListenSocket != INVALID_SOCKET)
if (closesocket(hListenSocket) == SOCKET_ERROR)
printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
#ifdef WIN32
// Shutdown Windows Sockets
WSACleanup();
#endif
}
}
instance_of_cnetcleanup;
|
[
"root@cpool1.cryptminer.net"
] |
root@cpool1.cryptminer.net
|
0e8beb278e20fd039d086c26690bd9df2129c196
|
01258c31195cf7525657e74c036482eec74d67e4
|
/ๅญๆธธๆ/็พไบบ็บขไน/ๆบๅจไบบๆๅก/AndroidUserItemSink.cpp
|
d375cd5935aee678d09fa1488a0c10736c0f0ce7
|
[] |
no_license
|
zhaozw/Server-1
|
cb418a8a78fa9795fdc12335de6549eeb751ec17
|
ccdd65090a07f994b10a2dc10b8eff2b4068fd7d
|
refs/heads/master
| 2020-04-03T22:11:00.436246
| 2018-12-09T08:44:55
| 2018-12-09T08:44:55
| 155,592,667
| 0
| 0
| null | 2018-10-31T16:51:17
| 2018-10-31T16:51:16
| null |
GB18030
|
C++
| false
| false
| 23,497
|
cpp
|
#include "Stdafx.h"
#include "AndroidUserItemSink.h"
#include "math.h"
//////////////////////////////////////////////////////////////////////////
//ๆถ้ดๆ ่ฏ
#define IDI_BANK_OPERATE 3 //้ถ่กๅฎๆถ
#define IDI_PLACE_JETTON1 103 //ไธๆณจๅฎๆถ
#define IDI_PLACE_JETTON2 104 //ไธๆณจๅฎๆถ
#define IDI_PLACE_JETTON3 105 //ไธๆณจๅฎๆถ
#define IDI_PLACE_JETTON4 106 //ไธๆณจๅฎๆถ
#define IDI_PLACE_JETTON5 107 //ไธๆณจๅฎๆถ
#define IDI_CHECK_BANKER 108 //ๆฃๆฅไธๅบ
#define IDI_REQUEST_BANKER 101 //็ณ่ฏทๅฎๆถ
#define IDI_GIVEUP_BANKER 102 //ไธๅบๅฎๆถ
#define IDI_PLACE_JETTON 110 //ไธๆณจๅฎไน (้ข็110-160)
//////////////////////////////////////////////////////////////////////////
int CAndroidUserItemSink::m_stlApplyBanker = 0L;
int CAndroidUserItemSink::m_stnApplyCount = 0L;
//ๆ้ ๅฝๆฐ
CAndroidUserItemSink::CAndroidUserItemSink()
{
//ๆธธๆๅ้
m_lMaxChipBanker = 0;
m_lMaxChipUser = 0;
m_wCurrentBanker = 0;
m_nChipTime = 0;
m_nChipTimeCount = 0;
m_cbTimeLeave = 0;
ZeroMemory(m_lAreaChip, sizeof(m_lAreaChip));
ZeroMemory(m_nChipLimit, sizeof(m_nChipLimit));
//ไธๅบๅ้
m_bMeApplyBanker=false;
m_nWaitBanker=0;
m_nBankerCount=0;
m_nListUserCount=0;
m_bReduceJettonLimit = false;
//ไธๅบๆฐ้
m_nRobotListMaxCount = 5;
m_nRobotListMinCount = 2;
srand((unsigned)time(NULL));
return;
}
//ๆๆๅฝๆฐ
CAndroidUserItemSink::~CAndroidUserItemSink()
{
}
//ๆฅๅฃๆฅ่ฏข
VOID * CAndroidUserItemSink::QueryInterface(REFGUID Guid, DWORD dwQueryVer)
{
QUERYINTERFACE(IAndroidUserItemSink,Guid,dwQueryVer);
QUERYINTERFACE_IUNKNOWNEX(IAndroidUserItemSink,Guid,dwQueryVer);
return NULL;
}
//ๅๅงๆฅๅฃ
bool CAndroidUserItemSink::Initialization(IUnknownEx * pIUnknownEx)
{
//ๆฅ่ฏขๆฅๅฃ
ASSERT(QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,IAndroidUserItem)!=NULL);
m_pIAndroidUserItem=QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx,IAndroidUserItem);
//้่ฏฏๅคๆญ
if(m_pIAndroidUserItem==NULL)
{
ASSERT(FALSE);
return false;
}
return true;
}
//้็ฝฎๆฅๅฃ
bool CAndroidUserItemSink::RepositionSink()
{
//ๆธธๆๅ้
m_lMaxChipBanker = 0;
m_lMaxChipUser = 0;
m_wCurrentBanker = 0;
m_nChipTime = 0;
m_nChipTimeCount = 0;
m_cbTimeLeave = 0;
ZeroMemory(m_lAreaChip, sizeof(m_lAreaChip));
ZeroMemory(m_nChipLimit, sizeof(m_nChipLimit));
//ไธๅบๅ้
m_bMeApplyBanker=false;
m_nWaitBanker=0;
m_nBankerCount=0;
return true;
}
//ๆถ้ดๆถๆฏ
bool CAndroidUserItemSink::OnEventTimer(UINT nTimerID)
{
switch(nTimerID)
{
case IDI_CHECK_BANKER: //ๆฃๆฅไธๅบ
{
m_pIAndroidUserItem->KillGameTimer(nTimerID);
if(m_wCurrentBanker == m_pIAndroidUserItem->GetChairID())
{
return false;
}
int nMinCount = m_nRobotListMaxCount;
if(m_nRobotListMaxCount > m_nRobotListMinCount)
{
nMinCount = (rand()%(m_nRobotListMaxCount - m_nRobotListMinCount+1)) + m_nRobotListMinCount;
}
//็ฉบๅบ
m_nWaitBanker++;
//ๆบๅจไบบไธๅบ
if(m_bRobotBanker
&& !m_bMeApplyBanker
&& m_nWaitBanker >= m_nRobotWaitBanker
&& m_nListUserCount < m_nRobotListMaxCount
&& m_stlApplyBanker < m_nRobotListMaxCount
&& m_stlApplyBanker < nMinCount
&& m_stnApplyCount < 2)
{
m_nWaitBanker = 0;
//ๅๆณๅคๆญ
IServerUserItem *pIUserItemBanker = m_pIAndroidUserItem->GetMeUserItem();
if(pIUserItemBanker->GetUserScore() > m_lBankerCondition)
{
//ๆบๅจไบบไธๅบ
m_nBankerCount = 0;
m_stlApplyBanker++;
m_stnApplyCount++;
m_pIAndroidUserItem->SetGameTimer(IDI_REQUEST_BANKER, (rand() % m_cbTimeLeave) + 1);
}
else
{
//ๆง่กๅๆฌพ
SCORE lDiffScore = (m_lRobotBankGetScoreBankerMax-m_lRobotBankGetScoreBankerMin)/100;
SCORE lScore = m_lRobotBankGetScoreBankerMin + (m_pIAndroidUserItem->GetUserID()%10)*(rand()%10)*lDiffScore +
(rand()%10+1)*(rand()%(lDiffScore/10));
if(lScore > 0)
{
m_pIAndroidUserItem->PerformTakeScore(lScore);
}
IServerUserItem *pIUserItemBanker = m_pIAndroidUserItem->GetMeUserItem();
if(pIUserItemBanker->GetUserScore() > m_lBankerCondition)
{
//ๆบๅจไบบไธๅบ
m_nBankerCount = 0;
m_stlApplyBanker++;
m_pIAndroidUserItem->SetGameTimer(IDI_REQUEST_BANKER, (rand() % m_cbTimeLeave) + 1);
}
}
}
return false;
}
case IDI_REQUEST_BANKER: //็ณ่ฏทไธๅบ
{
m_pIAndroidUserItem->KillGameTimer(nTimerID);
m_pIAndroidUserItem->SendSocketData(SUB_C_APPLY_BANKER);
return false;
}
case IDI_GIVEUP_BANKER: //็ณ่ฏทไธๅบ
{
m_pIAndroidUserItem->KillGameTimer(nTimerID);
m_pIAndroidUserItem->SendSocketData(SUB_C_CANCEL_BANKER);
return false;
}
case IDI_BANK_OPERATE: //้ถ่กๆไฝ
{
m_pIAndroidUserItem->KillGameTimer(nTimerID);
//ๅ้ๅฎไน
IServerUserItem *pUserItem = m_pIAndroidUserItem->GetMeUserItem();
LONGLONG lRobotScore = pUserItem->GetUserScore();
{
//ๅคๆญๅญๅ
if(lRobotScore > m_lRobotScoreRange[1])
{
LONGLONG lSaveScore=0L;
lSaveScore = LONGLONG(lRobotScore*m_nRobotBankStorageMul/100);
if(lSaveScore > lRobotScore)
{
lSaveScore = lRobotScore;
}
if(lSaveScore > 0 && m_wCurrentBanker != m_pIAndroidUserItem->GetChairID())
{
m_pIAndroidUserItem->PerformSaveScore(lSaveScore);
}
}
else if(lRobotScore < m_lRobotScoreRange[0])
{
SCORE lDiffScore = (m_lRobotBankGetScoreMax-m_lRobotBankGetScoreMin)/100;
SCORE lScore = m_lRobotBankGetScoreMin + (m_pIAndroidUserItem->GetUserID()%10)*(rand()%10)*lDiffScore +
(rand()%10+1)*(rand()%(lDiffScore/10));
if(lScore > 0)
{
m_pIAndroidUserItem->PerformTakeScore(lScore);
}
}
}
return false;
}
default:
{
if(nTimerID >= IDI_PLACE_JETTON && nTimerID <= IDI_PLACE_JETTON+MAX_CHIP_TIME)
{
//srand(GetTickCount());
//ๅ้ๅฎไน
int nRandNum = 0, nChipArea = 0, nCurChip = 0, nACTotal = 0, nCurJetLmt[2] = {};
LONGLONG lMaxChipLmt = __min(m_lMaxChipBanker, m_lMaxChipUser); //ๆๅคงๅฏไธๆณจๅผ
WORD wMyID = m_pIAndroidUserItem->GetChairID();
for(int i = 0; i < AREA_COUNT; i++)
{
nACTotal += m_RobotInfo.nAreaChance[i];
}
//็ป่ฎกๆฌกๆฐ
m_nChipTimeCount++;
//ๆฃๆต้ๅบ
if(lMaxChipLmt < m_RobotInfo.nChip[m_nChipLimit[0]])
{
return false;
}
for(int i = 0; i < AREA_COUNT; i++)
{
if(m_lAreaChip[i] >= m_RobotInfo.nChip[m_nChipLimit[0]])
{
break;
}
if(i == AREA_COUNT-1)
{
return false;
}
}
//ไธๆณจๅบๅ
ASSERT(nACTotal>0);
static int nStFluc = 1; //้ๆบ่พ
ๅฉ
if(nACTotal <= 0)
{
return false;
}
do
{
nRandNum = (rand()+wMyID+nStFluc*3) % nACTotal;
for(int i = 0; i < AREA_COUNT; i++)
{
nRandNum -= m_RobotInfo.nAreaChance[i];
if(nRandNum < 0)
{
nChipArea = i;
break;
}
}
}
while(m_lAreaChip[nChipArea] < m_RobotInfo.nChip[m_nChipLimit[0]]);
nStFluc = nStFluc%3 + 1;
//ไธๆณจๅคงๅฐ
if(m_nChipLimit[0] == m_nChipLimit[1])
{
nCurChip = m_nChipLimit[0];
}
else
{
//่ฎพ็ฝฎๅ้
lMaxChipLmt = __min(lMaxChipLmt, m_lAreaChip[nChipArea]);
nCurJetLmt[0] = m_nChipLimit[0];
nCurJetLmt[1] = m_nChipLimit[0];
//่ฎก็ฎๅฝๅๆๅคง็ญน็
for(int i = m_nChipLimit[1]; i > m_nChipLimit[0]; i--)
{
if(lMaxChipLmt > m_RobotInfo.nChip[i])
{
nCurJetLmt[1] = i;
break;
}
}
//้ๆบไธๆณจ
nRandNum = (rand()+wMyID) % (nCurJetLmt[1]-nCurJetLmt[0]+1);
nCurChip = nCurJetLmt[0] + nRandNum;
//ๅคไธๆงๅถ (ๅฝๅบๅฎถ้ๅธ่พๅฐๆถไผๅฐฝ้ไฟ่ฏไธ่ถณๆฌกๆฐ)
if(m_nChipTimeCount < m_nChipTime)
{
LONGLONG lLeftJetton = LONGLONG((lMaxChipLmt-m_RobotInfo.nChip[nCurChip])/(m_nChipTime-m_nChipTimeCount));
//ไธๅคๆฌกๆฐ (ๅณๅ
จ็จๆๅฐ้ๅถ็ญน็ ไธๆณจไนๅฐไบ)
if(lLeftJetton < m_RobotInfo.nChip[m_nChipLimit[0]] && nCurChip > m_nChipLimit[0])
{
nCurChip--;
}
}
}
//ๅ้ๅฎไน
CMD_C_PlaceJetton PlaceJetton = {};
//ๆ้ ๅ้
PlaceJetton.cbJettonArea = nChipArea+1; //ๅบๅๅฎไป1ๅผๅง
PlaceJetton.lJettonScore = m_RobotInfo.nChip[nCurChip];
//ๅ้ๆถๆฏ
m_pIAndroidUserItem->SendSocketData(SUB_C_PLACE_JETTON, &PlaceJetton, sizeof(PlaceJetton));
}
m_pIAndroidUserItem->KillGameTimer(nTimerID);
return false;
}
}
return false;
}
//ๆธธๆๆถๆฏ
bool CAndroidUserItemSink::OnEventGameMessage(WORD wSubCmdID, VOID * pBuffer, WORD wDataSize)
{
switch(wSubCmdID)
{
case SUB_S_GAME_FREE: //ๆธธๆ็ฉบ้ฒ
{
return OnSubGameFree(pBuffer, wDataSize);
}
case SUB_S_GAME_START: //ๆธธๆๅผๅง
{
return OnSubGameStart(pBuffer, wDataSize);
}
case SUB_S_PLACE_JETTON: //็จๆทๅ ๆณจ
{
return OnSubPlaceJetton(pBuffer, wDataSize);
}
case SUB_S_APPLY_BANKER: //็ณ่ฏทๅๅบ
{
return OnSubUserApplyBanker(pBuffer,wDataSize);
}
case SUB_S_CANCEL_BANKER: //ๅๆถๅๅบ
{
return OnSubUserCancelBanker(pBuffer,wDataSize);
}
case SUB_S_CHANGE_BANKER: //ๅๆขๅบๅฎถ
{
return OnSubChangeBanker(pBuffer,wDataSize);
}
case SUB_S_GAME_END: //ๆธธๆ็ปๆ
{
return OnSubGameEnd(pBuffer, wDataSize);
}
case SUB_S_SEND_RECORD: //ๆธธๆ่ฎฐๅฝ (ๅฟฝ็ฅ)
{
return true;
}
case SUB_S_PLACE_JETTON_FAIL: //ไธๆณจๅคฑ่ดฅ (ๅฟฝ็ฅ)
{
return true;
}
}
//้่ฏฏๆญ่จ
ASSERT(FALSE);
return true;
}
//ๆธธๆๆถๆฏ
bool CAndroidUserItemSink::OnEventFrameMessage(WORD wSubCmdID, VOID * pData, WORD wDataSize)
{
return true;
}
//ๅบๆฏๆถๆฏ
bool CAndroidUserItemSink::OnEventSceneMessage(BYTE cbGameStatus, bool bLookonOther, VOID * pData, WORD wDataSize)
{
switch(cbGameStatus)
{
case GAME_SCENE_FREE: //็ฉบ้ฒ็ถๆ
{
//ๆ้ชๆฐๆฎ
ASSERT(wDataSize==sizeof(CMD_S_StatusFree));
if(wDataSize!=sizeof(CMD_S_StatusFree))
{
return false;
}
//ๆถๆฏๅค็
CMD_S_StatusFree * pStatusFree=(CMD_S_StatusFree *)pData;
m_lUserLimitScore = pStatusFree->lUserMaxScore;
m_lAreaLimitScore = pStatusFree->lAreaLimitScore;
m_lBankerCondition = pStatusFree->lApplyBankerCondition;
memcpy(m_szRoomName, pStatusFree->szGameRoomName, sizeof(m_szRoomName));
ReadConfigInformation(&pStatusFree->CustomAndroid);
//ไธๅบๅค็
if(pStatusFree->wBankerUser == INVALID_CHAIR)
{
if(m_bRobotBanker && m_nRobotWaitBanker == 0 && m_stlApplyBanker < m_nRobotApplyBanker)
{
//ๅๆณๅคๆญ
IServerUserItem *pIUserItemBanker = m_pIAndroidUserItem->GetMeUserItem();
if(pIUserItemBanker->GetUserScore() > m_lBankerCondition)
{
//ๆบๅจไบบไธๅบ
m_nBankerCount = 0;
m_stlApplyBanker++;
BYTE cbTime = (pStatusFree->cbTimeLeave>0?(rand()%pStatusFree->cbTimeLeave+1):2);
if(cbTime == 0)
{
cbTime = 2;
}
m_pIAndroidUserItem->SetGameTimer(IDI_REQUEST_BANKER, cbTime);
}
}
}
return true;
}
case GS_PLACE_JETTON: //ๆธธๆ็ถๆ
case GS_GAME_END: //็ปๆ็ถๆ
{
//ๆ้ชๆฐๆฎ
ASSERT(wDataSize==sizeof(CMD_S_StatusPlay));
if(wDataSize!=sizeof(CMD_S_StatusPlay))
{
return false;
}
//ๆถๆฏๅค็
CMD_S_StatusPlay * pStatusPlay=(CMD_S_StatusPlay *)pData;
//ๅบๅฎถไฟกๆฏ
m_wCurrentBanker = pStatusPlay->wBankerUser;
m_lUserLimitScore = pStatusPlay->lUserMaxScore;
m_lAreaLimitScore = pStatusPlay->lAreaLimitScore;
m_lBankerCondition = pStatusPlay->lApplyBankerCondition;
memcpy(m_szRoomName, pStatusPlay->szGameRoomName, sizeof(m_szRoomName));
ReadConfigInformation(&pStatusPlay->CustomAndroid);
return true;
}
}
return true;
}
//็จๆท่ฟๅ
ฅ
void CAndroidUserItemSink::OnEventUserEnter(IAndroidUserItem * pIAndroidUserItem, bool bLookonUser)
{
return;
}
//็จๆท็ฆปๅผ
void CAndroidUserItemSink::OnEventUserLeave(IAndroidUserItem * pIAndroidUserItem, bool bLookonUser)
{
return;
}
//็จๆท็งฏๅ
void CAndroidUserItemSink::OnEventUserScore(IAndroidUserItem * pIAndroidUserItem, bool bLookonUser)
{
return;
}
//็จๆท็ถๆ
void CAndroidUserItemSink::OnEventUserStatus(IAndroidUserItem * pIAndroidUserItem, bool bLookonUser)
{
return;
}
//ๆธธๆ็ฉบ้ฒ
bool CAndroidUserItemSink::OnSubGameFree(const void * pBuffer, WORD wDataSize)
{
//ๆถๆฏๅค็
CMD_S_GameFree* pGameFree=(CMD_S_GameFree *)pBuffer;
m_cbTimeLeave = pGameFree->cbTimeLeave;
m_nListUserCount = pGameFree->nListUserCount;
//้ถ่กๆไฝ
if(pGameFree->cbTimeLeave > 1)
{
m_pIAndroidUserItem->SetGameTimer(IDI_BANK_OPERATE, (rand() % (pGameFree->cbTimeLeave-1)) + 1);
}
bool bMeGiveUp = false;
if(m_wCurrentBanker == m_pIAndroidUserItem->GetChairID())
{
m_nBankerCount++;
if(m_nBankerCount >= m_nRobotBankerCount)
{
//ๆบๅจไบบ่ตฐๅบ
m_nBankerCount = 0;
m_pIAndroidUserItem->SetGameTimer(IDI_GIVEUP_BANKER, rand()%2 + 1);
bMeGiveUp = true;
}
}
//ๆฃๆฅไธๅบ
//if (m_wCurrentBanker != m_pIAndroidUserItem->GetChairID() || bMeGiveUp)
{
m_cbTimeLeave = pGameFree->cbTimeLeave - 3;
m_pIAndroidUserItem->SetGameTimer(IDI_CHECK_BANKER, 3);
}
return true;
}
//ๆธธๆๅผๅง
bool CAndroidUserItemSink::OnSubGameStart(const void * pBuffer, WORD wDataSize)
{
//ๆ้ชๆฐๆฎ
ASSERT(wDataSize==sizeof(CMD_S_GameStart));
if(wDataSize!=sizeof(CMD_S_GameStart))
{
return false;
}
//ๆถๆฏๅค็
CMD_S_GameStart * pGameStart=(CMD_S_GameStart *)pBuffer;
srand(GetTickCount());
//่ชๅทฑๅฝๅบๆๆ ไธๆณจๆบๅจไบบ
if(pGameStart->wBankerUser == m_pIAndroidUserItem->GetChairID() || pGameStart->nChipRobotCount <= 0)
{
return true;
}
//่ฎพ็ฝฎๅ้
m_lMaxChipBanker = pGameStart->lBankerScore/m_RobotInfo.nMaxTime;
m_lMaxChipUser = pGameStart->lUserMaxScore/m_RobotInfo.nMaxTime;
m_wCurrentBanker = pGameStart->wBankerUser;
m_nChipTimeCount = 0;
ZeroMemory(m_nChipLimit, sizeof(m_nChipLimit));
for(int i = 0; i < AREA_COUNT; i++)
{
m_lAreaChip[i] = m_lAreaLimitScore;
}
//็ณป็ปๅฝๅบ
if(pGameStart->wBankerUser == INVALID_CHAIR)
{
m_lMaxChipBanker = 2147483647/m_RobotInfo.nMaxTime;
}
else
{
m_lMaxChipUser = __min(m_lMaxChipUser, m_lMaxChipBanker);
}
if(pGameStart->nAndriodApplyCount > 0)
{
m_stlApplyBanker=pGameStart->nAndriodApplyCount;
}
else
{
m_stlApplyBanker=0;
}
//่ฎก็ฎไธๆณจๆฌกๆฐ
int nElapse = 0;
WORD wMyID = m_pIAndroidUserItem->GetChairID();
if(m_nRobotBetTimeLimit[0] == m_nRobotBetTimeLimit[1])
{
m_nChipTime = m_nRobotBetTimeLimit[0];
}
else
{
m_nChipTime = (rand()+wMyID)%(m_nRobotBetTimeLimit[1]-m_nRobotBetTimeLimit[0]+1) + m_nRobotBetTimeLimit[0];
}
ASSERT(m_nChipTime>=0);
if(m_nChipTime <= 0)
{
return false; //็็กฎ,2ไธช้ฝๅธฆ็ญไบ
}
if(m_nChipTime > MAX_CHIP_TIME)
{
m_nChipTime = MAX_CHIP_TIME; //้ๅฎMAX_CHIPๆฌกไธๆณจ
}
//่ฎก็ฎ่ๅด
if(!CalcJettonRange(__min(m_lMaxChipBanker, m_lMaxChipUser), m_lRobotJettonLimit, m_nChipTime, m_nChipLimit))
{
return true;
}
//่ฎพ็ฝฎๆถ้ด
int nTimeGrid = int(pGameStart->cbTimeLeave-2)*800/m_nChipTime; //ๆถ้ดๆ ผ,ๅ2็งไธไธๆณจ,ๆไปฅ-2,800่กจ็คบๆบๅจไบบไธๆณจๆถ้ด่ๅดๅๅๆฏ
for(int i = 0; i < m_nChipTime; i++)
{
int nRandRage = int(nTimeGrid * i / (1500*sqrt((double)m_nChipTime))) + 1; //ๆณขๅจ่ๅด
nElapse = 2 + (nTimeGrid*i)/1000 + ((rand()+wMyID)%(nRandRage*2) - (nRandRage-1));
ASSERT(nElapse>=2&&nElapse<=pGameStart->cbTimeLeave);
if(nElapse < 2 || nElapse > pGameStart->cbTimeLeave)
{
continue;
}
m_pIAndroidUserItem->SetGameTimer(IDI_PLACE_JETTON+i+1, nElapse);
}
return true;
}
//็จๆทๅ ๆณจ
bool CAndroidUserItemSink::OnSubPlaceJetton(const void * pBuffer, WORD wDataSize)
{
//ๆ้ชๆฐๆฎ
ASSERT(wDataSize==sizeof(CMD_S_PlaceJetton));
if(wDataSize!=sizeof(CMD_S_PlaceJetton))
{
return false;
}
//ๆถๆฏๅค็
CMD_S_PlaceJetton * pPlaceJetton=(CMD_S_PlaceJetton *)pBuffer;
//่ฎพ็ฝฎๅ้
//m_lMaxChipBanker -= pPlaceJetton->lJettonScore;
m_lAreaChip[pPlaceJetton->cbJettonArea-1] -= pPlaceJetton->lJettonScore;
if(pPlaceJetton->wChairID == m_pIAndroidUserItem->GetChairID())
{
m_lMaxChipUser -= pPlaceJetton->lJettonScore;
}
return true;
}
//ไธๆณจๅคฑ่ดฅ
bool CAndroidUserItemSink::OnSubPlaceJettonFail(const void * pBuffer, WORD wDataSize)
{
return true;
}
//ๆธธๆ็ปๆ
bool CAndroidUserItemSink::OnSubGameEnd(const void * pBuffer, WORD wDataSize)
{
//ๆ้ชๆฐๆฎ
ASSERT(wDataSize==sizeof(CMD_S_GameEnd));
if(wDataSize!=sizeof(CMD_S_GameEnd))
{
return false;
}
//ๆถๆฏๅค็
CMD_S_GameEnd * pGameEnd=(CMD_S_GameEnd *)pBuffer;
m_stnApplyCount = 0;
return true;
}
//็ณ่ฏทๅๅบ
bool CAndroidUserItemSink::OnSubUserApplyBanker(const void * pBuffer, WORD wDataSize)
{
//ๆ้ชๆฐๆฎ
ASSERT(wDataSize==sizeof(CMD_S_ApplyBanker));
if(wDataSize!=sizeof(CMD_S_ApplyBanker))
{
return false;
}
//ๆถๆฏๅค็
CMD_S_ApplyBanker * pApplyBanker=(CMD_S_ApplyBanker *)pBuffer;
//่ชๅทฑๅคๆญ
if(m_pIAndroidUserItem->GetChairID()==pApplyBanker->wApplyUser)
{
m_bMeApplyBanker=true;
}
return true;
}
//ๅๆถๅๅบ
bool CAndroidUserItemSink::OnSubUserCancelBanker(const void * pBuffer, WORD wDataSize)
{
//ๆ้ชๆฐๆฎ
ASSERT(wDataSize==sizeof(CMD_S_CancelBanker));
if(wDataSize!=sizeof(CMD_S_CancelBanker))
{
return false;
}
//ๆถๆฏๅค็
CMD_S_CancelBanker * pCancelBanker=(CMD_S_CancelBanker *)pBuffer;
//่ชๅทฑๅคๆญ
if(m_pIAndroidUserItem->GetChairID()==pCancelBanker->wCancelUser)
{
m_bMeApplyBanker=false;
}
return true;
}
//ๅๆขๅบๅฎถ
bool CAndroidUserItemSink::OnSubChangeBanker(const void * pBuffer, WORD wDataSize)
{
//ๆ้ชๆฐๆฎ
ASSERT(wDataSize==sizeof(CMD_S_ChangeBanker));
if(wDataSize!=sizeof(CMD_S_ChangeBanker))
{
return false;
}
//ๆถๆฏๅค็
CMD_S_ChangeBanker * pChangeBanker = (CMD_S_ChangeBanker *)pBuffer;
if(m_wCurrentBanker == m_pIAndroidUserItem->GetChairID() && m_wCurrentBanker != pChangeBanker->wBankerUser)
{
//m_stlApplyBanker--;
m_nWaitBanker = 0;
m_bMeApplyBanker = false;
}
m_wCurrentBanker = pChangeBanker->wBankerUser;
return true;
}
//่ฏปๅ้
็ฝฎ
void CAndroidUserItemSink::ReadConfigInformation(tagCustomAndroid *pCustomAndroid)
{
//ๆฌกๆฐ้ๅถ
m_nRobotBetTimeLimit[0] = pCustomAndroid->lRobotMinBetTime;
m_nRobotBetTimeLimit[1] = pCustomAndroid->lRobotMaxBetTime;
if(m_nRobotBetTimeLimit[0] < 0)
{
m_nRobotBetTimeLimit[0] = 0;
}
if(m_nRobotBetTimeLimit[1] < m_nRobotBetTimeLimit[0])
{
m_nRobotBetTimeLimit[1] = m_nRobotBetTimeLimit[0];
}
//็ญน็ ้ๅถ
m_lRobotJettonLimit[0] = pCustomAndroid->lRobotMinJetton;
m_lRobotJettonLimit[1] = pCustomAndroid->lRobotMaxJetton;
if(m_lRobotJettonLimit[1] > 5000000)
{
m_lRobotJettonLimit[1] = 5000000;
}
if(m_lRobotJettonLimit[0] < 100)
{
m_lRobotJettonLimit[0] = 100;
}
if(m_lRobotJettonLimit[1] < m_lRobotJettonLimit[0])
{
m_lRobotJettonLimit[1] = m_lRobotJettonLimit[0];
}
//ๆฏๅฆๅๅบ
m_bRobotBanker = (pCustomAndroid->nEnableRobotBanker == TRUE)?true:false;
//ๅๅบๆฌกๆฐ
LONGLONG lRobotBankerCountMin = pCustomAndroid->lRobotBankerCountMin;
LONGLONG lRobotBankerCountMax = pCustomAndroid->lRobotBankerCountMax;
m_nRobotBankerCount = rand()%(lRobotBankerCountMax-lRobotBankerCountMin+1) + lRobotBankerCountMin;
//ๅ่กจไบบๆฐ
m_nRobotListMinCount = pCustomAndroid->lRobotListMinCount;
m_nRobotListMaxCount = pCustomAndroid->lRobotListMaxCount;
//ๆๅคไธชๆฐ
m_nRobotApplyBanker = pCustomAndroid->lRobotApplyBanker;
//็ฉบ็้็ณ
m_nRobotWaitBanker = pCustomAndroid->lRobotWaitBanker;
//ๅๆฐ้ๅถ
m_lRobotScoreRange[0] = pCustomAndroid->lRobotScoreMin;
m_lRobotScoreRange[1] = pCustomAndroid->lRobotScoreMax;
if(m_lRobotScoreRange[1] < m_lRobotScoreRange[0])
{
m_lRobotScoreRange[1] = m_lRobotScoreRange[0];
}
//ๆๆฌพๆฐ้ข
m_lRobotBankGetScoreMin = pCustomAndroid->lRobotBankGetMin;
m_lRobotBankGetScoreMax = pCustomAndroid->lRobotBankGetMax;
//ๆๆฌพๆฐ้ข (ๅบๅฎถ)
m_lRobotBankGetScoreBankerMin = pCustomAndroid->lRobotBankGetBankerMin;
m_lRobotBankGetScoreBankerMax = pCustomAndroid->lRobotBankGetBankerMax;
//ๅญๆฌพๅๆฐ
m_nRobotBankStorageMul = pCustomAndroid->lRobotBankStoMul;
if(m_nRobotBankStorageMul<0 || m_nRobotBankStorageMul>100)
{
m_nRobotBankStorageMul = 20;
}
return;
}
//่ฎก็ฎ่ๅด (่ฟๅๅผ่กจ็คบๆฏๅฆๅฏไปฅ้่ฟไธ้ไธ้่พพๅฐไธๆณจ)
bool CAndroidUserItemSink::CalcJettonRange(LONGLONG lMaxScore, LONGLONG lChipLmt[], int & nChipTime, int lJetLmt[])
{
//ๅฎไนๅ้
bool bHaveSetMinChip = false;
//ไธๅคไธๆณจ
if(lMaxScore < m_RobotInfo.nChip[0])
{
return false;
}
//้
็ฝฎ่ๅด
for(int i = 0; i < CountArray(m_RobotInfo.nChip); i++)
{
if(!bHaveSetMinChip && m_RobotInfo.nChip[i] >= lChipLmt[0])
{
lJetLmt[0] = i;
bHaveSetMinChip = true;
}
if(m_RobotInfo.nChip[i] <= lChipLmt[1])
{
lJetLmt[1] = i;
}
}
if(lJetLmt[0] > lJetLmt[1])
{
lJetLmt[0] = lJetLmt[1];
}
//ๆฏๅฆ้ไฝไธ้
if(m_bReduceJettonLimit)
{
if(nChipTime * m_RobotInfo.nChip[lJetLmt[0]] > lMaxScore)
{
//ๆฏๅฆ้ไฝไธๆณจๆฌกๆฐ
if(nChipTime * m_RobotInfo.nChip[0] > lMaxScore)
{
nChipTime = int(lMaxScore/m_RobotInfo.nChip[0]);
lJetLmt[0] = 0;
lJetLmt[1] = 0;
}
else
{
//้ไฝๅฐๅ้ไธ้
while(nChipTime * m_RobotInfo.nChip[lJetLmt[0]] > lMaxScore)
{
lJetLmt[0]--;
ASSERT(lJetLmt[0]>=0);
}
}
}
}
return true;
}
//////////////////////////////////////////////////////////////////////////
//็ปไปถๅๅปบๅฝๆฐ
DECLARE_CREATE_MODULE(AndroidUserItemSink);
|
[
"wang274380874@126.com"
] |
wang274380874@126.com
|
9f5b7320f825ee900ec21bbae91c95813d385e6b
|
072dd83ffe14401dfc083e911d28daed1f74b489
|
/src/global.cpp
|
065f2122fe70c1bcfb8adfa679bbe51331a09823
|
[] |
no_license
|
osmium18452/co
|
a7871fcee8b72015cde0840dbafbe4c2d8d48096
|
a9d993d1fb47e69c8696000bb11f78e802ec8a42
|
refs/heads/master
| 2022-11-16T21:55:39.147095
| 2020-07-07T08:57:05
| 2020-07-07T08:57:05
| 262,258,060
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 62
|
cpp
|
#include "../headers/global.h"
#include "../headers/lex.h"
|
[
"1711042219@qq.com"
] |
1711042219@qq.com
|
1402d5e82ce860b92569eae9190e6b009a11294e
|
12ff8204ef7404153fa06cc4a74275fbc132d77d
|
/data_dependency.cpp
|
0993155ceace699b95eacfa879bc7cc5500da0d8
|
[] |
no_license
|
xiaowei0312/coal
|
cbb6aedc9ad72d9b7da5702f69cad29d53d1c20a
|
a8186396cfce5693b902f56988351fd55c43a1e6
|
refs/heads/master
| 2021-07-05T08:12:02.522388
| 2017-09-28T11:30:08
| 2017-09-28T11:30:08
| 105,141,476
| 0
| 0
| null | null | null | null |
GB18030
|
C++
| false
| false
| 5,098
|
cpp
|
#include "data_dependency.h"
#include <QStack>
#include <QDebug>
#include <QRegExpValidator>
#include <QMessageBox>
DataDependency::DataDependency()
{
error = 0;
}
bool DataDependency::textIsNotNumber(QString &text)
{
int pos = 0;
QRegExpValidator numReg(QRegExp("^([1-9]\\d{0,15}|0)(\\.\\d{1,4})?$"),this);
if(text.isNull() || text.trimmed().isEmpty()) //ไพ่ต้กนไธบ็ฉบ
return true;
if(numReg.validate(text,pos) != QValidator::Acceptable) //ไพ่ต้กนไธๆฏ็บฏๆฐๅญ๏ผๆ่
ๅฐๆฐ๏ผ
return true;
return false;
}
bool DataDependency::depHasEmptyElement()
{
QString text;
for(int i=0;i<depList_final.size();i++)
{
text = depList_final[i]->text();
if(textIsNotNumber(text))
return true;
}
return false;
}
void DataDependency::markEmptyDepElement()
{
// for(int i=0;i<depList.size();i++)
// {
// if(depList.value(i)->text().trimmed().isEmpty())
// {
// depList.value(i)->setStyleSheet("QLineEdit{border:1px solid green}");
// }
// }
for(int i=0;i<depList.size();i++)
{
depList.value(i)->setStyleSheet("QLineEdit{border:1px solid green}");
}
}
double DataDependency::__execFormula(char *szFormula)
{
QStack<double> stack1;
QStack<char> stack2;
int status = 0;
double dTmp = 0; //ๆฐๅญ
double tmp = 10; //ๅฐๆฐ่ฎก็ฎๅ ๅญ๏ผ10,100-->1000
int count = 0;
QString text;
char *szTmp;
//qDebug() << szFormula;
while(1){
char c = *szFormula++;
//qDebug() << c;
if(c>='0' && c<='9'){
if(status == 0){
dTmp = 0;
tmp = 10;
status = 1; //่ฎก็ฎๆฐๅญ
}
if(status == 1)
dTmp = dTmp * 10 + (c - '0');
else if(status == 2){
dTmp = dTmp + (c-'0')/tmp;
tmp *= 10;
}
}else if(c=='.'){
if(status == 1)
status = 2; //่ฎก็ฎๆฐๅญ(ๅฐๆฐ็นไนๅ)
else{
QMessageBox::critical(NULL,QString::fromLocal8Bit("ๅ
ฌๅผ้่ฏฏ"),
QString::fromLocal8Bit("ๅ
ฌๅผ้่ฏฏ๏ผๅบ็ฐไธๅฏ้ขๆ็ๅฐๆฐ็น"),QMessageBox::Ok);
exit(-1);
}
}else{
if(status != 0){ //ๆฐๅญๅค็ๅฎๆฏ
if(!stack2.empty()){
switch(stack2.top()){
case '-':
dTmp *= -1;
stack2.pop();
stack2.push('+');
break;
case '*':
dTmp *= stack1.pop();
stack2.pop();
break;
case '/':
if(dTmp == 0){
error = 1;
return -1;
}
dTmp = stack1.pop() / dTmp;
stack2.pop();
break;
}
}
stack1.push(dTmp);
status = 0;
}
if(c == 0)
break; //่ทณๅบๅพช็ฏ
switch(c){
case ' ':
continue;
case '+':
case '-':
case '*':
case '/':
stack2.push(c);
continue;
case 'n':
status = 2;
c = *szFormula++;
text = depList[c-'0'-1]->text();
if(textIsNotNumber(text)){
//qDebug() << QString("Text[") + text + "]is Not number.";
error = 1;
return -1;
}
dTmp = text.toDouble();
break;
case '(':
status = 2;
szTmp = szFormula;
count = 0;
while(*szTmp && count!=1){
char t = *szTmp++;
if(t == '(')
count--;
else if(t == ')')
count++;
}
*(--szTmp) = 0;
if((dTmp = __execFormula(szFormula))==-1){
if(error == 1){
return -1;
}
}
szFormula = szTmp + 1;
break;
default:
QMessageBox::critical(NULL,QString::fromLocal8Bit("ๅ
ฌๅผ้่ฏฏ"),
QString::fromLocal8Bit("ๅ
ฌๅผ้่ฏฏ๏ผๅบ็ฐไธๅฏ้ขๆๅญ็ฌฆ:") + szFormula ,QMessageBox::Ok);
exit(-1);
}
}
}
while(!stack2.empty())
{
stack1.push(stack1.pop() + stack1.pop());
stack2.pop();
}
return stack1.pop();
}
double DataDependency::execFormula()
{
error = 0;
QByteArray ba = formula.toLatin1();
char *szFormula = ba.data();
return __execFormula(szFormula);
}
|
[
"zezhao_wei@163.com"
] |
zezhao_wei@163.com
|
6fe24c66bcd7a4f2bf29bb7aa4594df9e91ebd2a
|
95957325cc5d1376e9ad1af1899795b92ab9fa1a
|
/PortableDeviceApi.dll/PortableDeviceApi.dll.cpp
|
d2b847c38f9cfe874c4bce7082e6974bb76da511
|
[] |
no_license
|
SwenenzY/win-system32-dlls
|
c09964aababe77d1ae01cd0a431d6fc168f6ec89
|
fb8e3a6cdf379cdef16e2a922e3fbab79c313281
|
refs/heads/main
| 2023-09-05T07:49:10.820162
| 2021-11-09T07:30:18
| 2021-11-09T07:30:18
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,617
|
cpp
|
๏ปฟ#include <windows.h>
#include <shlwapi.h>
extern "C" {
extern void *ptr_DllCanUnloadNow;
void *ptr_DllCanUnloadNow = NULL;
extern void *ptr_DllGetClassObject;
void *ptr_DllGetClassObject = NULL;
extern void *ptr_DllRegisterServer;
void *ptr_DllRegisterServer = NULL;
extern void *ptr_DllUnregisterServer;
void *ptr_DllUnregisterServer = NULL;
}
static HMODULE hModule = NULL;
static void module_init()
{
if (hModule) return;
wchar_t sz_module_file[MAX_PATH];
GetSystemDirectoryW(sz_module_file, MAX_PATH);
wcscat_s(sz_module_file, L"\\PortableDeviceApi.dll");
hModule = LoadLibraryW(sz_module_file);
if (!hModule) return;
#define __vartype(x) decltype(x)
ptr_DllCanUnloadNow = (__vartype(ptr_DllCanUnloadNow))GetProcAddress(hModule, "DllCanUnloadNow");
ptr_DllGetClassObject = (__vartype(ptr_DllGetClassObject))GetProcAddress(hModule, "DllGetClassObject");
ptr_DllRegisterServer = (__vartype(ptr_DllRegisterServer))GetProcAddress(hModule, "DllRegisterServer");
ptr_DllUnregisterServer = (__vartype(ptr_DllUnregisterServer))GetProcAddress(hModule, "DllUnregisterServer");
#undef __vartype
}
extern "C" BOOL __stdcall DllMain( HMODULE hModule, DWORD ul_reason_for_call,LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
module_init();
wchar_t tmp1[2048];
GetModuleFileNameW(NULL, tmp1, _countof(tmp1));
PathRemoveExtensionW(tmp1);
wcscat(tmp1, L".hook.dll");
LoadLibraryW(tmp1);
break;
}
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
|
[
"udf.q@qq.com"
] |
udf.q@qq.com
|
6bf8e2bec6f14e1f1cc28d32af0e19d5606c834a
|
2c17c289d795c570491022960154b19505b27f27
|
/gquiche/quic/core/frames/quic_ack_frequency_frame.h
|
642d83c167250903240103d8faeaa63da3b4a731
|
[
"Apache-2.0",
"BSD-3-Clause"
] |
permissive
|
leeyangjie/quiche
|
4cb2849ce2474ec14c902683d25e9287b95a7078
|
2870175069d90bcb837f30170f4eff97e161805d
|
refs/heads/main
| 2022-06-18T17:05:13.066915
| 2022-04-13T07:14:13
| 2022-04-13T07:14:13
| 433,855,510
| 0
| 0
|
Apache-2.0
| 2021-12-01T14:17:22
| 2021-12-01T14:17:21
| null |
UTF-8
|
C++
| false
| false
| 1,873
|
h
|
// Copyright (c) 2020 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 QUICHE_QUIC_CORE_FRAMES_QUIC_ACK_FREQUENCY_FRAME_H_
#define QUICHE_QUIC_CORE_FRAMES_QUIC_ACK_FREQUENCY_FRAME_H_
#include <cstdint>
#include <ostream>
#include "gquiche/quic/core/quic_constants.h"
#include "gquiche/quic/core/quic_time.h"
#include "gquiche/quic/core/quic_types.h"
#include "gquiche/quic/platform/api/quic_export.h"
namespace quic {
// A frame that allows sender control of acknowledgement delays.
struct QUIC_EXPORT_PRIVATE QuicAckFrequencyFrame {
friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
std::ostream& os,
const QuicAckFrequencyFrame& ack_frequency_frame);
QuicAckFrequencyFrame() = default;
QuicAckFrequencyFrame(QuicControlFrameId control_frame_id,
uint64_t sequence_number,
uint64_t packet_tolerance,
QuicTime::Delta max_ack_delay);
// A unique identifier of this control frame. 0 when this frame is
// received, and non-zero when sent.
QuicControlFrameId control_frame_id = kInvalidControlFrameId;
// If true, do not ack immediately upon observeation of packet reordering.
bool ignore_order = false;
// Sequence number assigned to the ACK_FREQUENCY frame by the sender to allow
// receivers to ignore obsolete frames.
uint64_t sequence_number = 0;
// The maximum number of ack-eliciting packets after which the receiver sends
// an acknowledgement. Invald if == 0.
uint64_t packet_tolerance = 2;
// The maximum time that ack packets can be delayed.
QuicTime::Delta max_ack_delay =
QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
};
} // namespace quic
#endif // QUICHE_QUIC_CORE_FRAMES_QUIC_ACK_FREQUENCY_FRAME_H_
|
[
"wangsheng@bilibili.com"
] |
wangsheng@bilibili.com
|
fddfcb0cc00f83e2f716fd99acc653302dde01d1
|
e1b45b711e4b083f3a004a8c169979de676e5d41
|
/demo-menu/mainwindow.cpp
|
9ca277b797fa8629b0480776408ef3002311c6c6
|
[
"MIT"
] |
permissive
|
wangchunlin5013/menu-manager
|
b3b76a582355d271aa34bc65d9bb3574e85d3705
|
1c0487e3d84d1977239698800b233354cbe43810
|
refs/heads/main
| 2023-03-13T23:35:04.148444
| 2021-03-05T13:20:36
| 2021-03-05T13:20:36
| 342,234,851
| 0
| 0
|
MIT
| 2021-03-05T13:20:37
| 2021-02-25T12:18:55
|
C++
|
UTF-8
|
C++
| false
| false
| 4,050
|
cpp
|
/*
* Copyright (C) 2019 ~ 2019 Deepin Technology Co., Ltd.
*
* Author: wangcl <wangchunlin@uniontech.com>
*
* Maintainer: wangcl <wangchunlin@uniontech.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "mainwindow.h"
#include "mainwindow_p.h"
#include <QMenu>
#include <QStandardPaths>
#include <QDebug>
#include <QFileInfo>
#include <QFile>
#include <QSettings>
MainWindowPrivate::MainWindowPrivate()
{
}
MainWindowPrivate::~MainWindowPrivate()
{
}
void MainWindowPrivate::init()
{
configPath = QStandardPaths::standardLocations(QStandardPaths::ConfigLocation).first();
configPath += "/custommenu.conf";
qDebug()<<"======configPath:"<<configPath;
QFileInfo fileInfo(configPath);
if (fileInfo.exists() && fileInfo.isReadable()) {
hasCustom = true;
parseFile();
} else {
hasCustom = false;
actiondatas.clear();
}
qDebug()<<"======hasCustom:"<<hasCustom;
}
void MainWindowPrivate::parseFile()
{
actiondatas.clear();
QSettings setting(configPath, QSettings::NativeFormat);
QStringList groups = setting.childGroups();
if (groups.isEmpty()) {
hasCustom = false;
return;
}
for (int i=0; i<groups.count(); ++i) {
QString group = MENUGROUP + QString("%1").arg(i);
ActionData data;
setting.beginGroup(group);
QString type = setting.value(MENUTYPE).toString();
if (MENUTYPEACTION == type) {
data.type = ActionType::Action;
data.name = setting.value(MENUNAME).toString();
data.icon = setting.value(MENUICON).toString();
data.tips = setting.value(MENUTIPS).toString();
data.commd = setting.value(MENUCOMMD).toString();
} else if (MENUTYPESEPARATOR == type) {
data.type = ActionType::Separator;
} else {
data.type = ActionType::Unknow;
}
setting.endGroup();
if (data.type != ActionType::Unknow) {
actiondatas.append(data);
}
}
qDebug()<<"=====actions count:"<<actiondatas.count();
}
MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags f)
: QWidget(*new MainWindowPrivate, parent, f)
{
Q_D(MainWindow);
d->init();
}
MainWindow::~MainWindow()
{
}
MainWindow::MainWindow(MainWindowPrivate &dd, QWidget *parent, Qt::WindowFlags f)
: QWidget (dd, parent, f)
{
Q_D(MainWindow);
d->init();
}
void MainWindow::contextMenuEvent(QContextMenuEvent *event)
{
Q_UNUSED(event)
Q_D(MainWindow);
QMenu menu;
if (d->hasCustom) {
for (auto action : d->actiondatas) {
if (action.type == ActionType::Action) {
QAction *a = new QAction;
a->setText(action.name);
a->setIcon(QIcon(action.icon));
menu.addAction(a);
} else if (action.type == ActionType::Separator) {
menu.addSeparator();
}
}
} else {
// TODO:ๆ นๆฎ่ง่ๆ็ณป็ป้ป่ฎคๅฎ็ฐๆนๅผ๏ผๅ ่ฝฝๆๆ่ๅ
menu.addAction(QString("testAction1"));
menu.addAction(QString("testAction2"));
menu.addSeparator();
menu.addAction(QString("testAction3"));
menu.addAction(QString("testAction4"));
}
connect(&menu, &QMenu::triggered, this, [=](QAction *action) {
qDebug()<<"trigger action:"<<action->text();
});
menu.exec(QCursor::pos());
}
|
[
"wangchunlin@uniontech.com"
] |
wangchunlin@uniontech.com
|
4204607f0d6ac2c99bfa02fcc017f07f9ce2f259
|
6fd7ed15db6ff0cde5ab596e60adc6ee43c2e05f
|
/prob-L6P2 - Candy 2/candy2.cpp
|
a2a0c75283344bb7eaa82cf3982f59bee5e03ff1
|
[] |
no_license
|
tintin3274/Lab-Algorithm-Design-and-Analysis-01418232
|
ac34d43a1a6d7796de10b9548653289ce46e2228
|
eae411fc0876fe3a3c5d6a64a8ed5f62d54786ab
|
refs/heads/main
| 2023-02-26T15:53:41.619148
| 2021-02-01T05:52:24
| 2021-02-01T05:52:24
| 334,845,104
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,107
|
cpp
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void printVector(vector<int> arr){
for (auto i = arr.begin() ; i != arr.end() ; i++){
cout << *i << " ";
}
cout << endl;
}
int main(){
int n;
int count1 = 0,count2 = 0;
bool isUnalternate = false;
cin >> n;
vector<int> arr;
for (int i = 0; i < n; i++ ){
char temp;
cin >> temp;
if (temp == 'r'){
arr.push_back(1);
}
else{
arr.push_back(0);
}
}
for (int i = 0; i < n; i++){
if( i % 2 ){
if(arr[i] != 0)count1++;
}
else{
if(arr[i] != 1)count2++;
}
}
int result = abs(count1 - count2) + min(count1,count2);
count1 = 0;
count2 = 0;
for (int i = 0; i < n; i++){
if( i % 2 ){
if(arr[i] != 1)count1++;
}
else{
if(arr[i] != 0)count2++;
}
}
result = min(result,abs(count1 - count2) + min( count1 , count2 ));
cout << result << endl;
return 0;
}
|
[
"tintin3274@hotmail.co.th"
] |
tintin3274@hotmail.co.th
|
73e1831292033bb8bfbcb11dd3a0fc65034de9c7
|
14c2d3193d39e973e00df21351ed5d0186526dd2
|
/ch3/RacingCarOuterFunc.cpp
|
2982d3a285de9f2dcc254e28c26544da425082d0
|
[] |
no_license
|
younnggsuk/cpp
|
f914b8deb6436b527615bf30ee0b040526648ca8
|
2b99d9e447ad7c91f49bbd38b4b18b74c0a98dac
|
refs/heads/master
| 2020-05-19T08:43:58.955580
| 2019-05-04T17:58:53
| 2019-05-04T17:58:53
| 184,927,631
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,090
|
cpp
|
#include <iostream>
using std::endl;
using std::cout;
using std::cin;
namespace CAR_CONST
{
enum
{
ID_LEN = 20,
MAX_SPD = 200,
ACC_STEP = 10,
BRK_STEP = 10,
FUEL_STEP = 2
};
}
struct Car{
char gamerID[CAR_CONST::ID_LEN];
int fuelGauge;
int curSpeed;
void ShowCarState();
void Accel();
void Break();
};
int main(void)
{
Car car1 = {"car1", 100, 0};
Car car2 = {"car2", 100, 0};
car1.Accel();
car1.Accel();
car1.ShowCarState();
car1.Break();
car1.ShowCarState();
car2.Accel();
car2.Break();
car2.ShowCarState();
return 0;
}
inline void Car::ShowCarState()
{
cout<<"ID : "<<gamerID<<endl;
cout<<"Fuel : "<<fuelGauge<<"%"<<endl;
cout<<"Speed : "<<curSpeed<<"km/h"<<endl<<endl;
}
inline void Car::Accel()
{
if(fuelGauge <= 0)
return;
else
fuelGauge -= CAR_CONST::FUEL_STEP;
if((curSpeed + CAR_CONST::ACC_STEP) >= CAR_CONST::MAX_SPD)
{
curSpeed = CAR_CONST::MAX_SPD;
return;
}
curSpeed += CAR_CONST::ACC_STEP;
}
inline void Car::Break()
{
if(curSpeed <= 0)
{
curSpeed = 0;
return;
}
curSpeed -= CAR_CONST::BRK_STEP;
}
|
[
"younnggsuk@naver.com"
] |
younnggsuk@naver.com
|
e7897c6642984360375b153344255bdc550d590a
|
47bf9100232aa0b76f748aec60e1f9efd8af6105
|
/src/file.cpp
|
8255ceebdcf490443cb261ecbebcf4fd32f0beb7
|
[] |
no_license
|
OniDaito/RayTracer
|
8c6412763192af7e84c1bb66cc598aadefa62895
|
3fde21bd0f405510f1f9417111e5e1b9755ac419
|
refs/heads/master
| 2020-05-22T09:31:29.547402
| 2017-04-07T14:42:29
| 2017-04-07T14:42:29
| 28,977,802
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,686
|
cpp
|
/**
* @brief Cross Platform File Handling
* @file file.cpp
* @author Benjamin Blundell <oni@section9.co.uk>
* @date 06/03/2013
*
*/
__asm__(".symver memcpy,memcpy@GLIBC_2.2.5");
#include "file.hpp"
using namespace std;
using namespace s9;
Path::Path() {
final_path_ = ".";
}
Path::Path(std::string path){
if ( path.find("/") == 0 ){
// Absolute path
final_path_ = path;
}
else if (path.find(".") == 0){
// relative path - setup the data dir
// This exists path is a bit naughty and only here for examples but hey
if (Exists("../../../" + path) ) {
final_path_ = "../../../" + path;
} else if (Exists(path)){
final_path_ = path;
} else {
cerr << "FILE Error - Path does not exist: " << path << endl;
}
final_path_ = string(realpath(final_path_.c_str(),NULL));
}
else {
// error - malformed!
cerr << "FILE Error - Path was malformed: " << path << endl;
assert(false);
}
}
/// list all the files inside this directory
std::vector<File> Directory::ListFiles() {
std::vector<File> files;
DIR *dir;
struct dirent *ent;
if ((dir = opendir (final_path_.c_str())) != NULL) {
while ((ent = readdir (dir)) != NULL) {
struct stat st;
string fp = final_path_ + "/" + string(ent->d_name);
fp = string(realpath(fp.c_str(),NULL));
if (lstat(fp.c_str(), &st) == 0) {
if(S_ISREG(st.st_mode))
files.push_back(File(fp));
} else {
perror("stat");
}
}
closedir (dir);
} else {
/* could not open directory */
cerr << "SEBURO DIRECTORY ERROR - Could not open " << final_path_ << endl;
}
return files;
}
|
[
"b.blundell@qmul.ac.uk"
] |
b.blundell@qmul.ac.uk
|
47ee52a32cd1acd3539b4f026af501ed76238823
|
59a75e12801691f042ff6d6d6430d228c91953ae
|
/StarDisplay/GLSLRibbonProg.hpp
|
8bac70a36143d432a99ba6f54074ff655ddf135a
|
[] |
no_license
|
merovingiano/StarDisplay
|
07800bc40addcf9b6a54846d5c200585a39cc429
|
d08878e6eb9097565ff61ce5037f6b9d2a49af55
|
refs/heads/master
| 2021-01-21T04:36:29.145377
| 2016-03-14T13:54:29
| 2016-03-14T13:54:29
| 32,023,917
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 367
|
hpp
|
#ifndef GLSLRIBBONPROG_HPP_INCLUDED
#define GLSLRIBBONPROG_HPP_INCLUDED
#include <glsl/vertexarray.hpp>
#include "mapped_buffer.hpp"
class GLSLRibbonProg
{
public:
GLSLRibbonProg();
~GLSLRibbonProg();
void Flush(int ignoreId);
void Render();
private:
mapped_buffer mbuffer_;
glsl::vertexarray vao_;
size_t primitives_;
};
#endif
|
[
"robin.mills.27@gmail.com"
] |
robin.mills.27@gmail.com
|
8ce0d54a096f01de902a26d15b8a0c6d924da7cc
|
14e3d5b005e973753bb53acccb398b9571b41219
|
/aula8/src/Diary.cpp
|
5aa0a87f23fcdb246493f33cae03f50afe637c4a
|
[] |
no_license
|
ianbarreto22/lp1
|
f97b790e75ed4ec648e1d0543c6f0323d641491d
|
e5c37d738bdb860e36ae86ba60b0f78a7b9e2203
|
refs/heads/master
| 2022-11-20T10:27:55.838542
| 2020-07-21T01:22:53
| 2020-07-21T01:22:53
| 272,710,321
| 1
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 635
|
cpp
|
#include "Diary.h"
#include "Date.h"
#include "Aux.h"
Diary::Diary(const std::string& name) : filename(name), messages(nullptr), messages_size(0), messages_capacity(10)
{
messages = new Message[messages_capacity];
}
Diary::~Diary()
{
delete[] messages;
}
void Diary::add(const std::string& message)
{
if (messages_size >= messages_capacity) {
return;
}
Message m;
m.content = message;
m.date.set_from_string(get_current_date());
m.time.set_from_string(get_current_time());
messages[messages_size] = m;
messages_size++;
}
void Diary::write()
{
// gravar as mensagens no disco
}
|
[
"noreply@github.com"
] |
ianbarreto22.noreply@github.com
|
ccc5fdeb6399c9f2c14d1f32d4b7d393506937de
|
11b760c6924d5e26f192e3f3968a54b14f562e18
|
/ngraph/core/include/openvino/pass/visualize_tree.hpp
|
b9447a6447a970f0ec9c31d3a4f14456c0a3c21c
|
[
"Apache-2.0"
] |
permissive
|
alexander-shchepetov/openvino
|
810be90ff8b8306f35a0cafa8daf6b61ccb09922
|
a9dae1e3f2ba8b3fec227c51f4c1948667309efc
|
refs/heads/master
| 2023-08-07T21:52:10.472551
| 2021-10-02T11:39:05
| 2021-10-02T11:39:05
| 354,834,303
| 0
| 0
|
Apache-2.0
| 2021-06-07T05:18:14
| 2021-04-05T12:55:16
|
C++
|
UTF-8
|
C++
| false
| false
| 1,812
|
hpp
|
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <functional>
#include <set>
#include <sstream>
#include <string>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>
#include <utility>
#include "openvino/pass/pass.hpp"
class HeightMap;
using visualize_tree_ops_map_t =
std::unordered_map<ov::Node::type_info_t, std::function<void(const ov::Node&, std::ostream& ss)>>;
namespace ov {
namespace pass {
class OPENVINO_API VisualizeTree : public FunctionPass {
public:
OPENVINO_RTTI("ngraph::pass::VisualizeTree");
using node_modifiers_t = std::function<void(const Node& node, std::vector<std::string>& attributes)>;
VisualizeTree(const std::string& file_name, node_modifiers_t nm = nullptr, bool dot_only = false);
bool run_on_function(std::shared_ptr<ov::Function>) override;
void set_ops_to_details(const visualize_tree_ops_map_t& ops_map) {
m_ops_to_details = ops_map;
}
protected:
void add_node_arguments(std::shared_ptr<Node> node,
std::unordered_map<Node*, HeightMap>& height_maps,
size_t& fake_node_ctr);
std::string add_attributes(std::shared_ptr<Node> node);
virtual std::string get_attributes(std::shared_ptr<Node> node);
virtual std::string get_node_name(std::shared_ptr<Node> node);
std::string get_constant_value(std::shared_ptr<Node> node, size_t max_elements = 7);
void render() const;
std::stringstream m_ss;
std::string m_name;
std::set<std::shared_ptr<Node>> m_nodes_with_attributes;
visualize_tree_ops_map_t m_ops_to_details;
node_modifiers_t m_node_modifiers = nullptr;
bool m_dot_only;
static const int max_jump_distance;
};
} // namespace pass
} // namespace ov
|
[
"noreply@github.com"
] |
alexander-shchepetov.noreply@github.com
|
92868076241c9fb906cd4333c5759a59ea852ea2
|
7ccaf6d66baf345b4f001847414b6e4c056242b6
|
/src/filter2/vtkPCLBRigidAlignmentFilter2.cxx
|
70f2e5cc24388606fa1cfb6f94d817baf2926d6f
|
[
"Apache-2.0"
] |
permissive
|
dys564843131/ParaView-PCLPlugin
|
037525e133d1390b559dda13c14c8534fc7662e8
|
a6c13164bfe46796647ea3a7b4433a28d61f0bbc
|
refs/heads/master
| 2020-09-28T10:49:39.160619
| 2019-10-10T14:15:56
| 2019-10-10T14:15:56
| 226,762,762
| 1
| 0
|
Apache-2.0
| 2019-12-09T01:53:24
| 2019-12-09T01:53:24
| null |
UTF-8
|
C++
| false
| false
| 6,372
|
cxx
|
//==============================================================================
//
// Copyright 2012-2019 Kitware, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//==============================================================================
#include "vtkPCLBRigidAlignmentFilter2.h"
#include "vtkPCLConversions.h"
#include "FeatureExtractor.h"
#include "vtkObjectFactory.h"
#include <pcl/common/transforms.h>
#include <pcl/registration/icp.h>
//------------------------------------------------------------------------------
vtkStandardNewMacro(vtkPCLBRigidAlignmentFilter2);
//------------------------------------------------------------------------------
vtkPCLBRigidAlignmentFilter2::vtkPCLBRigidAlignmentFilter2()
{
}
//------------------------------------------------------------------------------
vtkPCLBRigidAlignmentFilter2::~vtkPCLBRigidAlignmentFilter2()
{
}
//------------------------------------------------------------------------------
void vtkPCLBRigidAlignmentFilter2::PrintSelf(ostream & os, vtkIndent indent)
{
this->Superclass::PrintSelf(os, indent);
os << indent << "NormalRadius: " << this->NormalRadius << "\n";
os << indent << "FeatureRadius: " << this->FeatureRadius << "\n";
os << indent << "DistanceThreshold: " << this->DistanceThreshold << "\n";
os << indent << "MaxIterations: " << this->MaxIterations << "\n";
os << indent << "Probability: " << this->Probability << "\n";
os << indent << "TransformationMatrix: " << this->TransformationMatrix << "\n";
os << indent << "HasTransformation: " << (this->HasTransformation ? "yes" : "no") << "\n";
os << indent << "ReuseTransformation: " << (this->ReuseTransformation ? "yes" : "no") << "\n";
}
//------------------------------------------------------------------------------
int vtkPCLBRigidAlignmentFilter2::ApplyPCLFilter2(
vtkPolyData * input,
vtkPolyData * target,
vtkPolyData * output
)
{
int index = vtkPCLConversions::GetPointTypeIndex(input);
#define _statement(PointType) return this->InternalApplyPCLFilter2<PointType,pcl::Normal,pcl::FPFHSignature33>(input, target, output);
PCLP_INVOKE_WITH_PCL_XYZ_POINT_TYPE(index, _statement)
#undef _statement
vtkErrorMacro(<< "no XYZ point data in input")
return 0;
}
//------------------------------------------------------------------------------
template <typename PointT, typename NormalT, typename FeatureT>
int vtkPCLBRigidAlignmentFilter2::InternalApplyPCLFilter2(
vtkPolyData * input,
vtkPolyData * target,
vtkPolyData * output
)
{
// The transformation will be applied to the input cloud to preserve its
// attributes even if the model used is purely geometric.
typedef pcl::PointCloud<PointT> CloudT;
typename CloudT::Ptr inputCloud(new CloudT);
typename CloudT::Ptr outputCloud(new CloudT);
vtkPCLConversions::PointCloudFromPolyData(input, inputCloud);
// Perform the alignment and get the transformation matrix if missing or reuse
// is not requested.
if (! (this->HasTransformation && this->ReuseTransformation))
{
// The model functions require PointNormal clouds. These are used to
// calculate the transformation, which will then be applied to the input
// type to preserve attributes.
//
// TODO: check if this is can be generalized to all point types.
typedef pcl::PointNormal PointNormalT;
typedef pcl::PointCloud<PointNormalT> NormalCloudT;
typename NormalCloudT::Ptr sourceCloud(new NormalCloudT);
typename NormalCloudT::Ptr targetCloud(new NormalCloudT);
vtkPCLConversions::PointCloudFromPolyData(input, sourceCloud);
vtkPCLConversions::PointCloudFromPolyData(target, targetCloud);
FeatureExtractor<PointNormalT, NormalT, FeatureT>
feSource(sourceCloud, this->NormalRadius, this->FeatureRadius),
feTarget(targetCloud, this->NormalRadius, this->FeatureRadius);
pcl::Correspondences correspondences;
pcl::registration::CorrespondenceEstimation<FeatureT,FeatureT> correspondenceEstimator;
correspondenceEstimator.setInputCloud(feSource.Features);
correspondenceEstimator.setInputTarget(feTarget.Features);
correspondenceEstimator.initCompute();
correspondenceEstimator.determineCorrespondences(correspondences);
auto nr_correspondences = correspondences.size();
std::vector<int> sourceIndices (nr_correspondences);
std::vector<int> targetIndices (nr_correspondences);
for (decltype(nr_correspondences) i = 0; i < nr_correspondences; ++i)
{
sourceIndices[i] = correspondences[i].index_query;
targetIndices[i] = correspondences[i].index_match;
}
pcl::SampleConsensusModelRegistration<PointNormalT>::Ptr ransacModel;
ransacModel.reset(new pcl::SampleConsensusModelRegistration<PointNormalT>(sourceCloud, sourceIndices));
ransacModel->setInputTarget (targetCloud, targetIndices);
pcl::RandomSampleConsensus<PointNormalT> ransacFilter(ransacModel);
ransacFilter.setMaxIterations(this->MaxIterations);
ransacFilter.setDistanceThreshold(this->DistanceThreshold);
ransacFilter.setProbability(this->Probability);
if (! (ransacFilter.computeModel() && ransacFilter.refineModel()))
{
vtkErrorMacro(<< "failed to compute random sample consensus")
return 0;
}
Eigen::VectorXf modelCoefficients;
ransacFilter.getModelCoefficients(modelCoefficients);
this->TransformationMatrix.row (0) = modelCoefficients.segment<4>(0);
this->TransformationMatrix.row (1) = modelCoefficients.segment<4>(4);
this->TransformationMatrix.row (2) = modelCoefficients.segment<4>(8);
this->TransformationMatrix.row (3) = modelCoefficients.segment<4>(12);
this->HasTransformation = true;
}
pcl::transformPointCloud<PointT>((* inputCloud), (* outputCloud), this->TransformationMatrix);
vtkPCLConversions::PolyDataFromPointCloud(outputCloud, output);
return 1;
}
|
[
"mike.rye@kitware.com"
] |
mike.rye@kitware.com
|
3a5d27b7e91af74d728dc2e78abe3b24e1b1de51
|
e73d2cea4aaeb9be92105581df617d524a532ba5
|
/Space_Invaders_Linux/src/Pilot.cpp
|
f450596f2c280d0cd6c1e76aa155f011c6aa0698
|
[] |
no_license
|
shanesatterfield/Space_Invaders
|
f9200650dab80d9fd26ab4f99ffb2fa23a53a57a
|
4ca0e2e359daeafec391de33fdc555287631355e
|
refs/heads/master
| 2016-08-07T04:51:30.025577
| 2012-08-27T10:57:09
| 2012-08-27T10:57:09
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,376
|
cpp
|
#include "Pilot.h"
#include "SDL/SDL.h"
#include "SDL/SDL_image.h"
#include "SDL/SDL_ttf.h"
#include "Shot.h"
#include <vector>
#include <time.h>
#include <stdio.h>
#include <math.h>
Pilot::Pilot( int X, int Y, SDL_Surface* temp, SDL_Surface* shieldTemp, SDL_Surface* lowTemp, int shield_)
{
//Initialize the offsets
x = X;
y = Y;
//Initialize the velocity
xVel = 0;
yVel = 0;
shield = shield_;
image = temp;
shieldImage = shieldTemp;
lowShield = lowTemp;
hardMode = true;
//Create the necessary SDL_Rects
box.resize( 6 );
//Initialize the collision boxes' width and height
box[ 0 ].w = 4;
box[ 0 ].h = 12;
box[ 1 ].w = 3*4;
box[ 1 ].h = 4;
box[ 2 ].w = 20;
box[ 2 ].h = 4;
box[ 3 ].w = 36;
box[ 3 ].h = 4;
box[ 4 ].w = 52;
box[ 4 ].h = 4;
box[ 5 ].w = 68;
box[ 5 ].h = 20;
//Move the collision boxes to their proper spot
shift_boxes();
}
void Pilot::apply_surface(int x, int y, SDL_Surface* source, SDL_Surface* destination){
SDL_Rect offset;
offset.x = x;
offset.y = y;
SDL_BlitSurface(source, NULL, destination, &offset);
}
void Pilot::shift_boxes()
{
//The row offset
int r = 0;
//Go through the dot's collision boxes
for( int set = 0; set < box.size(); set++ )
{
//Center the collision box
box[ set ].x = x + ( image->w - box[ set ].w ) / 2;
//Set the collision box at its row offset
box[ set ].y = y + r;
//Move the row offset down the height of the collision box
r += box[ set ].h;
}
}
void Pilot::pilotMovement(std::vector<Shot> &hyperBeam, SDL_Surface* shots, clock_t &shotPause, int SCREEN_WIDTH, int FRAMES_PER_SECOND, int frames_per){
Uint8 *keystates = SDL_GetKeyState(NULL);
if( (keystates[SDLK_RIGHT] || keystates[SDLK_d] ) && x + image->w < SCREEN_WIDTH){
if(frames_per > 0){
x += 10 * ceil(float(FRAMES_PER_SECOND) / frames_per);
}
else
x += 10;
shift_boxes();
}
if( (keystates[SDLK_LEFT] || keystates[SDLK_a]) && x > 0){
if(frames_per > 0 && frames_per < FRAMES_PER_SECOND){
x -= 10 * (float(FRAMES_PER_SECOND) / frames_per);
}
else
x -= 10;
shift_boxes();
}
if(keystates[SDLK_SPACE] && (float(clock()) - float(shotPause))/CLOCKS_PER_SEC*10 > .2){
Shot temp2(x + (image->w - shots->w)/2, y, shots);
hyperBeam.push_back(temp2);
shotPause = clock();
}
}
void Pilot::show(SDL_Surface* screen, SDL_Surface* tempMessage){
if(!hardMode){
if(shield >= 3){
apply_surface(x,y,shieldImage,screen);
}
else if(shield > 0){
apply_surface(x,y,lowShield,screen);
}
else{
apply_surface(x,y,image,screen);
}
}
else
apply_surface(x,y,image,screen);
apply_surface(x + (image->w - tempMessage->w)/2, y + (image->h - tempMessage->h)/1.35, tempMessage, screen);
}
std::vector<SDL_Rect> &Pilot::get_rects()
{
//Retrieve the collision boxes
return box;
}
bool Pilot::check_collision( std::vector<SDL_Rect> &B )
{
//The sides of the rectangles
int leftA, leftB;
int rightA, rightB;
int topA, topB;
int bottomA, bottomB;
//Go through the A boxes
for( int Abox = 0; Abox < box.size(); Abox++ )
{
//Calculate the sides of rect A
leftA = box[ Abox ].x;
rightA = box[ Abox ].x + box[ Abox ].w;
topA = box[ Abox ].y;
bottomA = box[ Abox ].y + box[ Abox ].h;
//Go through the B boxes
for( int Bbox = 0; Bbox < B.size(); Bbox++ )
{
//Calculate the sides of rect B
leftB = B[ Bbox ].x;
rightB = B[ Bbox ].x + B[ Bbox ].w;
topB = B[ Bbox ].y;
bottomB = B[ Bbox ].y + B[ Bbox ].h;
//If no sides from A are outside of B
if( ( ( bottomA <= topB ) || ( topA >= bottomB ) || ( rightA <= leftB ) || ( leftA >= rightB ) ) == false )
{
//A collision is detected
return true;
}
}
}
//If neither set of collision boxes touched
return false;
}
|
[
"dustyplant@gmail.com"
] |
dustyplant@gmail.com
|
51b8831d6de93b5fc2b07943109c575d3eceb1e4
|
eec2dbab8e275f8195cb49676b7766c328e5d4b9
|
/Labs/lab-10-visitor-pattern-tobecontinued-master/rand.hpp
|
bbdf28fd684404b7ab860d7c0cccab5032a92f01
|
[] |
no_license
|
kevint1221/CS100
|
84c3625116feabaa3939c844b2fd7b59348c1dba
|
1b2c1fed4426cbf699d446122a708cdd91172b84
|
refs/heads/master
| 2020-06-25T09:36:07.551450
| 2019-07-28T10:49:18
| 2019-07-28T10:49:18
| 199,273,803
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 817
|
hpp
|
#ifndef RAND_H
#define RAND_H
#include "base.hpp"
#include <string>
#include "nullIterator.hpp"
#include "visitor.hpp"
using namespace std;
class Rand: public Base {
public:
Rand() {
this->data = getRandDouble();
}
double getRandDouble();
double evaluate() ;
string stringify();
Base* get_left(){ return nullptr; }
Base* get_right(){ return nullptr; }
Iterator* create_iterator(){
return new NullIterator(this);
}
void accept(CountVisitor* c){
c->visit_rand();
}
private:
double data;
};
double Rand::getRandDouble() {
srand (time(NULL));
double randNum = rand() % 100;
return randNum;
}
double Rand::evaluate() {
return data;
}
string Rand::stringify() {
return to_string(data);
}
#endif
|
[
"32470783+kevint1221@users.noreply.github.com"
] |
32470783+kevint1221@users.noreply.github.com
|
535453268335bd882b9fb645fe0835aa7b37bf1c
|
641fa8341d8c436ad24945bcbf8e7d7d1dd7dbb2
|
/components/content_settings/core/test/content_settings_test_utils.cc
|
9ec3edb023a3f76561d95112bdd3912ff2d9f116
|
[
"BSD-3-Clause"
] |
permissive
|
massnetwork/mass-browser
|
7de0dfc541cbac00ffa7308541394bac1e945b76
|
67526da9358734698c067b7775be491423884339
|
refs/heads/master
| 2022-12-07T09:01:31.027715
| 2017-01-19T14:29:18
| 2017-01-19T14:29:18
| 73,799,690
| 4
| 4
|
BSD-3-Clause
| 2022-11-26T11:53:23
| 2016-11-15T09:49:29
| null |
UTF-8
|
C++
| false
| false
| 2,364
|
cc
|
// Copyright (c) 2012 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 "components/content_settings/core/test/content_settings_test_utils.h"
#include "components/content_settings/core/browser/content_settings_observable_provider.h"
#include "components/content_settings/core/browser/host_content_settings_map.h"
#include "components/content_settings/core/common/content_settings_types.h"
namespace content_settings {
// static
base::Value* TestUtils::GetContentSettingValue(
const ProviderInterface* provider,
const GURL& primary_url,
const GURL& secondary_url,
ContentSettingsType content_type,
const std::string& resource_identifier,
bool include_incognito) {
return HostContentSettingsMap::GetContentSettingValueAndPatterns(
provider, primary_url, secondary_url, content_type, resource_identifier,
include_incognito, NULL, NULL).release();
}
// static
ContentSetting TestUtils::GetContentSetting(
const ProviderInterface* provider,
const GURL& primary_url,
const GURL& secondary_url,
ContentSettingsType content_type,
const std::string& resource_identifier,
bool include_incognito) {
std::unique_ptr<base::Value> value(
GetContentSettingValue(provider, primary_url, secondary_url, content_type,
resource_identifier, include_incognito));
return ValueToContentSetting(value.get());
}
// static
std::unique_ptr<base::Value> TestUtils::GetContentSettingValueAndPatterns(
content_settings::RuleIterator* rule_iterator,
const GURL& primary_url,
const GURL& secondary_url,
ContentSettingsPattern* primary_pattern,
ContentSettingsPattern* secondary_pattern) {
return HostContentSettingsMap::GetContentSettingValueAndPatterns(
rule_iterator, primary_url, secondary_url, primary_pattern,
secondary_pattern);
}
// static
void TestUtils::OverrideProvider(
HostContentSettingsMap* map,
std::unique_ptr<content_settings::ObservableProvider> provider,
HostContentSettingsMap::ProviderType type) {
if (map->content_settings_providers_[type]) {
map->content_settings_providers_[type]->ShutdownOnUIThread();
}
map->content_settings_providers_[type] = std::move(provider);
}
} // namespace content_settings
|
[
"xElvis89x@gmail.com"
] |
xElvis89x@gmail.com
|
67ea3a42022021207bf872642692326877df368d
|
786de89be635eb21295070a6a3452f3a7fe6712c
|
/psddl_hdf2psana/tags/V00-02-02/include/epics.ddl.h
|
af4c7b8d2527c81dcb4079577eabc2d828ab2ca4
|
[] |
no_license
|
connectthefuture/psdmrepo
|
85267cfe8d54564f99e17035efe931077c8f7a37
|
f32870a987a7493e7bf0f0a5c1712a5a030ef199
|
refs/heads/master
| 2021-01-13T03:26:35.494026
| 2015-09-03T22:22:11
| 2015-09-03T22:22:11
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 4,966
|
h
|
#ifndef PSDDL_HDF2PSANA_EPICS_DDL_H
#define PSDDL_HDF2PSANA_EPICS_DDL_H 1
// *** Do not edit this file, it is auto-generated ***
#include "psddl_psana/epics.ddl.h"
#include "hdf5pp/Group.h"
#include "hdf5pp/Type.h"
#include "PSEvt/Proxy.h"
namespace psddl_hdf2psana {
namespace Epics {
enum {
iXtcVersion = 1 /**< */
};
enum {
iMaxPvNameLength = 64 /**< Maximum size of PV name string. */
};
enum {
MAX_STRING_SIZE = 40 /**< Maximum length of strings in EPICS. */
};
enum {
MAX_UNITS_SIZE = 8 /**< Maximum lenght of units strings. */
};
enum {
MAX_ENUM_STRING_SIZE = 26 /**< Maximum length of strings specifying ENUMs. */
};
enum {
MAX_ENUM_STATES = 16 /**< Maximum number of different ENUM constants. */
};
/** Enum specifying type of DBR structures. */
enum DbrTypes {
DBR_STRING = 0,
DBR_SHORT = 1,
DBR_FLOAT = 2,
DBR_ENUM = 3,
DBR_CHAR = 4,
DBR_LONG = 5,
DBR_DOUBLE = 6,
DBR_STS_STRING = 7,
DBR_STS_SHORT = 8,
DBR_STS_FLOAT = 9,
DBR_STS_ENUM = 10,
DBR_STS_CHAR = 11,
DBR_STS_LONG = 12,
DBR_STS_DOUBLE = 13,
DBR_TIME_STRING = 14,
DBR_TIME_INT = 15,
DBR_TIME_SHORT = 15,
DBR_TIME_FLOAT = 16,
DBR_TIME_ENUM = 17,
DBR_TIME_CHAR = 18,
DBR_TIME_LONG = 19,
DBR_TIME_DOUBLE = 20,
DBR_GR_STRING = 21,
DBR_GR_SHORT = 22,
DBR_GR_FLOAT = 23,
DBR_GR_ENUM = 24,
DBR_GR_CHAR = 25,
DBR_GR_LONG = 26,
DBR_GR_DOUBLE = 27,
DBR_CTRL_STRING = 28,
DBR_CTRL_SHORT = 29,
DBR_CTRL_FLOAT = 30,
DBR_CTRL_ENUM = 31,
DBR_CTRL_CHAR = 32,
DBR_CTRL_LONG = 33,
DBR_CTRL_DOUBLE = 34,
};
namespace ns_epicsTimeStamp_v0 {
struct dataset_data {
static hdf5pp::Type native_type();
static hdf5pp::Type stored_type();
dataset_data();
dataset_data(const Psana::Epics::epicsTimeStamp& psanaobj);
~dataset_data();
uint32_t secPastEpoch;
uint32_t nsec;
operator Psana::Epics::epicsTimeStamp() const { return Psana::Epics::epicsTimeStamp(secPastEpoch, nsec); }
};
}
namespace ns_EpicsPvHeader_v0 {
struct dataset_data {
static hdf5pp::Type native_type();
static hdf5pp::Type stored_type();
dataset_data();
dataset_data(const Psana::Epics::EpicsPvHeader& psanaobj);
~dataset_data();
int16_t pvId;
int16_t dbrType;
int16_t numElements;
};
}
class EpicsPvHeader_v0 : public Psana::Epics::EpicsPvHeader {
public:
typedef Psana::Epics::EpicsPvHeader PsanaType;
EpicsPvHeader_v0() {}
EpicsPvHeader_v0(hdf5pp::Group group, hsize_t idx)
: m_group(group), m_idx(idx) {}
EpicsPvHeader_v0(const boost::shared_ptr<Epics::ns_EpicsPvHeader_v0::dataset_data>& ds) : m_ds_data(ds) {}
virtual ~EpicsPvHeader_v0() {}
virtual int16_t pvId() const;
virtual int16_t dbrType() const;
virtual int16_t numElements() const;
/** Returns 1 if PV is one of CTRL types, 0 otherwise. */
uint8_t isCtrl() const;
/** Returns 1 if PV is one of TIME types, 0 otherwise. */
uint8_t isTime() const;
/** Returns status value for the PV. */
uint16_t status() const;
/** Returns severity value for the PV. */
uint16_t severity() const;
private:
mutable hdf5pp::Group m_group;
hsize_t m_idx;
mutable boost::shared_ptr<Epics::ns_EpicsPvHeader_v0::dataset_data> m_ds_data;
void read_ds_data() const;
};
namespace ns_PvConfigV1_v0 {
struct dataset_data {
static hdf5pp::Type native_type();
static hdf5pp::Type stored_type();
dataset_data();
dataset_data(const Psana::Epics::PvConfigV1& psanaobj);
~dataset_data();
int16_t pvId;
char description[64];
float interval;
operator Psana::Epics::PvConfigV1() const { return Psana::Epics::PvConfigV1(pvId, description, interval); }
};
}
namespace ns_ConfigV1_v0 {
struct dataset_config {
static hdf5pp::Type native_type();
static hdf5pp::Type stored_type();
dataset_config();
dataset_config(const Psana::Epics::ConfigV1& psanaobj);
~dataset_config();
int32_t numPv;
};
}
class ConfigV1_v0 : public Psana::Epics::ConfigV1 {
public:
typedef Psana::Epics::ConfigV1 PsanaType;
ConfigV1_v0() {}
ConfigV1_v0(hdf5pp::Group group, hsize_t idx)
: m_group(group), m_idx(idx) {}
virtual ~ConfigV1_v0() {}
virtual int32_t numPv() const;
virtual ndarray<const Psana::Epics::PvConfigV1, 1> pvControls() const;
private:
mutable hdf5pp::Group m_group;
hsize_t m_idx;
mutable boost::shared_ptr<Epics::ns_ConfigV1_v0::dataset_config> m_ds_config;
void read_ds_config() const;
mutable ndarray<const Psana::Epics::PvConfigV1, 1> m_ds_pvConfig;
void read_ds_pvConfig() const;
};
boost::shared_ptr<PSEvt::Proxy<Psana::Epics::ConfigV1> > make_ConfigV1(int version, hdf5pp::Group group, hsize_t idx);
void store(const Psana::Epics::ConfigV1& obj, hdf5pp::Group group, int version = -1);
void append(const Psana::Epics::ConfigV1& obj, hdf5pp::Group group, int version = -1);
} // namespace Epics
} // namespace psddl_hdf2psana
#endif // PSDDL_HDF2PSANA_EPICS_DDL_H
|
[
"salnikov@SLAC.STANFORD.EDU@b967ad99-d558-0410-b138-e0f6c56caec7"
] |
salnikov@SLAC.STANFORD.EDU@b967ad99-d558-0410-b138-e0f6c56caec7
|
7522d74331191d64ee6c2309b1d7755b361a6d68
|
ed20cf1539dbc0aa2f57f3451f0aba2c77e02eb8
|
/week-01/day-3/AnimalsAndLegs/main.cpp
|
340714bd507be2fdc156eb8e2650cf3cc11e4968
|
[] |
no_license
|
green-fox-academy/Joco456
|
60b0090dcc9f368240cca045eea4b3f67df69f83
|
3b98cdb39f26010246ecc38837b62e4f37d00b91
|
refs/heads/master
| 2020-05-04T08:59:18.192461
| 2019-10-03T09:17:11
| 2019-10-03T09:17:11
| 179,058,002
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 629
|
cpp
|
#include <iostream>
int main(int argc, char* args[]) {
// Write a program that asks for two integers
// The first represents the number of chickens the farmer has
// The second represents the number of pigs owned by the farmer
// It should print how many legs all the animals have
int chicken;
int pig;
std::cout << "Please enter the number of chickens!" <<std::endl;
std::cin >> chicken;
std::cout << "Please enter the number of pigs!" << std::endl;
std::cin >> pig;
int legs = chicken * 2 + pig * 4;
std::cout << "The number of legs: " << legs << std::endl;
return 0;
}
|
[
"jozsef.varga.123@gmail.com"
] |
jozsef.varga.123@gmail.com
|
ad31786f160f44adfcdf7294309707b2c1da59c7
|
53b28ebf3028837eaf69870ea14f1393a7728cf4
|
/src/Engine/XmlExpertSystemLoader.cpp
|
6d017bd024fc700f76d0440610ca41067f29d1e7
|
[
"MIT"
] |
permissive
|
AndreyBuyanov/ExpertSystem
|
a538aa34a9401fc2f228430b73697a92801b14ce
|
a4208300ad3f1095259345511debb9e28af0c9fc
|
refs/heads/main
| 2023-02-02T17:45:04.201868
| 2020-12-17T13:02:56
| 2020-12-17T13:02:56
| 319,333,142
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,521
|
cpp
|
๏ปฟ#include "XmlExpertSystemLoader.hpp"
#include "ILogger.hpp"
#include "pugixml.hpp"
#include <stdexcept>
namespace ES
{
/**
* ะกะพะทะดะฐะฝะธะต ะทะฐะณััะทัะธะบะฐ ะฟะพ ัะผะพะปัะฐะฝะธั.
*
* \return ะญะบะทะตะผะฟะปัั ะทะฐะณััะทัะธะบะฐ
*/
std::unique_ptr<IExpertSystemLoader> CreateExpertSystemLoader()
{
return std::make_unique<XmlExpertSystemLoader>();
}
/**
* ะะฐะณััะทะบะฐ ัะบัะฟะตััะฝะพะน ัะธััะตะผั ะธะท ัะฐะนะปะฐ ะบะพะฝัะธะณััะฐัะธะธ.
*
* \param configPath ะฟััั ะบ ัะฐะนะปั ะบะพะฝัะธะณััะฐัะธะธ
* \return
*/
void XmlExpertSystemLoader::Load(
const std::string& configPath) noexcept(false)
{
// xml-ัะฐะนะป
pugi::xml_document doc;
// ะัะบััะฒะฐะตะผ ัะฐะนะป
pugi::xml_parse_result result = doc.load_file(configPath.c_str());
// ะัะพะฒะตััะตะผ ัะตะทัะปััะฐั ะพัะบัััะธั ะธ ะฟะฐััะธะฝะณะฐ ัะฐะนะปะฐ
if (!result) {
// ะงัะพ-ัะพ ะฟะพัะปะพ ะฝะต ัะฐะบ. ะะธะดะฐะตะผ ะธัะบะปััะตะฝะธะต
throw std::runtime_error(result.description());
}
// ะัะตะผ ะฒ ะดะพะบัะผะตะฝัะต ัะปะตะผะตะฝั <es>
auto elEs = doc.child("es");
if (!elEs) {
// ะญะปะตะผะตะฝั <es> ะฝะต ะฝะฐะนะดะตะฝ. ะะธะดะฐะตะผ ะธัะบะปััะตะฝะธะต
throw std::runtime_error(
u8"ะ ะบะพะฝัะธะณััะฐัะธะพะฝะฝะพะผ ัะฐะนะปะต ะฝะต ะฝะฐะนะดะตะฝ ัะปะตะผะตะฝั <es>");
}
// ะัะตะผ ะฒ ะดะพัะตัะฝะธั
ัะปะตะผะตะฝัะฐั
ัะปะตะผะตะฝัะฐ <es> ัะปะตะผะตะฝั <name>
auto elName = elEs.child("name");
if (!elName) {
// ะญะปะตะผะตะฝั <name> ะฝะต ะฝะฐะนะดะตะฝ. ะะธะดะฐะตะผ ะธัะบะปััะตะฝะธะต
throw std::runtime_error(
u8"ะ ะบะพะฝัะธะณััะฐัะธะพะฝะฝะพะผ ัะฐะนะปะต ะฝะต ะฝะฐะนะดะตะฝ ัะปะตะผะตะฝั <name>");
}
// ะกะพั
ัะฐะฝัะตะผ ะฝะฐะทะฒะฐะฝะธะต ัะบัะฟะตััะฝะพะน ัะธััะตะผั
m_name = elName.text().as_string();
// ะัะตะผ ะฒ ะดะพัะตัะฝะธั
ัะปะตะผะตะฝัะฐั
ัะปะตะผะตะฝัะฐ <es> ัะปะตะผะตะฝั <tree>
auto elTree = elEs.child("tree");
if (!elTree) {
// ะญะปะตะผะตะฝั <tree> ะฝะต ะฝะฐะนะดะตะฝ. ะะธะดะฐะตะผ ะธัะบะปััะตะฝะธะต
throw std::runtime_error(
u8"ะ ะบะพะฝัะธะณััะฐัะธะพะฝะฝะพะผ ัะฐะนะปะต ะฝะต ะฝะฐะนะดะตะฝ ัะปะตะผะตะฝั <tree>");
}
// ะัะตะผ ะฒ ะดะพัะตัะฝะธั
ัะปะตะผะตะฝัะฐั
ัะปะตะผะตะฝัะฐ <tree> ัะปะตะผะตะฝั <nodes>
auto elNodes = elTree.child("nodes");
if (!elNodes) {
// ะญะปะตะผะตะฝั <nodes> ะฝะต ะฝะฐะนะดะตะฝ. ะะธะดะฐะตะผ ะธัะบะปััะตะฝะธะต
throw std::runtime_error(
u8"ะ ะบะพะฝัะธะณััะฐัะธะพะฝะฝะพะผ ัะฐะนะปะต ะฝะต ะฝะฐะนะดะตะฝ ัะปะตะผะตะฝั <nodes>");
}
// ะัะพั
ะพะดะธะผ ะฟะพ ะดะพัะตัะฝะธะผ ัะปะตะผะตะฝัะฐะผ <node> ัะปะตะผะตะฝัะฐ <nodes>
for (auto node = elNodes.child("node"); node; node = node.next_sibling("node")) {
// ะกัะธััะฒะฐะตะผ ะฐััะธะฑัั type
auto nodeType = node.attribute("type");
if (!nodeType) {
// ะััะธะฑัั type ะฝะต ะฝะฐะนะดะตะฝ. ะะฐะฟะธัะตะผ ะฟัะตะดัะฟัะตะถะดะตะฝะธะต ะฒ ะปะพะณ
logger->Log(LogLevel::Warning,
u8"ะฃ ัะปะตะผะตะฝัะฐ <node> ะฝะต ะฝะฐะนะดะตะฝ ะฐััะธะฑัั type");
// ะัะพะธะณะฝะพัะธััะตะผ ัะตะบััะนะธ ัะปะตะผะตะฝั ะธ ะฟะตัะตะนะดัะผ ะบ ัะปะตะดัััะตะผั ัะปะตะผะตะฝัั
continue;
}
// ะกัะธััะฒะฐะตะผ ะฐััะธะฑัั id
auto nodeID = node.attribute("id");
if (!nodeID) {
// ะััะธะฑัั id ะฝะต ะฝะฐะนะดะตะฝ. ะะฐะฟะธัะตะผ ะฟัะตะดัะฟัะตะถะดะตะฝะธะต ะฒ ะปะพะณ
logger->Log(LogLevel::Warning,
u8"ะฃ ัะปะตะผะตะฝัะฐ <node> ะฝะต ะฝะฐะนะดะตะฝ ะฐััะธะฑัั id");
// ะัะพะธะณะฝะพัะธััะตะผ ัะตะบััะนะธ ัะปะตะผะตะฝั ะธ ะฟะตัะตะนะดัะผ ะบ ัะปะตะดัััะตะผั ัะปะตะผะตะฝัั
continue;
}
// ะกัะธััะฒะฐะตะผ ะดะฐะฝะฝัะต ัะทะปะฐ
auto nodeData = node.text();
if (!nodeData) {
// ะะฐะฝะฝัั
ะฝะต ะพะบะฐะทะฐะปะพัั. ะะฐะฟะธัะตะผ ะฟัะตะดัะฟัะตะถะดะตะฝะธะต ะฒ ะปะพะณ
logger->Log(LogLevel::Warning,
u8"ะญะปะตะผะตะฝั <node> ะฝะต ัะพะดะตัะถะธั ะดะฐะฝะฝัั
");
// ะัะพะธะณะฝะพัะธััะตะผ ัะตะบััะนะธ ัะปะตะผะตะฝั ะธ ะฟะตัะตะนะดัะผ ะบ ัะปะตะดัััะตะผั ัะปะตะผะตะฝัั
continue;
}
// ะะพะปััะฐะตะผ ััะพัะพะบะพะฒะพะต ะฟัะตะดััะฐะฒะปะตะฝะธะต ัะธะฟะฐ ัะทะปะฐ
std::string nodeTypeStr = nodeType.as_string();
if (nodeTypeStr == "question") {
// ะัะปะธ ัะตะบััะธะน ัะทะตะป - ััะพ ะฒะพะฟัะพั, ัะพ ะดะพะฑะฐะฒะปัะตะผ ะดะฐะฝะฝัะต ััะพะณะพ ัะทะปะฐ ะบ ัะฟะธัะบั ะฒะพะฟัะพัะพะฒ
m_questions.emplace_back(nodeID.as_int(), std::string(nodeData.as_string()));
}
else if (nodeTypeStr == "answer") {
// ะัะปะธ ัะตะบััะธะน ัะทะตะป - ััะพ ะพัะฒะตั, ัะพ ะดะพะฑะฐะฒะปัะตะผ ะดะฐะฝะฝัะต ััะพะณะพ ัะทะปะฐ ะบ ัะฟะธัะบั ะพัะฒะตัะพะฒ
m_answers.emplace_back(nodeID.as_int(), nodeData.as_string());
}
else {
// ะะตะธะทะฒะตััะฝัะน ัะธะฟ ัะทะปะฐ. ะะฐะฟะธัะตะผ ะฟัะตะดัะฟัะตะถะดะตะฝะธะต ะฒ ะปะพะณ
logger->Log(LogLevel::Warning,
u8"ะญะปะตะผะตะฝั <node> ะธะผะตะตั ะฝะตะธะทะฒะตััะฝัะน ัะธะฟ");
}
}
// ะัะตะผ ะฒ ะดะพัะตัะฝะธั
ัะปะตะผะตะฝัะฐั
ัะปะตะผะตะฝัะฐ <tree> ัะปะตะผะตะฝั <connections>
auto nodeConnections = elTree.child("connections");
if (!nodeConnections) {
// ะญะปะตะผะตะฝั <connections> ะฝะต ะฝะฐะนะดะตะฝ. ะะธะดะฐะตะผ ะธัะบะปััะตะฝะธะต
throw std::runtime_error(
u8"ะ ะบะพะฝัะธะณััะฐัะธะพะฝะฝะพะผ ัะฐะนะปะต ะฝะต ะฝะฐะนะดะตะฝ ัะปะตะผะตะฝั <connections>");
}
// ะัะพั
ะพะดะธะผ ะฟะพ ะดะพัะตัะฝะธะผ ัะปะตะผะตะฝัะฐะผ <connection> ัะปะตะผะตะฝัะฐ <connections>
for (auto connection = nodeConnections.child("connection"); connection; connection = connection.next_sibling("connection")) {
// ะกัะธััะฒะฐะตะผ ะฐััะธะฑัั src
auto src = connection.attribute("src");
if (!src) {
// ะััะธะฑัั src ะฝะต ะฝะฐะนะดะตะฝ. ะะฐะฟะธัะตะผ ะฟัะตะดัะฟัะตะถะดะตะฝะธะต ะฒ ะปะพะณ
logger->Log(LogLevel::Warning,
u8"ะฃ ัะปะตะผะตะฝัะฐ <connection> ะฝะต ะฝะฐะนะดะตะฝ ะฐััะธะฑัั src");
// ะัะพะธะณะฝะพัะธััะตะผ ัะตะบััะนะธ ัะปะตะผะตะฝั ะธ ะฟะตัะตะนะดัะผ ะบ ัะปะตะดัััะตะผั ัะปะตะผะตะฝัั
continue;
}
// ะกัะธััะฒะฐะตะผ ะฐััะธะฑัั dst
auto dst = connection.attribute("dst");
if (!dst) {
// ะััะธะฑัั dst ะฝะต ะฝะฐะนะดะตะฝ. ะะฐะฟะธัะตะผ ะฟัะตะดัะฟัะตะถะดะตะฝะธะต ะฒ ะปะพะณ
logger->Log(LogLevel::Warning,
u8"ะฃ ัะปะตะผะตะฝัะฐ <connection> ะฝะต ะฝะฐะนะดะตะฝ ะฐััะธะฑัั dst");
// ะัะพะธะณะฝะพัะธััะตะผ ัะตะบััะนะธ ัะปะตะผะตะฝั ะธ ะฟะตัะตะนะดัะผ ะบ ัะปะตะดัััะตะผั ัะปะตะผะตะฝัั
continue;
}
// ะกัะธััะฒะฐะตะผ ะฐััะธะฑัั predicat
auto predicat = connection.attribute("predicat");
if (!predicat) {
// ะััะธะฑัั predicat ะฝะต ะฝะฐะนะดะตะฝ. ะะฐะฟะธัะตะผ ะฟัะตะดัะฟัะตะถะดะตะฝะธะต ะฒ ะปะพะณ
logger->Log(LogLevel::Warning,
u8"ะฃ ัะปะตะผะตะฝัะฐ <connection> ะฝะต ะฝะฐะนะดะตะฝ ะฐััะธะฑัั predicat");
// ะัะพะธะณะฝะพัะธััะตะผ ัะตะบััะนะธ ัะปะตะผะตะฝั ะธ ะฟะตัะตะนะดัะผ ะบ ัะปะตะดัััะตะผั ัะปะตะผะตะฝัั
continue;
}
// ะะพะฑะฐะฒะปัะตะผ ัะพะตะดะธะฝะตะฝะธะต ะบ ัะฟะธัะบั ัะพะตะดะธะฝะตะฝะธะน.
// ะัะตะดะธะบะฐั - ััะพ ััะฝะบัะธั ััะฐะฒะฝะตะฝะธั ัะธัะปะฐ ั ะทะฐะดะฐะฝะฝัะผ ะฒ ะฐััะธะฑััะต predicat.
// ะขะต ะตัะปะธ ะฟะฐัะฐะผะตัั ะฟัะตะดะธะบะฐัะฐ ัะฐะตะฝ 0, ัะพ ะตัะปะธ ะฒัะทะฒะฐัั ะดะฐะฝะฝัะน ะฟัะตะดะธะบะฐั,
// ะฟะตัะตะดะฐะฒ ะฒ ะฝะตะณะพ 0, ัะพ ะฟะพะปััะธะผ ture.
// ะัะตะดะธะบะฐัั ะฟะพะฝะฐะดะฐะฑัััั ะฟัะธ ั
ะพะถะดะตะฝะธะธ ะฟะพ ะดะตัะตะฒั
m_connections.emplace_back(src.as_int(), dst.as_int(),
[predicat=predicat.as_int()] (const int value) -> bool
{
return value == predicat;
});
}
logger->Log(LogLevel::Info, u8"ะญะบัะฟะตััะฝะฐั ัะธััะตะผะฐ ะทะฐะณััะถะตะฝะฐ");
}
}
|
[
"andreew.12.87@gmail.com"
] |
andreew.12.87@gmail.com
|
be9557e78bc46f61f20e3cb66096cf1cb6d44901
|
cf4876d97646702a89e10bf9c59cd071aba2852b
|
/src/controller_JIK.h
|
55595e12b02a8cf071734a89382364280cfea182
|
[] |
no_license
|
rbackman/odeapp
|
1d269625bd3f1b8edb473586274e64349a48caf0
|
058aedb4dc50a387f1b9c5195ef6f10e3fa3818f
|
refs/heads/main
| 2023-06-20T15:55:01.810361
| 2021-07-17T02:31:31
| 2021-07-17T02:31:31
| 386,815,549
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 973
|
h
|
#pragma once
#include "controller.h"
#include "common.h"
#include <gsim/gs_matn.h>
//this controller is responsible for solving the analytical ik to achieve the root and foot positions as close as possible
//
class IkBody;
class KnScene;
class JIKController : public Controller
{
public:
JIKController(ODEHuman* human);
~JIKController(void);
bool evaluate();
void setRoot(GsVec p);
void setLeft(GsVec p);
void setRight(GsVec p);
void solveIK(SnManipulator* manip,ODEJoint* endJoint, ODEJoint* baseJoint);
/*
void setRightY(float y);
void setLeftY(float y);
void setHeight(float h);
void setRightVisible(bool vis);
void setLeftVisible(bool vis);
void setRootVisible(bool vis);
*/
void matchIK();
private:
GsMatn J,Jt,JJt,JJTPG,JJt_inv,j_plus, Idt;
GsMatn eff,theta;
int n,m;
bool manual;
GsVec rootStart;
GsVec rootOffset;
SnManipulator* rootManip;
SnManipulator* leftManip;
SnManipulator* rightManip;
void makeIK();
//stuff
};
|
[
"rbackman07@gmail.com"
] |
rbackman07@gmail.com
|
5e7044c3378aadd8b70110ac3694d321ccf2043c
|
49f88ff91aa582e1a9d5ae5a7014f5c07eab7503
|
/gen/third_party/perfetto/protos/perfetto/trace/ftrace/sched_process_exit.pbzero.cc
|
09ace1a3abeb3c06288dc3cf179382fe34834a98
|
[] |
no_license
|
AoEiuV020/kiwibrowser-arm64
|
b6c719b5f35d65906ae08503ec32f6775c9bb048
|
ae7383776e0978b945e85e54242b4e3f7b930284
|
refs/heads/main
| 2023-06-01T21:09:33.928929
| 2021-06-22T15:56:53
| 2021-06-22T15:56:53
| 379,186,747
| 0
| 1
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,267
|
cc
|
// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
#include "perfetto/trace/ftrace/sched_process_exit.pbzero.h"
namespace {
static const ::protozero::ProtoFieldDescriptor kInvalidField = {"", ::protozero::ProtoFieldDescriptor::Type::TYPE_INVALID, 0, false};
}
namespace perfetto {
namespace protos {
namespace pbzero {
static const ::protozero::ProtoFieldDescriptor kFields_SchedProcessExitFtraceEvent[] = {
{"comm", ::protozero::ProtoFieldDescriptor::Type::TYPE_STRING, 1, 0},
{"pid", ::protozero::ProtoFieldDescriptor::Type::TYPE_INT32, 2, 0},
{"tgid", ::protozero::ProtoFieldDescriptor::Type::TYPE_INT32, 3, 0},
{"prio", ::protozero::ProtoFieldDescriptor::Type::TYPE_INT32, 4, 0},
};
const ::protozero::ProtoFieldDescriptor* SchedProcessExitFtraceEvent::GetFieldDescriptor(uint32_t field_id) {
switch (field_id) {
case kCommFieldNumber:
return &kFields_SchedProcessExitFtraceEvent[0];
case kPidFieldNumber:
return &kFields_SchedProcessExitFtraceEvent[1];
case kTgidFieldNumber:
return &kFields_SchedProcessExitFtraceEvent[2];
case kPrioFieldNumber:
return &kFields_SchedProcessExitFtraceEvent[3];
default:
return &kInvalidField;
}
}
} // Namespace.
} // Namespace.
} // Namespace.
|
[
"aoeiuv020@gmail.com"
] |
aoeiuv020@gmail.com
|
c36bacf262eed184c7cb75b1c582db3dbeb839c4
|
73dbb57d8eece4d364305f062b337d84f481eb4b
|
/horario.h
|
3a883e27e4bb21297e6eb4fc8df13dbfe533cd20
|
[] |
no_license
|
OmarGard/QtProyect
|
ef1a535c58ebffc001a14225eedbd8a7b4e8b84d
|
beb79fc84f7d61ee9e23fb46f4ae0c6b124c39ab
|
refs/heads/master
| 2020-04-07T01:41:10.922599
| 2018-11-17T03:49:36
| 2018-11-17T03:49:36
| 157,948,185
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 246
|
h
|
#ifndef HORARIO_H
#define HORARIO_H
class Horario
{
private:
int inicio;
int fin;
public:
Horario();
Horario(int,int);
int getHora(){return inicio;}
int getMinutos(){return fin;}
};
#endif // HORARIO_H
|
[
"noreply@github.com"
] |
OmarGard.noreply@github.com
|
ad19aa05a8f0c384d25590db27f7cf41915fa688
|
9030ce2789a58888904d0c50c21591632eddffd7
|
/SDK/ARKSurvivalEvolved_Dimorph_Character_BP_Aberrant_parameters.hpp
|
8bcf207f6bba5e77c03a80af773ede4f778f4f25
|
[
"MIT"
] |
permissive
|
2bite/ARK-SDK
|
8ce93f504b2e3bd4f8e7ced184980b13f127b7bf
|
ce1f4906ccf82ed38518558c0163c4f92f5f7b14
|
refs/heads/master
| 2022-09-19T06:28:20.076298
| 2022-09-03T17:21:00
| 2022-09-03T17:21:00
| 232,411,353
| 14
| 5
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 949
|
hpp
|
#pragma once
// ARKSurvivalEvolved (332.8) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "ARKSurvivalEvolved_Dimorph_Character_BP_Aberrant_classes.hpp"
namespace sdk
{
//---------------------------------------------------------------------------
//Parameters
//---------------------------------------------------------------------------
// Function Dimorph_Character_BP_Aberrant.Dimorph_Character_BP_Aberrant_C.UserConstructionScript
struct ADimorph_Character_BP_Aberrant_C_UserConstructionScript_Params
{
};
// Function Dimorph_Character_BP_Aberrant.Dimorph_Character_BP_Aberrant_C.ExecuteUbergraph_Dimorph_Character_BP_Aberrant
struct ADimorph_Character_BP_Aberrant_C_ExecuteUbergraph_Dimorph_Character_BP_Aberrant_Params
{
int EntryPoint; // (Parm, ZeroConstructor, IsPlainOldData)
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
[
"sergey.2bite@gmail.com"
] |
sergey.2bite@gmail.com
|
dff30ad36f1166116bb82691df678320feeb29f7
|
86a6846646037abe9618cae7bc0248f2d9c08020
|
/exam/repository.cpp
|
5d37442d8955d7748e71018396df7b36aa3b5c2b
|
[] |
no_license
|
andidh/OOP
|
5dac173924137d94505b5343f12399a5bfe77329
|
ef8510874a462c7dafa7445a8866b75ac6879d42
|
refs/heads/master
| 2020-04-06T03:41:16.021410
| 2016-06-19T17:58:14
| 2016-06-19T17:58:14
| 52,655,675
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,802
|
cpp
|
#include "repository.h"
#include <string>
#include <algorithm>
Repository::Repository(const string& file) : file{file}
{
this->loadFromFile();
}
void Repository::removeFile(Source &s){
this->files.erase(remove(files.begin(), files.end(), s), files.end());
notify();
}
void Repository::reviseFile(const string& file,const string &name) {
for(auto it = files.begin(); it != files.end(); it++) {
if( (*it).getName() == file){
(*it).changeStatus("revised");
(*it).changeReviewer(name);
}
}
notify();
}
Repository::~Repository() {
this->writeToFile();
}
//------------------------------------------------
void Repository::loadFromFile() {
ifstream f(file);
string line;
while(getline(f, line)){
stringstream ss(line);
vector<string> tokens;
string token;
while(getline(ss, token, ','))
tokens.push_back(token);
progs.push_back(Programmer(tokens[0], stoi(tokens[1])));
}
f.close();
f.open("/Users/AndiD/Documents/C++/exam/source.txt");
while(getline(f, line)){
stringstream ss(line);
vector<string> tokens;
string token;
while(getline(ss, token ,','))
tokens.push_back(token);
files.push_back(Source(tokens[0], tokens[1], tokens[2], tokens[3]));
}
f.close();
this->sortData();
notify();
}
void Repository::sortData() {
sort(files.begin(), files.end(), [](const Source& a,const Source& b){
return a.getName() < b.getName();
});
}
void Repository::writeToFile(){
ofstream f("/Users/AndiD/Documents/C++/exam/source.txt");
for(auto it : files)
f<<it.getName()<<","<<it.getStatus()<<","<<it.getCreator()<<","<<it.getReviewer()<<"\n";
f.close();
}
|
[
"andi.deh30@icloud.com"
] |
andi.deh30@icloud.com
|
403a204ffd461b782e7a43fe1243ff5b71db04e2
|
322edfff463a328adfa8e418f8f2d5f03b990715
|
/src/comm-device-interface/op20.cpp
|
91c594083e83961999ff66726b370019fedb9127
|
[] |
no_license
|
DowJhob/Evo-live-map
|
123b4f56a40537311c4c7dbe717de2d293d069bb
|
c764bc2fa79c648dfe435e69a48f053b32590c53
|
refs/heads/master
| 2023-08-19T01:51:25.030081
| 2022-06-11T11:32:33
| 2022-06-11T11:32:33
| 155,981,294
| 7
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 5,454
|
cpp
|
#include "op20.h"
OP20::OP20(QString dllName, QString DeviceDesc, QString DeviceUniqueID) : j2534_interface(dllName, DeviceDesc, DeviceUniqueID)
{
//devType = deviceType::OP20;
//qDebug() << "OP20" << DeviceUniqueID;
QThread *this_thread = new QThread();
QObject::connect(this_thread, &QThread::started, this, [this](){
pollTimer = new QTimer(this);
QObject::connect(pollTimer, &QTimer::timeout, this, [this](){
QByteArray a = readWB();
if (a.size() > 0)
emit readyRead(a);
});
}
);
//connect(this_thread, &QThread::started, this, &controller::loop, Qt::QueuedConnection);
QObject::connect(this, &OP20::destroyed, this_thread, &QThread::quit); // ะะพะณะดะฐ ัะดะฐะปะธะผ ะพะฑัะตะบั ะพััะฐะฝะพะฒะธะผ ะฟะพัะพะบ
QObject::connect(this_thread, &QThread::finished, this_thread, &QThread::deleteLater); // ะะพะณะดะฐ ะพััะฐะฝะพะฒะธะผ ะฟะพัะพะบ ัะดะฐะปะธะผ ะตะณะพ
moveToThread(this_thread);
this_thread->start();
}
OP20::~OP20()
{
}
bool OP20::isClosed()
{
if (chanID_INNO == 0)
return true;
else
return false;
}
bool OP20::openWB(uint baudRate)
{
//qDebug() << "==================== OP20:openWB ==================================" << j2534->lastErrorString();
if (isNotUse())
if (j2534->PassThruOpen(nullptr, &devID)) // Get devID
{
qDebug() << "==================== OP20:openWB::PassThruOpen ==================================" << j2534->lastErrorString();
return false;
}
setUse();
//qDebug() << "==================== OP20:openWB3 ==================================" << j2534->lastErrorString();
// try to connect to the specific channel we would like to use
//
// in this case, it is the 2.5mm jack on the Openport 2.0 which can be used as
// a RS-232 voltage level receive only input. the Innovate MTS bus
// can be used this way, as it is 19200 baud, N,8,1 serial and transmits continuously
// without any polling needed.
//
// note that the ISO9141_NO_CHECKSUM connection flag is used to avoid requiring the data
// to have valid ISO9141 checksums (it doesn't)
qDebug() << "==================== OP20:openWB::PassThruConnect before ==================================" << j2534->lastErrorString() << "devID" << devID << "chanID_INNO" << chanID_INNO;
if (chanID_INNO == 0)
if (j2534->PassThruConnect(devID, Protocol::ISO9141_INNO, ConnectFlag::ISO9141NoChecksum, baudRate, &chanID_INNO))
{
qDebug() << "==================== OP20:openWB::PassThruConnect after ==================================" << j2534->lastErrorString() << "devID" << devID << "chanID_INNO" << chanID_INNO;
return false;
}
qDebug() << "==================== OP20:openWB::PassThruConnect2 ==================================" << "devID" << devID << "chanID_INNO" << chanID_INNO;
// all J2534 channels need filters in order to receive anything at all
//
// in this case, we simply create a "pass all" filter so that we can see
// everything unfiltered in the raw stream
rxmsg.setProtocolId(Protocol::ISO9141_INNO);
rxmsg.m_rxStatus = 0;
rxmsg.m_txFlags = 0;
rxmsg.m_timestamp = 0;
rxmsg.m_dataSize = 1;
rxmsg.m_extraDataIndex = 0;
msgMask = msgPattern = rxmsg;
msgMask.m_data[0] = 0; // mask the first byte to 0
msgPattern.m_data[0] = 0; // match it with 0 (i.e. pass everything)
if (j2534->PassThruStartMsgFilter(chanID_INNO, PassThru::PassFilter, &msgMask, &msgPattern, NULL, &msgId))
{
qDebug() << "==================== OP20:openWB::PassThruStartMsgFilter ==================================" << j2534->lastErrorString();
return false;
}
return true;
}
bool OP20::connectWB(uint baudRate)
{
return true;
}
bool OP20::closeWB()
{
qDebug() << "\n==================== OP20::closeWB ==================================" << "chanID_INNO" << chanID_INNO;
if (j2534->PassThruDisconnect(chanID_INNO))
{
qDebug() << "==================== OP20:closeWB::PassThruDisconnect ==================================" << j2534->lastErrorString();
}
resetUse();
if(countUSE <= 0) // ะตัะปะธ ะฟะพัะปะตะดะฝะธะน ัะพ ะทะฐะบััะฒะฐะตะผ
{
countUSE = 0; // ะฝะฐ ะฒััะบะธะน ัะปััะฐะน
j2534->PassThruClose(devID);
chanID_INNO = 0;
}
chanID_INNO = 0;
return true;
}
QByteArray OP20::readWB()
{
QByteArray a;
numRxMsg = 1;
do
{
j2534->PassThruReadMsgs(chanID_INNO, &rxmsg, &numRxMsg, 140);
qDebug() << "==================== OP20:readWB ==================================" << j2534->lastErrorString() << chanID_INNO;
a.append(QByteArray((char*)rx_msg.m_data, rx_msg.m_dataSize));
// qDebug()<< "j2534_interface::read " << "rx_msg.m_rxStatus" << rx_msg.m_rxStatus
// << "rx_msg.m_dataSize" << rx_msg.m_dataSize
// << "time" << QString::number( tt.nsecsElapsed()/1000000.0)
// << "NumMsgs=" << NumMsgs
// //<< "rx_msg[0].data" << QByteArray((char*)rx_msg[0].m_data, 4).toHex(':')
// ;
}
while(rx_msg.m_rxStatus == Message::RxStatusBit::InStartOfMessage);
//qDebug() << "OP20::read: readWB" << a << "\n\n";
//
return a;
}
|
[
"eulle@ya.ru"
] |
eulle@ya.ru
|
3eee329f40979980712a83962cb83f54b6e2bc6d
|
fc2ee2fe737e7932a004bac94f0cff4caf95f495
|
/sources/FieldDoctor.hpp
|
10579c220c301333557563d63b25d28fcdb626c8
|
[] |
no_license
|
nofar88/pandemic-b
|
9d042f87681723124a4992c915d2d29a6cdb31b9
|
12b4be7398b863a8b3f98b759ee55af5cfa878f2
|
refs/heads/main
| 2023-04-25T04:20:50.277285
| 2021-05-17T18:33:01
| 2021-05-17T18:33:01
| 368,283,390
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 365
|
hpp
|
#ifndef DEMO1_CPP_FIELDDOCTOR_HPP
#define DEMO1_CPP_FIELDDOCTOR_HPP
#include "Player.hpp"
namespace pandemic {
class FieldDoctor: public Player {
public:
FieldDoctor(Board& board, City city): Player(board, city){};
Player& treat(City) override;
string role() override;
};
}
#endif //DEMO1_CPP_FIELDDOCTOR_HPP
|
[
"noreply@github.com"
] |
nofar88.noreply@github.com
|
d16e72eb62b0ea6a528110a7746777564d3b9b85
|
b958286bb016a56f5ddff5514f38fbd29f3e9072
|
/include/ublox/message/LogInfoPoll.h
|
72f0b757de4e7a14d0cb8d72178f8e282f6ac488
|
[] |
no_license
|
yxw027/cc.ublox.generated
|
abdda838945777a498f433b0d9624a567ab1ea80
|
a8bf468281d2d06e32d3e029c40bc6d38e4a34de
|
refs/heads/master
| 2021-01-14T23:03:20.722801
| 2020-02-20T06:24:46
| 2020-02-20T06:24:46
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,376
|
h
|
// Generated by commsdsl2comms v3.3.2
/// @file
/// @brief Contains definition of <b>"LOG-INFO (Poll)"</b> message and its fields.
#pragma once
#include <tuple>
#include "comms/MessageBase.h"
#include "ublox/MsgId.h"
#include "ublox/message/LogInfoPollCommon.h"
#include "ublox/options/DefaultOptions.h"
namespace ublox
{
namespace message
{
/// @brief Fields of @ref LogInfoPoll.
/// @tparam TOpt Extra options
/// @see @ref LogInfoPoll
/// @headerfile "ublox/message/LogInfoPoll.h"
template <typename TOpt = ublox::options::DefaultOptions>
struct LogInfoPollFields
{
/// @brief All the fields bundled in std::tuple.
using All = std::tuple<
>;
};
/// @brief Definition of <b>"LOG-INFO (Poll)"</b> message class.
/// @details
/// See @ref LogInfoPollFields for definition of the fields this message contains.
/// @tparam TMsgBase Base (interface) class.
/// @tparam TOpt Extra options
/// @headerfile "ublox/message/LogInfoPoll.h"
template <typename TMsgBase, typename TOpt = ublox::options::DefaultOptions>
class LogInfoPoll : public
comms::MessageBase<
TMsgBase,
typename TOpt::message::LogInfoPoll,
comms::option::def::StaticNumIdImpl<ublox::MsgId_LogInfo>,
comms::option::def::FieldsImpl<typename LogInfoPollFields<TOpt>::All>,
comms::option::def::MsgType<LogInfoPoll<TMsgBase, TOpt> >,
comms::option::def::HasName
>
{
// Redefinition of the base class type
using Base =
comms::MessageBase<
TMsgBase,
typename TOpt::message::LogInfoPoll,
comms::option::def::StaticNumIdImpl<ublox::MsgId_LogInfo>,
comms::option::def::FieldsImpl<typename LogInfoPollFields<TOpt>::All>,
comms::option::def::MsgType<LogInfoPoll<TMsgBase, TOpt> >,
comms::option::def::HasName
>;
public:
// Compile time check for serialisation length.
static const std::size_t MsgMinLen = Base::doMinLength();
static const std::size_t MsgMaxLen = Base::doMaxLength();
static_assert(MsgMinLen == 0U, "Unexpected min serialisation length");
static_assert(MsgMaxLen == 0U, "Unexpected max serialisation length");
/// @brief Name of the message.
static const char* doName()
{
return ublox::message::LogInfoPollCommon::name();
}
};
} // namespace message
} // namespace ublox
|
[
"arobenko@gmail.com"
] |
arobenko@gmail.com
|
9e945bec14a0531a73af145394168a7536d4cebe
|
155bb920a8fc8fb3a0a545e923952e902e4ef3df
|
/XEngine.Core/Source/XEngine.Core.GeometryResource.h
|
53a85766134ff027a4e9f00fb907ca381c1c258e
|
[] |
no_license
|
rbmkp4800/XEngine
|
2035d0c7b81bc291b42e55e7ea91af1f6a86e8bc
|
f689d20d8deffd48399ba0d86432caf644235992
|
refs/heads/master
| 2021-01-01T15:59:43.013938
| 2019-03-10T13:14:53
| 2019-03-10T19:24:53
| 30,755,730
| 0
| 1
| null | 2020-07-13T21:23:33
| 2015-02-13T12:36:29
|
C++
|
UTF-8
|
C++
| false
| false
| 2,007
|
h
|
#pragma once
#include <XLib.Types.h>
#include <XLib.NonCopyable.h>
#include <XEngine.Render.Base.h>
#include <XEngine.Render.Scene.h>
#include "XEngine.Core.ResourceCache.h"
namespace XEngine::Core
{
using GeometryResourceUID = uint64;
using GeometryResourceHandle = uint16;
class GeometryResource : public XLib::NonCopyable
{
private:
uint32 vertexCount = 0;
uint32 indexCount = 0;
Render::BufferHandle buffer = Render::BufferHandle(0);
uint8 vertexStride = 0;
bool indexIs32Bit = false;
public:
GeometryResource() = default;
~GeometryResource() = default;
// NOTE: temporary
bool createFromFile(const char* filename);
void createCube();
void createPlane_texture();
void createPlane_tangentTexture();
void createCubicSphere(uint32 detalizationLevel);
inline Render::GeometryDesc getGeometryDesc() const
{
Render::GeometryDesc result;
result.vertexBufferHandle = buffer;
result.indexBufferHandle = buffer;
result.vertexDataOffset = 0;
result.indexDataOffset = vertexCount * vertexStride;
result.vertexDataSize = result.indexDataOffset;
result.indexCount = indexCount;
result.vertexStride = vertexStride;
result.indexIs32Bit = indexIs32Bit;
return result;
}
public: // creation
enum class CreationType : uint8;
struct CreationArgs;
class CreationTask;
static bool Create(const CreationArgs& args, CreationTask& task);
};
enum class GeometryResource::CreationType : uint8
{
None = 0,
Cube,
CubicSphere,
FromFile,
};
struct GeometryResource::CreationArgs
{
CreationType type = CreationType::None;
union
{
struct
{
uint16 detalization;
} cubicSphere;
struct
{
char filename[32];
} fromFile;
};
};
class GeometryResource::CreationTask : public XLib::NonCopyable
{
private:
public:
CreationTask() = default;
~CreationTask();
bool cancel();
};
//using GeometryResourceCache = ResourceCache<
// GeometryResourceUID, GeometryResourceHandle, GeometryResource>;
}
|
[
"rbmkp4800@gmail.com"
] |
rbmkp4800@gmail.com
|
cd6b10381de8c92142db8de3c46cd83932e3449a
|
27bb5ed9eb1011c581cdb76d96979a7a9acd63ba
|
/aws-cpp-sdk-ec2/source/model/ReservedInstancesOffering.cpp
|
6a82ce3490506889624d94c80d15a508f39bfed1
|
[
"Apache-2.0",
"JSON",
"MIT"
] |
permissive
|
exoscale/aws-sdk-cpp
|
5394055f0876a0dafe3c49bf8e804d3ddf3ccc54
|
0876431920136cf638e1748d504d604c909bb596
|
refs/heads/master
| 2023-08-25T11:55:20.271984
| 2017-05-05T17:32:25
| 2017-05-05T17:32:25
| 90,744,509
| 0
| 0
| null | 2017-05-09T12:43:30
| 2017-05-09T12:43:30
| null |
UTF-8
|
C++
| false
| false
| 13,634
|
cpp
|
๏ปฟ/*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/ec2/model/ReservedInstancesOffering.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>
#include <utility>
using namespace Aws::Utils::Xml;
using namespace Aws::Utils;
namespace Aws
{
namespace EC2
{
namespace Model
{
ReservedInstancesOffering::ReservedInstancesOffering() :
m_reservedInstancesOfferingIdHasBeenSet(false),
m_instanceType(InstanceType::NOT_SET),
m_instanceTypeHasBeenSet(false),
m_availabilityZoneHasBeenSet(false),
m_duration(0),
m_durationHasBeenSet(false),
m_usagePrice(0.0),
m_usagePriceHasBeenSet(false),
m_fixedPrice(0.0),
m_fixedPriceHasBeenSet(false),
m_productDescription(RIProductDescription::NOT_SET),
m_productDescriptionHasBeenSet(false),
m_instanceTenancy(Tenancy::NOT_SET),
m_instanceTenancyHasBeenSet(false),
m_currencyCode(CurrencyCodeValues::NOT_SET),
m_currencyCodeHasBeenSet(false),
m_offeringType(OfferingTypeValues::NOT_SET),
m_offeringTypeHasBeenSet(false),
m_recurringChargesHasBeenSet(false),
m_marketplace(false),
m_marketplaceHasBeenSet(false),
m_pricingDetailsHasBeenSet(false),
m_offeringClass(OfferingClassType::NOT_SET),
m_offeringClassHasBeenSet(false),
m_scope(Scope::NOT_SET),
m_scopeHasBeenSet(false)
{
}
ReservedInstancesOffering::ReservedInstancesOffering(const XmlNode& xmlNode) :
m_reservedInstancesOfferingIdHasBeenSet(false),
m_instanceType(InstanceType::NOT_SET),
m_instanceTypeHasBeenSet(false),
m_availabilityZoneHasBeenSet(false),
m_duration(0),
m_durationHasBeenSet(false),
m_usagePrice(0.0),
m_usagePriceHasBeenSet(false),
m_fixedPrice(0.0),
m_fixedPriceHasBeenSet(false),
m_productDescription(RIProductDescription::NOT_SET),
m_productDescriptionHasBeenSet(false),
m_instanceTenancy(Tenancy::NOT_SET),
m_instanceTenancyHasBeenSet(false),
m_currencyCode(CurrencyCodeValues::NOT_SET),
m_currencyCodeHasBeenSet(false),
m_offeringType(OfferingTypeValues::NOT_SET),
m_offeringTypeHasBeenSet(false),
m_recurringChargesHasBeenSet(false),
m_marketplace(false),
m_marketplaceHasBeenSet(false),
m_pricingDetailsHasBeenSet(false),
m_offeringClass(OfferingClassType::NOT_SET),
m_offeringClassHasBeenSet(false),
m_scope(Scope::NOT_SET),
m_scopeHasBeenSet(false)
{
*this = xmlNode;
}
ReservedInstancesOffering& ReservedInstancesOffering::operator =(const XmlNode& xmlNode)
{
XmlNode resultNode = xmlNode;
if(!resultNode.IsNull())
{
XmlNode reservedInstancesOfferingIdNode = resultNode.FirstChild("reservedInstancesOfferingId");
if(!reservedInstancesOfferingIdNode.IsNull())
{
m_reservedInstancesOfferingId = StringUtils::Trim(reservedInstancesOfferingIdNode.GetText().c_str());
m_reservedInstancesOfferingIdHasBeenSet = true;
}
XmlNode instanceTypeNode = resultNode.FirstChild("instanceType");
if(!instanceTypeNode.IsNull())
{
m_instanceType = InstanceTypeMapper::GetInstanceTypeForName(StringUtils::Trim(instanceTypeNode.GetText().c_str()).c_str());
m_instanceTypeHasBeenSet = true;
}
XmlNode availabilityZoneNode = resultNode.FirstChild("availabilityZone");
if(!availabilityZoneNode.IsNull())
{
m_availabilityZone = StringUtils::Trim(availabilityZoneNode.GetText().c_str());
m_availabilityZoneHasBeenSet = true;
}
XmlNode durationNode = resultNode.FirstChild("duration");
if(!durationNode.IsNull())
{
m_duration = StringUtils::ConvertToInt64(StringUtils::Trim(durationNode.GetText().c_str()).c_str());
m_durationHasBeenSet = true;
}
XmlNode usagePriceNode = resultNode.FirstChild("usagePrice");
if(!usagePriceNode.IsNull())
{
m_usagePrice = StringUtils::ConvertToDouble(StringUtils::Trim(usagePriceNode.GetText().c_str()).c_str());
m_usagePriceHasBeenSet = true;
}
XmlNode fixedPriceNode = resultNode.FirstChild("fixedPrice");
if(!fixedPriceNode.IsNull())
{
m_fixedPrice = StringUtils::ConvertToDouble(StringUtils::Trim(fixedPriceNode.GetText().c_str()).c_str());
m_fixedPriceHasBeenSet = true;
}
XmlNode productDescriptionNode = resultNode.FirstChild("productDescription");
if(!productDescriptionNode.IsNull())
{
m_productDescription = RIProductDescriptionMapper::GetRIProductDescriptionForName(StringUtils::Trim(productDescriptionNode.GetText().c_str()).c_str());
m_productDescriptionHasBeenSet = true;
}
XmlNode instanceTenancyNode = resultNode.FirstChild("instanceTenancy");
if(!instanceTenancyNode.IsNull())
{
m_instanceTenancy = TenancyMapper::GetTenancyForName(StringUtils::Trim(instanceTenancyNode.GetText().c_str()).c_str());
m_instanceTenancyHasBeenSet = true;
}
XmlNode currencyCodeNode = resultNode.FirstChild("currencyCode");
if(!currencyCodeNode.IsNull())
{
m_currencyCode = CurrencyCodeValuesMapper::GetCurrencyCodeValuesForName(StringUtils::Trim(currencyCodeNode.GetText().c_str()).c_str());
m_currencyCodeHasBeenSet = true;
}
XmlNode offeringTypeNode = resultNode.FirstChild("offeringType");
if(!offeringTypeNode.IsNull())
{
m_offeringType = OfferingTypeValuesMapper::GetOfferingTypeValuesForName(StringUtils::Trim(offeringTypeNode.GetText().c_str()).c_str());
m_offeringTypeHasBeenSet = true;
}
XmlNode recurringChargesNode = resultNode.FirstChild("recurringCharges");
if(!recurringChargesNode.IsNull())
{
XmlNode recurringChargesMember = recurringChargesNode.FirstChild("item");
while(!recurringChargesMember.IsNull())
{
m_recurringCharges.push_back(recurringChargesMember);
recurringChargesMember = recurringChargesMember.NextNode("item");
}
m_recurringChargesHasBeenSet = true;
}
XmlNode marketplaceNode = resultNode.FirstChild("marketplace");
if(!marketplaceNode.IsNull())
{
m_marketplace = StringUtils::ConvertToBool(StringUtils::Trim(marketplaceNode.GetText().c_str()).c_str());
m_marketplaceHasBeenSet = true;
}
XmlNode pricingDetailsNode = resultNode.FirstChild("pricingDetailsSet");
if(!pricingDetailsNode.IsNull())
{
XmlNode pricingDetailsMember = pricingDetailsNode.FirstChild("item");
while(!pricingDetailsMember.IsNull())
{
m_pricingDetails.push_back(pricingDetailsMember);
pricingDetailsMember = pricingDetailsMember.NextNode("item");
}
m_pricingDetailsHasBeenSet = true;
}
XmlNode offeringClassNode = resultNode.FirstChild("offeringClass");
if(!offeringClassNode.IsNull())
{
m_offeringClass = OfferingClassTypeMapper::GetOfferingClassTypeForName(StringUtils::Trim(offeringClassNode.GetText().c_str()).c_str());
m_offeringClassHasBeenSet = true;
}
XmlNode scopeNode = resultNode.FirstChild("scope");
if(!scopeNode.IsNull())
{
m_scope = ScopeMapper::GetScopeForName(StringUtils::Trim(scopeNode.GetText().c_str()).c_str());
m_scopeHasBeenSet = true;
}
}
return *this;
}
void ReservedInstancesOffering::OutputToStream(Aws::OStream& oStream, const char* location, unsigned index, const char* locationValue) const
{
if(m_reservedInstancesOfferingIdHasBeenSet)
{
oStream << location << index << locationValue << ".ReservedInstancesOfferingId=" << StringUtils::URLEncode(m_reservedInstancesOfferingId.c_str()) << "&";
}
if(m_instanceTypeHasBeenSet)
{
oStream << location << index << locationValue << ".InstanceType=" << InstanceTypeMapper::GetNameForInstanceType(m_instanceType) << "&";
}
if(m_availabilityZoneHasBeenSet)
{
oStream << location << index << locationValue << ".AvailabilityZone=" << StringUtils::URLEncode(m_availabilityZone.c_str()) << "&";
}
if(m_durationHasBeenSet)
{
oStream << location << index << locationValue << ".Duration=" << m_duration << "&";
}
if(m_usagePriceHasBeenSet)
{
oStream << location << index << locationValue << ".UsagePrice=" << m_usagePrice << "&";
}
if(m_fixedPriceHasBeenSet)
{
oStream << location << index << locationValue << ".FixedPrice=" << m_fixedPrice << "&";
}
if(m_productDescriptionHasBeenSet)
{
oStream << location << index << locationValue << ".ProductDescription=" << RIProductDescriptionMapper::GetNameForRIProductDescription(m_productDescription) << "&";
}
if(m_instanceTenancyHasBeenSet)
{
oStream << location << index << locationValue << ".InstanceTenancy=" << TenancyMapper::GetNameForTenancy(m_instanceTenancy) << "&";
}
if(m_currencyCodeHasBeenSet)
{
oStream << location << index << locationValue << ".CurrencyCode=" << CurrencyCodeValuesMapper::GetNameForCurrencyCodeValues(m_currencyCode) << "&";
}
if(m_offeringTypeHasBeenSet)
{
oStream << location << index << locationValue << ".OfferingType=" << OfferingTypeValuesMapper::GetNameForOfferingTypeValues(m_offeringType) << "&";
}
if(m_recurringChargesHasBeenSet)
{
unsigned recurringChargesIdx = 1;
for(auto& item : m_recurringCharges)
{
Aws::StringStream recurringChargesSs;
recurringChargesSs << location << index << locationValue << ".RecurringCharges." << recurringChargesIdx++;
item.OutputToStream(oStream, recurringChargesSs.str().c_str());
}
}
if(m_marketplaceHasBeenSet)
{
oStream << location << index << locationValue << ".Marketplace=" << std::boolalpha << m_marketplace << "&";
}
if(m_pricingDetailsHasBeenSet)
{
unsigned pricingDetailsIdx = 1;
for(auto& item : m_pricingDetails)
{
Aws::StringStream pricingDetailsSs;
pricingDetailsSs << location << index << locationValue << ".PricingDetailsSet." << pricingDetailsIdx++;
item.OutputToStream(oStream, pricingDetailsSs.str().c_str());
}
}
if(m_offeringClassHasBeenSet)
{
oStream << location << index << locationValue << ".OfferingClass=" << OfferingClassTypeMapper::GetNameForOfferingClassType(m_offeringClass) << "&";
}
if(m_scopeHasBeenSet)
{
oStream << location << index << locationValue << ".Scope=" << ScopeMapper::GetNameForScope(m_scope) << "&";
}
}
void ReservedInstancesOffering::OutputToStream(Aws::OStream& oStream, const char* location) const
{
if(m_reservedInstancesOfferingIdHasBeenSet)
{
oStream << location << ".ReservedInstancesOfferingId=" << StringUtils::URLEncode(m_reservedInstancesOfferingId.c_str()) << "&";
}
if(m_instanceTypeHasBeenSet)
{
oStream << location << ".InstanceType=" << InstanceTypeMapper::GetNameForInstanceType(m_instanceType) << "&";
}
if(m_availabilityZoneHasBeenSet)
{
oStream << location << ".AvailabilityZone=" << StringUtils::URLEncode(m_availabilityZone.c_str()) << "&";
}
if(m_durationHasBeenSet)
{
oStream << location << ".Duration=" << m_duration << "&";
}
if(m_usagePriceHasBeenSet)
{
oStream << location << ".UsagePrice=" << m_usagePrice << "&";
}
if(m_fixedPriceHasBeenSet)
{
oStream << location << ".FixedPrice=" << m_fixedPrice << "&";
}
if(m_productDescriptionHasBeenSet)
{
oStream << location << ".ProductDescription=" << RIProductDescriptionMapper::GetNameForRIProductDescription(m_productDescription) << "&";
}
if(m_instanceTenancyHasBeenSet)
{
oStream << location << ".InstanceTenancy=" << TenancyMapper::GetNameForTenancy(m_instanceTenancy) << "&";
}
if(m_currencyCodeHasBeenSet)
{
oStream << location << ".CurrencyCode=" << CurrencyCodeValuesMapper::GetNameForCurrencyCodeValues(m_currencyCode) << "&";
}
if(m_offeringTypeHasBeenSet)
{
oStream << location << ".OfferingType=" << OfferingTypeValuesMapper::GetNameForOfferingTypeValues(m_offeringType) << "&";
}
if(m_recurringChargesHasBeenSet)
{
unsigned recurringChargesIdx = 1;
for(auto& item : m_recurringCharges)
{
Aws::StringStream recurringChargesSs;
recurringChargesSs << location << ".RecurringCharges." << recurringChargesIdx++;
item.OutputToStream(oStream, recurringChargesSs.str().c_str());
}
}
if(m_marketplaceHasBeenSet)
{
oStream << location << ".Marketplace=" << std::boolalpha << m_marketplace << "&";
}
if(m_pricingDetailsHasBeenSet)
{
unsigned pricingDetailsIdx = 1;
for(auto& item : m_pricingDetails)
{
Aws::StringStream pricingDetailsSs;
pricingDetailsSs << location << ".PricingDetailsSet." << pricingDetailsIdx++;
item.OutputToStream(oStream, pricingDetailsSs.str().c_str());
}
}
if(m_offeringClassHasBeenSet)
{
oStream << location << ".OfferingClass=" << OfferingClassTypeMapper::GetNameForOfferingClassType(m_offeringClass) << "&";
}
if(m_scopeHasBeenSet)
{
oStream << location << ".Scope=" << ScopeMapper::GetNameForScope(m_scope) << "&";
}
}
} // namespace Model
} // namespace EC2
} // namespace Aws
|
[
"henso@amazon.com"
] |
henso@amazon.com
|
64ed68b8d6785bb0476bc13c35609d2b87c0b4f8
|
22a87fab6bfdd5eb4d0cf39917cc7211b8f0da8d
|
/practice test/1.cpp
|
e23460ccb68088f255440b67cbbd1a48397bb0a8
|
[] |
no_license
|
Artlesbol/Cpp-practice-on-CGplatform
|
8f4338329c4e38a9eb1edb95e4da1ea1d3a16353
|
9262a1d58037d9606d039c9d03c99e63223782f6
|
refs/heads/main
| 2023-02-10T11:29:04.382430
| 2021-01-06T14:19:26
| 2021-01-06T14:19:26
| 320,823,977
| 4
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 540
|
cpp
|
#include <iostream>
using namespace std;
class questiontwo
{
public:
int answer(int sum)
{
if(sum == 1)
{
cout<<" "<<sum;
return sum;
}
else
{
if((sum%2) == 1){
sum=sum*3+1;
cout<<sum<<" ";
return answer(sum);
}
else{
sum>>=1;
cout<<sum<<" ";
return answer(sum);
}
}
}
};
int main()
{
int c ;
cin>>c;
questiontwo question2;
question2.answer(c);
return 0;
}
|
[
"noreply@github.com"
] |
Artlesbol.noreply@github.com
|
26ace993b16b82ff66f7be95c7a58af088b811aa
|
bd80c038d443123c7b46102587e04afc0eeae80f
|
/GCJ2016/BFFs/bff.cpp
|
97bf4c2ce5c90323aebe3abc000853e13cfa4ffa
|
[] |
no_license
|
SiweiYang/CodingChallenge
|
73e0e3a47a7feafef472fea239c4ea37e0af3cc0
|
fb77dcdba597782f0447cbd7a2158fe3694957dc
|
refs/heads/master
| 2022-01-13T06:44:47.866243
| 2019-06-28T11:55:46
| 2019-06-28T11:55:46
| 3,609,562
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,313
|
cpp
|
#include <iostream>
#include <fstream>
#include <string.h>
using namespace std;
int run(int *m, bool *v, int i) {
if (v[i])return i;
v[i] = true;
return run(m, v, m[i]);
}
int count(bool *v, int s) {
int total = 0;
for (int i = 1; i < s + 1; i++) {
if (v[i])total++;
}
return total;
}
int main(int argc, char **argv) {
const char *fn = "sample3.in";
if (argc > 1)fn = argv[1];
ifstream in(fn);
int total_case;
in >> total_case;
for (int i = 1; i < total_case + 1; i++) {
int c_size;
in >> c_size;
int *m = new int[c_size + 1];
for (int j = 0; j < c_size; j++) {
in >> m[j+1];
}
int *mc = (int *)calloc(c_size + 1, sizeof(int));
bool *v = (bool *)calloc(c_size + 1, sizeof(bool));
for (int j = 1; j < c_size + 1; j++) {
v = (bool *)calloc(c_size + 1, sizeof(bool));
int end = run(m, v, j);
if (m[m[end]] == end) {
int c = count(v, c_size) - 1;
if (c > mc[end])mc[end] = c;
}
}
int max_c = 0;
for (int j = 1; j < c_size + 1; j++) {
max_c += mc[j];
}
for (int j = 1; j < c_size + 1; j++) {
v = (bool *)calloc(c_size + 1, sizeof(bool));
int end = run(m, v, j);
if (end != j) {
continue;
}
int c = count(v, c_size);
if (c > max_c)max_c = c;
}
cout << "Case #" << i << ": " << max_c << endl;
}
return 0;
}
|
[
"yangsiwei880813@gmail.com"
] |
yangsiwei880813@gmail.com
|
e1653b072c64c3cb62a871e3305449037644b7b2
|
6736f139a3c166b3dcb6ca655e3c26e4adfd7252
|
/daydream_viewer/app/src/main/jni/renderer.cc
|
1ee10fc6028b7f06f8c5e591fb42f48e600c8079
|
[
"LicenseRef-scancode-warranty-disclaimer",
"Libpng",
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"Apache-2.0"
] |
permissive
|
alexey-odintsov/tango
|
bb67f7b3739884424fbcfc1396f3a51f09e09075
|
3555d1f52e9ac1b078b3304a789a446d92d7ac4c
|
refs/heads/master
| 2021-01-01T19:12:43.266094
| 2017-07-22T08:04:54
| 2017-07-22T08:04:54
| null | 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 17,900
|
cc
|
#include "renderer.h" // NOLINT
#include "shaders.h" // NOLINT
#include "data/file3d.h"
#include <android/log.h>
#include <assert.h>
#include <stdlib.h>
#include <cmath>
#include <random>
namespace {
static const float kReticleDistance = 3.0f;
static const int kCoordsPerVertex = 3;
static const uint64_t kPredictionTimeWithoutVsyncNanos = 50000000;
static const float kAngleLimit = 0.12f;
static const float kPitchLimit = 0.12f;
static const float kYawLimit = 0.12f;
float reticle_vertices_[] = {
-1.f, 1.f, 0.0f,
-1.f, -1.f, 0.0f,
1.f, 1.f, 0.0f,
-1.f, -1.f, 0.0f,
1.f, -1.f, 0.0f,
1.f, 1.f, 0.0f,
};
static std::array<float, 16> MatrixToGLArray(const gvr::Mat4f& matrix) {
std::array<float, 16> result;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
result[j * 4 + i] = matrix.m[i][j];
}
}
return result;
}
static std::array<float, 4> MatrixVectorMul(const gvr::Mat4f& matrix, const std::array<float, 4>& vec) {
std::array<float, 4> result;
for (int i = 0; i < 4; ++i) {
result[i] = 0;
for (int k = 0; k < 4; ++k) {
result[i] += matrix.m[i][k] * vec[k];
}
}
return result;
}
static gvr::Mat4f MatrixMul(const gvr::Mat4f& matrix1, const gvr::Mat4f& matrix2) {
gvr::Mat4f result;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
result.m[i][j] = 0.0f;
for (int k = 0; k < 4; ++k) {
result.m[i][j] += matrix1.m[i][k] * matrix2.m[k][j];
}
}
}
return result;
}
static std::array<float, 3> Vec4ToVec3(const std::array<float, 4>& vec) {
return {vec[0], vec[1], vec[2]};
}
static gvr::Mat4f PerspectiveMatrixFromView(const gvr::Rectf& fov, float z_near, float z_far) {
gvr::Mat4f result;
const float x_left = -std::tan(fov.left * M_PI / 180.0f) * z_near;
const float x_right = std::tan(fov.right * M_PI / 180.0f) * z_near;
const float y_bottom = -std::tan(fov.bottom * M_PI / 180.0f) * z_near;
const float y_top = std::tan(fov.top * M_PI / 180.0f) * z_near;
const float zero = 0.0f;
assert(x_left < x_right && y_bottom < y_top && z_near < z_far && z_near > zero && z_far > zero);
const float X = (2 * z_near) / (x_right - x_left);
const float Y = (2 * z_near) / (y_top - y_bottom);
const float A = (x_right + x_left) / (x_right - x_left);
const float B = (y_top + y_bottom) / (y_top - y_bottom);
const float C = (z_near + z_far) / (z_near - z_far);
const float D = (2 * z_near * z_far) / (z_near - z_far);
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
result.m[i][j] = 0.0f;
}
}
result.m[0][0] = X;
result.m[0][2] = A;
result.m[1][1] = Y;
result.m[1][2] = B;
result.m[2][2] = C;
result.m[2][3] = D;
result.m[3][2] = -1;
return result;
}
static gvr::Rectf ModulateRect(const gvr::Rectf& rect, float width, float height) {
gvr::Rectf result = {rect.left * width, rect.right * width, rect.bottom * height, rect.top * height};
return result;
}
static gvr::Recti CalculatePixelSpaceRect(const gvr::Sizei& texture_size, const gvr::Rectf& texture_rect) {
const float width = static_cast<float>(texture_size.width);
const float height = static_cast<float>(texture_size.height);
const gvr::Rectf rect = ModulateRect(texture_rect, width, height);
const gvr::Recti result = {
static_cast<int>(rect.left), static_cast<int>(rect.right),
static_cast<int>(rect.bottom), static_cast<int>(rect.top)};
return result;
}
static gvr::Sizei HalfPixelCount(const gvr::Sizei& in) {
// Scale each dimension by sqrt(2)/2 ~= 7/10ths.
gvr::Sizei out;
out.width = (7 * in.width) / 10;
out.height = (7 * in.height) / 10;
return out;
}
static gvr::Mat4f ControllerQuatToMatrix(const gvr::ControllerQuat& quat) {
gvr::Mat4f result;
const float x = quat.qx;
const float x2 = quat.qx * quat.qx;
const float y = quat.qy;
const float y2 = quat.qy * quat.qy;
const float z = quat.qz;
const float z2 = quat.qz * quat.qz;
const float w = quat.qw;
const float xy = quat.qx * quat.qy;
const float xz = quat.qx * quat.qz;
const float xw = quat.qx * quat.qw;
const float yz = quat.qy * quat.qz;
const float yw = quat.qy * quat.qw;
const float zw = quat.qz * quat.qw;
const float m11 = 1.0f - 2.0f * y2 - 2.0f * z2;
const float m12 = 2.0f * (xy - zw);
const float m13 = 2.0f * (xz + yw);
const float m21 = 2.0f * (xy + zw);
const float m22 = 1.0f - 2.0f * x2 - 2.0f * z2;
const float m23 = 2.0f * (yz - xw);
const float m31 = 2.0f * (xz - yw);
const float m32 = 2.0f * (yz + xw);
const float m33 = 1.0f - 2.0f * x2 - 2.0f * y2;
return {{{m11, m12, m13, 0.0f},
{m21, m22, m23, 0.0f},
{m31, m32, m33, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}}};
}
} // anonymous namespace
Renderer::Renderer(gvr_context* gvr_context, std::string filename)
: gvr_api_(gvr::GvrApi::WrapNonOwned(gvr_context)),
viewport_left_(gvr_api_->CreateBufferViewport()),
viewport_right_(gvr_api_->CreateBufferViewport()),
reticle_render_size_{128, 128},
gvr_controller_api_(nullptr),
gvr_viewer_type_(gvr_api_->GetViewerType()) {
ResumeControllerApiAsNeeded();
if (gvr_viewer_type_ == GVR_VIEWER_TYPE_CARDBOARD) {
LOGI("Viewer type: CARDBOARD");
} else if (gvr_viewer_type_ == GVR_VIEWER_TYPE_DAYDREAM) {
LOGI("Viewer type: DAYDREAM");
} else {
LOGE("Unexpected viewer type.");
}
oc::File3d io(filename, false);
textured_ = io.GetType() == oc::OBJ;
io.ReadModel(20000, static_meshes_);
}
Renderer::~Renderer() {
}
void Renderer::InitializeGl() {
gvr_api_->InitializeGl();
int index = textured_ ? 0 : 1;
const int vertex_shader = LoadGLShader(GL_VERTEX_SHADER, &kTextureVertexShaders[index]);
const int fragment_shader = LoadGLShader(GL_FRAGMENT_SHADER, &kTextureFragmentShaders[index]);
const int pass_through_shader = LoadGLShader(GL_FRAGMENT_SHADER, &kPassthroughFragmentShaders[0]);
const int reticle_vertex_shader = LoadGLShader(GL_VERTEX_SHADER, &kReticleVertexShaders[0]);
const int reticle_fragment_shader = LoadGLShader(GL_FRAGMENT_SHADER, &kReticleFragmentShaders[0]);
model_program_ = glCreateProgram();
glAttachShader(model_program_, vertex_shader);
glAttachShader(model_program_, fragment_shader);
glLinkProgram(model_program_);
glUseProgram(model_program_);
model_position_param_ = glGetAttribLocation(model_program_, "a_Position");
if (textured_)
model_uv_param_ = glGetAttribLocation(model_program_, "a_UV");
else
model_uv_param_ = glGetAttribLocation(model_program_, "a_Color");
model_modelview_projection_param_ = glGetUniformLocation(model_program_, "u_MVP");
model_translatex_param_ = glGetUniformLocation(model_program_, "u_X");
model_translatey_param_ = glGetUniformLocation(model_program_, "u_Y");
model_translatez_param_ = glGetUniformLocation(model_program_, "u_Z");
reticle_program_ = glCreateProgram();
glAttachShader(reticle_program_, reticle_vertex_shader);
glAttachShader(reticle_program_, reticle_fragment_shader);
glLinkProgram(reticle_program_);
glUseProgram(reticle_program_);
reticle_position_param_ = glGetAttribLocation(reticle_program_, "a_Position");
reticle_modelview_projection_param_ = glGetUniformLocation(reticle_program_, "u_MVP");
// Object first appears directly in front of user.
model_model_ = {{{100.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 100.0f, 0.0f, 0.0},
{0.0f, 0.0f, 100.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}}};
const float rs = 0.04f; // Reticle scale.
model_reticle_ = {{{rs, 0.0f, 0.0f, 0.0f},
{0.0f, rs, 0.0f, 0.0f},
{0.0f, 0.0f, rs, -kReticleDistance},
{0.0f, 0.0f, 0.0f, 1.0f}}};
// Because we are using 2X MSAA, we can render to half as many pixels and
// achieve similar quality.
render_size_ = HalfPixelCount(gvr_api_->GetMaximumEffectiveRenderTargetSize());
std::vector<gvr::BufferSpec> specs;
specs.push_back(gvr_api_->CreateBufferSpec());
specs[0].SetColorFormat(GVR_COLOR_FORMAT_RGBA_8888);
specs[0].SetDepthStencilFormat(GVR_DEPTH_STENCIL_FORMAT_DEPTH_16);
specs[0].SetSamples(2);
specs[0].SetSize(render_size_);
specs.push_back(gvr_api_->CreateBufferSpec());
specs[1].SetSize(reticle_render_size_);
specs[1].SetColorFormat(GVR_COLOR_FORMAT_RGBA_8888);
specs[1].SetDepthStencilFormat(GVR_DEPTH_STENCIL_FORMAT_NONE);
specs[1].SetSamples(1);
swapchain_.reset(new gvr::SwapChain(gvr_api_->CreateSwapChain(specs)));
viewport_list_.reset(
new gvr::BufferViewportList(gvr_api_->CreateEmptyBufferViewportList()));
}
void Renderer::ResumeControllerApiAsNeeded() {
switch (gvr_viewer_type_) {
case GVR_VIEWER_TYPE_CARDBOARD:
gvr_controller_api_.reset();
break;
case GVR_VIEWER_TYPE_DAYDREAM:
if (!gvr_controller_api_) {
// Initialized controller api.
gvr_controller_api_.reset(new gvr::ControllerApi);
gvr_controller_api_->Init(gvr::ControllerApi::DefaultOptions(), gvr_api_->cobj());
}
gvr_controller_api_->Resume();
break;
default:
LOGE("unexpected viewer type.");
break;
}
}
void Renderer::ProcessControllerInput() {
const int old_status = gvr_controller_state_.GetApiStatus();
const int old_connection_state = gvr_controller_state_.GetConnectionState();
// Read current controller state.
gvr_controller_state_.Update(*gvr_controller_api_);
if (gvr_controller_state_.GetApiStatus() != old_status ||
gvr_controller_state_.GetConnectionState() != old_connection_state) {
}
// Trigger click event if app/click button is clicked.
if (gvr_controller_state_.GetButtonDown(GVR_CONTROLLER_BUTTON_APP) ||
gvr_controller_state_.GetButtonDown(GVR_CONTROLLER_BUTTON_CLICK)) {
OnTriggerEvent();
}
}
void Renderer::DrawFrame() {
if (gvr_viewer_type_ == GVR_VIEWER_TYPE_DAYDREAM) {
ProcessControllerInput();
}
PrepareFramebuffer();
gvr::Frame frame = swapchain_->AcquireFrame();
// A client app does its rendering here.
gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
gvr::BufferViewport* viewport[2] = { &viewport_left_, &viewport_right_, };
head_view_ = gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
viewport_list_->SetToRecommendedBufferViewports();
gvr::BufferViewport reticle_viewport = gvr_api_->CreateBufferViewport();
reticle_viewport.SetSourceBufferIndex(1);
reticle_viewport.SetReprojection(GVR_REPROJECTION_NONE);
const gvr_rectf fullscreen = { 0, 1, 0, 1 };
reticle_viewport.SetSourceUv(fullscreen);
gvr::Mat4f controller_matrix = ControllerQuatToMatrix(gvr_controller_state_.GetOrientation());
model_cursor_ = MatrixMul(controller_matrix, model_reticle_);
gvr::Mat4f eye_views[2];
for (int eye = 0; eye < 2; ++eye) {
const gvr::Eye gvr_eye = eye == 0 ? GVR_LEFT_EYE : GVR_RIGHT_EYE;
const gvr::Mat4f eye_from_head = gvr_api_->GetEyeFromHeadMatrix(gvr_eye);
eye_views[eye] = MatrixMul(eye_from_head, head_view_);
viewport_list_->GetBufferViewport(eye, viewport[eye]);
reticle_viewport.SetTransform(MatrixMul(eye_from_head, model_reticle_));
reticle_viewport.SetTargetEye(gvr_eye);
viewport_list_->SetBufferViewport(2 + eye, reticle_viewport);
modelview_model_[eye] = MatrixMul(eye_views[eye], model_model_);
const gvr_rectf fov = viewport[eye]->GetSourceFov();
const gvr::Mat4f perspective = PerspectiveMatrixFromView(fov, 1, 10000);
modelview_projection_model_[eye] = MatrixMul(perspective, modelview_model_[eye]);
modelview_projection_cursor_[eye] = MatrixMul(perspective, MatrixMul(eye_views[eye], model_cursor_));
}
cur_position = 0.95f * cur_position + 0.05f * dst_position;
glEnable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_BLEND);
// Draw the world.
frame.BindBuffer(0);
glClearColor(0.1f, 0.1f, 0.1f, 0.5f); // Dark background so text shows up.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
DrawWorld(kLeftView);
DrawWorld(kRightView);
frame.Unbind();
frame.BindBuffer(1);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Transparent background.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (gvr_viewer_type_ == GVR_VIEWER_TYPE_CARDBOARD)
DrawCardboardReticle();
frame.Unbind();
// Submit frame.
frame.Submit(*viewport_list_, head_view_);
}
void Renderer::PrepareFramebuffer() {
// Because we are using 2X MSAA, we can render to half as many pixels and
// achieve similar quality.
const gvr::Sizei recommended_size = HalfPixelCount(gvr_api_->GetMaximumEffectiveRenderTargetSize());
if (render_size_.width != recommended_size.width || render_size_.height != recommended_size.height) {
// We need to resize the framebuffer.
swapchain_->ResizeBuffer(0, recommended_size);
render_size_ = recommended_size;
}
}
void Renderer::OnTriggerEvent() {
glm::mat4 left = glm::make_mat4(MatrixToGLArray(modelview_model_[kLeftView]).data());
glm::mat4 right = glm::make_mat4(MatrixToGLArray(modelview_model_[kRightView]).data());
glm::vec4 lv = glm::vec4(0, 0, 1, 1) * left;
glm::vec4 rv = glm::vec4(0, 0, 1, 1) * right;
lv /= fabs(lv.w);
rv /= fabs(rv.w);
dst_position += (lv + rv) * 0.0025f;
}
void Renderer::OnPause() {
gvr_api_->PauseTracking();
if (gvr_controller_api_) gvr_controller_api_->Pause();
}
void Renderer::OnResume() {
gvr_api_->ResumeTracking();
gvr_api_->RefreshViewerProfile();
gvr_viewer_type_ = gvr_api_->GetViewerType();
ResumeControllerApiAsNeeded();
}
int Renderer::LoadGLShader(int type, const char** shadercode) {
int shader = glCreateShader(type);
glShaderSource(shader, 1, shadercode, nullptr);
glCompileShader(shader);
const unsigned int BUFFER_SIZE = 512;
char buffer[BUFFER_SIZE];
memset(buffer, 0, BUFFER_SIZE);
GLsizei length = 0;
glGetShaderInfoLog(shader, BUFFER_SIZE, &length, buffer);
if (length > 0)
LOGI("GLSL compile log: %s\n%s", buffer, *shadercode);
// Get the compilation status.
int compileStatus;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
// If the compilation failed, delete the shader.
if (compileStatus == 0) {
glDeleteShader(shader);
shader = 0;
}
return shader;
}
void Renderer::DrawWorld(ViewType view) {
const gvr::BufferViewport& viewport = view == kLeftView ? viewport_left_ : viewport_right_;
const gvr::Recti pixel_rect = CalculatePixelSpaceRect(render_size_, viewport.GetSourceUv());
glViewport(pixel_rect.left, pixel_rect.bottom,
pixel_rect.right - pixel_rect.left,
pixel_rect.top - pixel_rect.bottom);
DrawModel(view);
if (gvr_viewer_type_ == GVR_VIEWER_TYPE_DAYDREAM)
DrawDaydreamCursor(view);
}
void Renderer::DrawModel(ViewType view) {
glUseProgram(model_program_);
float* matrix = MatrixToGLArray(modelview_projection_model_[view]).data();
glUniform1f(model_translatex_param_, cur_position.x);
glUniform1f(model_translatey_param_, cur_position.y);
glUniform1f(model_translatez_param_, cur_position.z);
glUniformMatrix4fv(model_modelview_projection_param_, 1, GL_FALSE, MatrixToGLArray(modelview_projection_model_[view]).data());
glEnableVertexAttribArray(model_position_param_);
for(oc::Mesh& mesh : static_meshes_) {
if (mesh.image && (mesh.texture == -1)) {
GLuint textureID;
glGenTextures(1, &textureID);
mesh.texture = textureID;
glBindTexture(GL_TEXTURE_2D, textureID);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, mesh.image->GetWidth(), mesh.image->GetHeight(),
0, GL_RGB, GL_UNSIGNED_BYTE, mesh.image->GetData());
}
glVertexAttribPointer(model_position_param_, 3, GL_FLOAT, false, 0, mesh.vertices.data());
if (textured_)
{
glBindTexture(GL_TEXTURE_2D, (unsigned int)mesh.texture);
glVertexAttribPointer(model_uv_param_, 2, GL_FLOAT, false, 0, mesh.uv.data());
glDrawArrays(GL_TRIANGLES, 0, mesh.vertices.size());
}
else
{
glVertexAttribPointer(model_uv_param_, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, mesh.colors.data());
glDrawArrays(GL_TRIANGLES, 0, mesh.vertices.size());
}
}
glDisableVertexAttribArray(model_position_param_);
}
void Renderer::DrawDaydreamCursor(ViewType view) {
glUseProgram(reticle_program_);
glUniformMatrix4fv(reticle_modelview_projection_param_, 1, GL_FALSE, MatrixToGLArray(modelview_projection_cursor_[view]).data());
glVertexAttribPointer(reticle_position_param_, kCoordsPerVertex, GL_FLOAT, false, 0, reticle_vertices_);
glEnableVertexAttribArray(reticle_position_param_);
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisableVertexAttribArray(reticle_position_param_);
}
void Renderer::DrawCardboardReticle() {
glViewport(0, 0, reticle_render_size_.width, reticle_render_size_.height);
glUseProgram(reticle_program_);
const gvr::Mat4f uniform_matrix = {{{1.f, 0.f, 0.f, 0.f},
{0.f, 1.f, 0.f, 0.f},
{0.f, 0.f, 1.f, 0.f},
{0.f, 0.f, 0.f, 1.f}}};
glUniformMatrix4fv(reticle_modelview_projection_param_, 1, GL_FALSE, MatrixToGLArray(uniform_matrix).data());
glVertexAttribPointer(reticle_position_param_, kCoordsPerVertex, GL_FLOAT, false, 0, reticle_vertices_);
glEnableVertexAttribArray(reticle_position_param_);
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisableVertexAttribArray(reticle_position_param_);
}
|
[
"lubos@mapfactor.com"
] |
lubos@mapfactor.com
|
18d40a79af641da050c4ee3748513d38431bdb83
|
67fc9e51437e351579fe9d2d349040c25936472a
|
/wrappers/8.1.1/vtkEdgeSubdivisionCriterionWrap.h
|
5f7c79641464526f921e4a8fc1265dddf4295274
|
[] |
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
| 1,652
|
h
|
/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */
#ifndef NATIVE_EXTENSION_VTK_VTKEDGESUBDIVISIONCRITERIONWRAP_H
#define NATIVE_EXTENSION_VTK_VTKEDGESUBDIVISIONCRITERIONWRAP_H
#include <nan.h>
#include <vtkSmartPointer.h>
#include <vtkEdgeSubdivisionCriterion.h>
#include "vtkObjectWrap.h"
#include "../../plus/plus.h"
class VtkEdgeSubdivisionCriterionWrap : public VtkObjectWrap
{
public:
using Nan::ObjectWrap::Wrap;
static void Init(v8::Local<v8::Object> exports);
static void InitPtpl();
static void ConstructorGetter(
v8::Local<v8::String> property,
const Nan::PropertyCallbackInfo<v8::Value>& info);
VtkEdgeSubdivisionCriterionWrap(vtkSmartPointer<vtkEdgeSubdivisionCriterion>);
VtkEdgeSubdivisionCriterionWrap();
~VtkEdgeSubdivisionCriterionWrap( );
static Nan::Persistent<v8::FunctionTemplate> ptpl;
private:
static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
static void DontPassField(const Nan::FunctionCallbackInfo<v8::Value>& info);
static void GetNumberOfFields(const Nan::FunctionCallbackInfo<v8::Value>& info);
static void GetOutputField(const Nan::FunctionCallbackInfo<v8::Value>& info);
static void NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info);
static void PassField(const Nan::FunctionCallbackInfo<v8::Value>& info);
static void ResetFieldList(const Nan::FunctionCallbackInfo<v8::Value>& info);
static void SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info);
#ifdef VTK_NODE_PLUS_VTKEDGESUBDIVISIONCRITERIONWRAP_CLASSDEF
VTK_NODE_PLUS_VTKEDGESUBDIVISIONCRITERIONWRAP_CLASSDEF
#endif
};
#endif
|
[
"axkibe@gmail.com"
] |
axkibe@gmail.com
|
9858e297cb0b29f3f180a901f8f56c02bb3f4e0b
|
1974b1cd6499c5b121f035557e59308b2d39a8f9
|
/include/json/json.h
|
9777c6ac067df64ccfd6d3afe9707b84a267c6ec
|
[] |
no_license
|
harestomper/json-parser
|
7885622450a5fc12290ff3d3a2b0e3fa5804752a
|
aa9bfd6acfa8d95a88893c6a5525ca32424e55eb
|
refs/heads/master
| 2021-01-10T11:03:43.806049
| 2016-02-04T08:07:49
| 2016-02-04T08:07:49
| 50,937,788
| 0
| 0
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 2,655
|
h
|
/*
* json.h
*
* Created on: 18 ัะฝะฒ. 2016 ะณ.
* Author: Voldemar Khramtsov <harestomper@gmail.com>
*
* 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 _JSON_JSON_H_
#define _JSON_JSON_H_
#ifndef null
# if __cplusplus >= 201103L
# define null nullptr
# else
# define null 0
# endif
#endif /* null */
namespace json {
struct Value;
class Map;
class Array;
using Uint = unsigned int;
using Integer = long long int;
using iterator = Value*;
using const_iterator = Value const*;
struct MapBase
{
protected:
Value* m_values = null;
Uint* m_codes = null;
char** m_keys = null;
Uint m_num_buckets = 0;
Uint m_num_items = 0;
Uint m_capacity = 0;
};
struct ArrayBase
{
protected:
Value* m_data = null;
Uint m_num_items = 0;
Uint m_allocated_size = 0;
};
} /* namespace json */
#define BUFSIZE 1024
#define check_and_return(expr, ...) { \
if (not (expr)) \
{ \
char __b[BUFSIZE]; \
::snprintf(__b, BUFSIZE, " " __VA_ARGS__); \
fprintf(::stderr, "ERROR:%s:%s:%i:'%s', failure. %s\n", __FILE__, __func__, __LINE__, #expr, __b); \
return; \
} }
#define check_and_return_val(expr, retval, ...) { \
if (not (expr)) \
{ \
char __b[BUFSIZE]; \
::snprintf(__b, BUFSIZE, " " __VA_ARGS__); \
fprintf(::stderr, "ERROR:%s:%s:%i:'%s', failure. %s\n", __FILE__, __func__, __LINE__, #expr, __b); \
return (retval); \
} }
#include "jsonvalue.h"
#include "jsonarray.h"
#include "jsonmap.h"
#endif /* _JSON_JSON_H_ */
|
[
"harestomper@gmail.com"
] |
harestomper@gmail.com
|
68dabbe0b05f88e6a19e64b086437daf82e5b1ff
|
e274ecc01c1828a796fc727426419809431a8896
|
/camerapreview/src/main/cpp/libcommon/message_queue/message_queue.h
|
dc52089ba28e47a69699794c10661547c07ea9b4
|
[] |
no_license
|
LymanYe/FFmpeg
|
39cc528d45e08fbf1caf33fc34c43672175236ba
|
c7a310a35506f89766804c92d9ed8bc8244dd938
|
refs/heads/master
| 2020-03-22T05:09:00.478217
| 2018-08-10T06:41:21
| 2018-08-10T06:41:21
| 139,545,546
| 6
| 3
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 1,227
|
h
|
#ifndef VIDEO_COMMON_MESSAGE_QUEUE_H
#define VIDEO_COMMON_MESSAGE_QUEUE_H
#include "../libcommon/CommonTools.h"
#include <pthread.h>
#define MESSAGE_QUEUE_LOOP_QUIT_FLAG 19900909
class Handler;
class Message {
private:
int what;
int arg1;
int arg2;
void* obj;
public:
Message();
Message(int what);
Message(int what, int arg1, int arg2);
Message(int what, void* obj);
Message(int what, int arg1, int arg2, void* obj);
~Message();
int execute();
int getWhat(){
return what;
};
int getArg1(){
return arg1;
};
int getArg2(){
return arg2;
};
void* getObj(){
return obj;
};
Handler* handler;
};
typedef struct MessageNode {
Message *msg;
struct MessageNode *next;
MessageNode(){
msg = NULL;
next = NULL;
}
} MessageNode;
class MessageQueue {
private:
MessageNode* mFirst;
MessageNode* mLast;
int mNbPackets;
bool mAbortRequest;
pthread_mutex_t mLock;
pthread_cond_t mCondition;
const char* queueName;
public:
MessageQueue();
MessageQueue(const char* queueNameParam);
~MessageQueue();
void init();
void flush();
int enqueueMessage(Message* msg);
int dequeueMessage(Message **msg, bool block);
int size();
void abort();
};
#endif // VIDEO_COMMON_MESSAGE_QUEUE_H
|
[
"lymanye@gmail.com"
] |
lymanye@gmail.com
|
b922819c100c6076e085765a5dcf9d1dfbd459fa
|
e9f82e2ba230c31be4e624c94c6399d1f77010f7
|
/Shovel Knight_Fin/Shovel Knight/Shovel Knight.cpp
|
6d168480d77ce2fdffe46af630cfde20025bf587
|
[] |
no_license
|
beny91/Get-a-time
|
475d1160b066831846eb84633037a5d5262c1097
|
5ca822a9d86265ba31f558e57e17c9ced76a01e3
|
refs/heads/master
| 2020-04-05T14:02:42.666752
| 2017-07-06T23:00:15
| 2017-07-06T23:00:15
| 94,745,144
| 0
| 0
| null | null | null | null |
UHC
|
C++
| false
| false
| 5,469
|
cpp
|
// Shovel Knight.cpp : ์์ฉ ํ๋ก๊ทธ๋จ์ ๋ํ ์ง์
์ ์ ์ ์ํฉ๋๋ค.
//
#include "stdafx.h"
#include "Shovel Knight.h"
#include "maingame.h"
#define MAX_LOADSTRING 100
// ์ ์ญ ๋ณ์:
HINSTANCE hInst; // ํ์ฌ ์ธ์คํด์ค์
๋๋ค.
TCHAR szTitle[MAX_LOADSTRING]; // ์ ๋ชฉ ํ์์ค ํ
์คํธ์
๋๋ค.
TCHAR szWindowClass[MAX_LOADSTRING]; // ๊ธฐ๋ณธ ์ฐฝ ํด๋์ค ์ด๋ฆ์
๋๋ค.
HWND g_hWnd;
// ์ด ์ฝ๋ ๋ชจ๋์ ๋ค์ด ์๋ ํจ์์ ์ ๋ฐฉํฅ ์ ์ธ์
๋๋ค.
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
int APIENTRY _tWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
//_CrtSetBreakAlloc(175);
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// TODO: ์ฌ๊ธฐ์ ์ฝ๋๋ฅผ ์
๋ ฅํฉ๋๋ค.
MSG msg;
HACCEL hAccelTable;
// ์ ์ญ ๋ฌธ์์ด์ ์ด๊ธฐํํฉ๋๋ค.
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_SHOVELKNIGHT, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// ์์ฉ ํ๋ก๊ทธ๋จ ์ด๊ธฐํ๋ฅผ ์ํํฉ๋๋ค.
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_SHOVELKNIGHT));
msg.message = WM_NULL;
CMainGame MainGame;
MainGame.Initialize();
DWORD dwTime = GetTickCount();
while (msg.message != WM_QUIT)
{
if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
if(dwTime + 30 < GetTickCount())
{
dwTime = GetTickCount();
MainGame.Progress();
MainGame.Render();
}
}
}
//// ๊ธฐ๋ณธ ๋ฉ์์ง ๋ฃจํ์
๋๋ค.
//while (GetMessage(&msg, NULL, 0, 0))
//{
// if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
// {
// TranslateMessage(&msg);
// DispatchMessage(&msg);
// }
//}
// _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
return (int) msg.wParam;
}
//
// ํจ์: MyRegisterClass()
//
// ๋ชฉ์ : ์ฐฝ ํด๋์ค๋ฅผ ๋ฑ๋กํฉ๋๋ค.
//
// ์ค๋ช
:
//
// Windows 95์์ ์ถ๊ฐ๋ 'RegisterClassEx' ํจ์๋ณด๋ค ๋จผ์
// ํด๋น ์ฝ๋๊ฐ Win32 ์์คํ
๊ณผ ํธํ๋๋๋ก
// ํ๋ ค๋ ๊ฒฝ์ฐ์๋ง ์ด ํจ์๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ด ํจ์๋ฅผ ํธ์ถํด์ผ
// ํด๋น ์์ฉ ํ๋ก๊ทธ๋จ์ ์ฐ๊ฒฐ๋
// '์ฌ๋ฐ๋ฅธ ํ์์' ์์ ์์ด์ฝ์ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX 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_SHOVELKNIGHT));
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
return RegisterClassEx(&wcex);
}
//
// ํจ์: InitInstance(HINSTANCE, int)
//
// ๋ชฉ์ : ์ธ์คํด์ค ํธ๋ค์ ์ ์ฅํ๊ณ ์ฃผ ์ฐฝ์ ๋ง๋ญ๋๋ค.
//
// ์ค๋ช
:
//
// ์ด ํจ์๋ฅผ ํตํด ์ธ์คํด์ค ํธ๋ค์ ์ ์ญ ๋ณ์์ ์ ์ฅํ๊ณ
// ์ฃผ ํ๋ก๊ทธ๋จ ์ฐฝ์ ๋ง๋ ๋ค์ ํ์ํฉ๋๋ค.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HWND hWnd;
hInst = hInstance; // ์ธ์คํด์ค ํธ๋ค์ ์ ์ญ ๋ณ์์ ์ ์ฅํฉ๋๋ค.
hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, g_iWINCX, g_iWINCY, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
g_hWnd = hWnd;
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)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE:
DestroyWindow(hWnd);
break;
}
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(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_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO: ์ฌ๊ธฐ์ ๊ทธ๋ฆฌ๊ธฐ ์ฝ๋๋ฅผ ์ถ๊ฐํฉ๋๋ค.
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;
}
|
[
"sosik4@gmail.com"
] |
sosik4@gmail.com
|
1a49875910acde426161e1cda75d790695fef49c
|
2b19a7d798a7a8b259857ef0cd0445724df9056a
|
/project/include/ctrlext.h
|
0116497e1ff1a0809b70148ebc77e421c1e67326
|
[
"MIT"
] |
permissive
|
lakeweb/spur-gear-gen
|
98a95838bcbc1b24e2b1133f877552fdffab3857
|
40714adfbe0acca16d517e6824eb72d1f3dec42d
|
refs/heads/master
| 2021-05-01T22:25:21.896050
| 2017-01-16T21:14:38
| 2017-01-16T21:14:38
| 77,257,019
| 1
| 2
| null | null | null | null |
UTF-8
|
C++
| false
| false
| 8,316
|
h
|
// ctrlext.h :
//
// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.
#ifndef __TREECTLX_H__
#define __TREECTLX_H__
//#define TCN_BEGIN_LIST 32780
#define TCN_LMOUSEBUTTON 32780
#ifdef _AFX_NO_AFXCMN_SUPPORT
#error Windows Common Control classes not supported in this library variant.
#endif
#ifndef __AFXWIN_H__
#include <afxwin.h>
#endif
class CTreeCtrlEx;
//.........................................................
/*
#define TVHT_NOWHERE 0x0001
#define TVHT_ONITEMICON 0x0002
#define TVHT_ONITEMLABEL 0x0004
#define TVHT_ONITEM (TVHT_ONITEMICON | TVHT_ONITEMLABEL | TVHT_ONITEMSTATEICON)
#define TVHT_ONITEMINDENT 0x0008
#define TVHT_ONITEMBUTTON 0x0010
#define TVHT_ONITEMRIGHT 0x0020
#define TVHT_ONITEMSTATEICON 0x0040
#define TVHT_ABOVE 0x0100
#define TVHT_BELOW 0x0200
#define TVHT_TORIGHT 0x0400
#define TVHT_TOLEFT 0x0800
typedef struct tagTVHITTESTINFO {
POINT pt;
UINT flags;
HTREEITEM hItem;
} TVHITTESTINFO, *LPTVHITTESTINFO;
*/
/*
typedef struct tagNMHDR
{
HWND hwndFrom;
UINT_PTR idFrom;
UINT code; // NM_ code
} NMHDR;
*/
//notify clicks
typedef struct tagTREECLICKA
{
NMHDR hdr;
TVHITTESTINFO hit_info;
UINT mouse_flags;
CPoint ptClick;
CTreeCtrlEx* pClass;
} TREECLICKA, *LPTREECLICKA;
//Used in OnNMClick, as CLVN_CHECKCHANGE
// OnNMRclick, as CLVN_RTLCLK; OnNMDblclk, as CLVN_DBLCLK
// ............................................................
class CTreeCtrlEx;
// ............................................................
class CTreeCursor
{
// Attributes
protected:
HTREEITEM m_hTreeItem;
CTreeCtrlEx *m_pTree;
// Implementation
protected:
CTreeCursor CTreeCursor::_Insert( LPCTSTR strItem, int nImageNorm, int nImageSel, HTREEITEM hAfter );
// Operation
public:
CTreeCursor( );
CTreeCursor( HTREEITEM hTreeItem, CTreeCtrlEx* pTree );
CTreeCursor( const CTreeCursor& posSrc );
CTreeCursor( const TREECLICKA& info );
~CTreeCursor( );
const CTreeCursor& operator = ( const CTreeCursor& posSrc );
operator HTREEITEM( ) const;
bool IsValid( ) const;
void SetInvalid( );
CTreeCursor InsertAfter( LPCTSTR strItem, HTREEITEM hAfter, int nImageNorm= -1, int nImageSel= -1 );
CTreeCursor AddHead( LPCTSTR strItem, int nImageNorm= -1, int nImageSel= -1 );
CTreeCursor AddTail( LPCTSTR strItem, int nImageNorm= -1, int nImageSel= -1 );
int GetImageID( );
int GetImageIDSel( );
BOOL GetRect( LPRECT lpRect, BOOL bTextOnly );
CTreeCursor GetNext( UINT nCode );
CTreeCursor GetChild( );
CTreeCursor GetNextSibling( );
CTreeCursor GetPrevSibling( );
CTreeCursor GetParent( );
CTreeCursor GetFirstVisible( );
CTreeCursor GetNextVisible( );
CTreeCursor GetPrevVisible( );
CTreeCursor GetSelected( );
CTreeCursor GetDropHilight( );
CTreeCursor GetRoot( );
CString GetText( );
BOOL GetImage( int& nImage, int& nSelectedImage );
UINT GetState( UINT nStateMask );
DWORD GetData( ) const;
//BOOL SetItem( UINT nMask, LPCTSTR lpszItem, int nImage,
// int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam );
BOOL SetText( LPCTSTR lpszItem );
BOOL SetImage( int nImage, int nSelectedImage= -1 );
BOOL SetState( UINT nState, UINT nStateMask );
BOOL SetData( DWORD dwData );
BOOL HasChildren( );
//returns count of real children
int GetChildCount( ); //5/31/7
// Operations
BOOL Delete( );
BOOL Expand(UINT nCode= TVE_EXPAND );
BOOL Collapse( );
BOOL Select( UINT nCode );
BOOL Select( );
BOOL SelectDropTarget( );
BOOL SelectSetFirstVisible( );
CEdit* EditLabel( );
CImageList* CreateDragImage( );
BOOL SortChildren( );
BOOL EnsureVisible( );
void DeleteAllChildren( ); //added 3/26/4
CTreeCtrlEx& GetTreeCtrl( ); //added 5/14/7
//will appear as having children [+] without real children
void SetHasChildern( ); //added 5/30/7
bool IsExpanded( ) const;
};
// ............................................................
class CTreeCtrlEx : public CTreeCtrl
{
DECLARE_DYNAMIC( CTreeCtrlEx )
bool IsSelectedItem( HTREEITEM hItem );
public:
CTreeCtrlEx( );
virtual ~CTreeCtrlEx( );
operator CTreeCtrlEx * ( ) { return this; }
CImageList* SetImageList( CImageList* pImageList, int nImageListType = TVSIL_NORMAL );
CTreeCursor GetNextItem( HTREEITEM hItem, UINT nCode );
CTreeCursor GetChildItem( HTREEITEM hItem );
CTreeCursor GetNextSiblingItem( HTREEITEM hItem );
CTreeCursor GetPrevSiblingItem( HTREEITEM hItem );
CTreeCursor GetParentItem( HTREEITEM hItem );
CTreeCursor GetFirstVisibleItem( );
CTreeCursor GetNextVisibleItem( HTREEITEM hItem );
CTreeCursor GetPrevVisibleItem( HTREEITEM hItem );
CTreeCursor GetSelectedItem( );
CTreeCursor GetDropHilightItem( );
CTreeCursor GetRootItem( );
CTreeCursor InsertItem( LPTV_INSERTSTRUCT lpInsertStruct );
CTreeCursor InsertItem( UINT nMask, LPCTSTR lpszItem, int nImage,
int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam,
HTREEITEM hParent, HTREEITEM hInsertAfter );
CTreeCursor InsertItem( LPCTSTR lpszItem, HTREEITEM hParent = TVI_ROOT,
HTREEITEM hInsertAfter = TVI_LAST );
CTreeCursor InsertItem( LPCTSTR lpszItem, int nImage, int nSelectedImage,
HTREEITEM hParent = TVI_ROOT, HTREEITEM hInsertAfter = TVI_LAST );
CTreeCursor HitTest( CPoint pt, UINT* pFlags = NULL );
CTreeCursor HitTest( TV_HITTESTINFO* pHitTestInfo );
//returns true if children and expanded
protected:
DECLARE_MESSAGE_MAP( )
afx_msg BOOL OnNMCustomdrawTreeEx( NMHDR *pNMHDR, LRESULT *pResult );
afx_msg void OnLButtonDown( UINT nFlags, CPoint point );
};
// ............................................................
class CTreeCtrlTraverse
{
CTreeCtrlEx& tree_ctrl;
HTREEITEM root;
HTREEITEM tree_pos;
long depth;
public:
//constructor sets traverse start to root
CTreeCtrlTraverse::CTreeCtrlTraverse( CTreeCtrlEx& inTC )
:tree_ctrl( inTC )
,depth( 1 )
{
ASSERT( (HTREEITEM)inTC.GetRootItem( ) );
root= tree_pos= inTC.GetRootItem( );
}
//constructor sets traverse start to tree cursor
CTreeCtrlTraverse::CTreeCtrlTraverse( CTreeCursor& inPos )
:tree_ctrl( inPos.GetTreeCtrl( ) )
,depth( 1 )
{
ASSERT( (HTREEITEM)inPos );
root= tree_pos= inPos;
}
CTreeCursor GetCurrentNode( ) const { return CTreeCursor( tree_pos, &tree_ctrl ); }
//Return next node and increment
CTreeCursor GetNextNode( );
//Returns root set by instantiation
CTreeCursor GetRootNode( ) const { return CTreeCursor( tree_pos, &tree_ctrl ); }
//Get depth in tree
long GetDepth( ) const { return depth; }
void Reset( ) { depth= 1; tree_pos= root; }
};
// ............................................................
class CViewTreeEx : public CTreeCtrlEx
{
// Construction
public:
CViewTreeEx( );
// Overrides
protected:
virtual BOOL OnNotify( WPARAM wParam, LPARAM lParam, LRESULT* pResult );
// Implementation
public:
virtual ~CViewTreeEx( );
protected:
DECLARE_MESSAGE_MAP( )
};
// ............................................................
// ............................................................
// ............................................................
// ............................................................
// ............................................................
/////////////////////////////////////////////////////////////////////////////
// CListCtrlEx
//class CListCtrlEx : public CListCtrl
//{
// // Attributes
//protected:
//
// // Operation
//public:
// CListCtrlEx();
// ~CListCtrlEx();
// CImageList* SetImageList(CImageList* pImageList, int nImageListType = TVSIL_NORMAL);
// BOOL AddColumn(
// LPCTSTR strItem,int nItem,int nSubItem = -1,
// int nMask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM,
// int nFmt = LVCFMT_LEFT);
// BOOL AddItem(int nItem,int nSubItem,LPCTSTR strItem,int nImageIndex = -1);
//};
/////////////////////////////////////////////////////////////////////////////
#include <CtrlExt.inl>
#endif //__TREECTLX_H__
|
[
"contest@lakeweb.net"
] |
contest@lakeweb.net
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.