blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
b6a11d2b2deab26e4fb9de05d7e7585f486d98f9 | 045f7711ccfa95d2a51056f21b6c1c308fe95fc2 | /Lab7/Lab2/Lab2.cpp | a3a3de9a22c38cef4d649a06ba0ceefd3a620eeb | [
"MIT"
] | permissive | TrueEdOs/OS-E | 19eb5e641394d7f3a1d17c5b557ff37a924b656d | 0d0db497a0b0c798e1c8448e8a1eedd4ed260eae | refs/heads/master | 2022-06-04T07:11:10.082473 | 2020-04-28T20:19:07 | 2020-04-28T20:19:07 | 259,721,443 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 8,323 | cpp |
#include "stdafx.h"
#include "Lab2.h"
#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
// Forward declarations of functions included in this code module:
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
void InitControls(HWND);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
HWND hWnd;
int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ LPTSTR lpCmdLine,
_In_ int nCmdShow)
{
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_LAB2, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_LAB2));
// 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.
//
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_LAB2));
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)3;
wcex.lpszMenuName = MAKEINTRESOURCE(IDC_LAB2);
wcex.lpszClassName = szWindowClass;
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
return RegisterClassEx(&wcex);
}
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
hInst = hInstance; // Store instance handle in our global variable
hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, 390, 380, NULL, NULL, hInstance, NULL);
InitControls(hWnd);
if (!hWnd)
{
return FALSE;
}
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
return TRUE;
}
#define EDIT_ID 1
#define BUTTON_ADD_ID 2
#define BUTTON_CLEAR_ID 3
#define BUTTON_TORIGHT_ID 4
#define BUTTON_DELETE_ID 5
#define LISTBOX1_ID 6
#define LISTBOX2_ID 7
HWND hEdit, hButtonAdd, hButtonClear, hButtonToRight, hButtonDelete, hListBox1, hListBox2;
void InitControls(HWND hWnd) {
hEdit = CreateWindowEx(WS_EX_CLIENTEDGE, L"EDIT", L"Добавь меня!", WS_TABSTOP | WS_CHILD | WS_VISIBLE | ES_AUTOVSCROLL | ES_AUTOHSCROLL,
40, 10, 200, 25, hWnd, (HMENU)EDIT_ID, hInst, NULL);
hButtonAdd = CreateWindow(L"BUTTON", L"Добавить", WS_TABSTOP | WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
40, 45, 80, 30, hWnd, (HMENU)BUTTON_ADD_ID, hInst, NULL);
hButtonClear = CreateWindow(L"BUTTON", L"Очистить поля", WS_TABSTOP | WS_CHILD | WS_VISIBLE,
120, 280, 140, 30, hWnd, (HMENU)BUTTON_CLEAR_ID, hInst, NULL);
hButtonToRight = CreateWindow(L"BUTTON", L"Сместить вправо", WS_TABSTOP | WS_CHILD | WS_VISIBLE,
200, 240, 140, 30, hWnd, (HMENU)BUTTON_TORIGHT_ID, hInst, NULL);
hButtonDelete = CreateWindow(L"BUTTON", L"Удалить", WS_TABSTOP | WS_CHILD | WS_VISIBLE,
40, 240, 140, 30, hWnd, (HMENU)BUTTON_DELETE_ID, hInst, NULL);
hListBox1 = CreateWindowEx(WS_EX_CLIENTEDGE, L"LISTBOX", L"", WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL | ES_AUTOVSCROLL | ES_AUTOHSCROLL | LBS_MULTIPLESEL,
40, 80, 140, 160, hWnd, (HMENU)LISTBOX1_ID, hInst, NULL);
hListBox2 = CreateWindowEx(WS_EX_CLIENTEDGE, L"LISTBOX", L"", WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_AUTOVSCROLL | WS_HSCROLL | ES_AUTOVSCROLL | LBS_MULTIPLESEL,
200, 80, 140, 160, hWnd, (HMENU)LISTBOX2_ID, hInst, NULL);
SendDlgItemMessage(hWnd, EDIT_ID, (UINT)LB_SETHORIZONTALEXTENT, (WPARAM)1024, (LPARAM)0);
}
bool ContainsString(HWND hListBox, TCHAR* s) {
int count = SendMessage(hListBox, LB_GETCOUNT, 0, 0);
for (int i = 0; i < count; i++) {
TCHAR buffer[256];
SendMessage(hListBox, LB_GETTEXT, i, (LPARAM)buffer);
if (!_tcscmp(s, buffer))
return true;
}
return false;
}
void UpdateListBoxScroll(HWND hListBox, int itemId = -1) {
int count = SendMessage(hListBox, LB_GETCOUNT, 0, 0);
if (count == 0) SendDlgItemMessage(hWnd, hListBox == hListBox1 ? LISTBOX1_ID : LISTBOX2_ID, (UINT)LB_SETHORIZONTALEXTENT, (WPARAM)0, (LPARAM)0);
TCHAR buffer[256];
for (int i = 0; i < count; i++) {
if (i == itemId) continue;
SendMessage(hListBox, LB_GETTEXT, i, (LPARAM)buffer);
int SizeOfHBListBox = _tcslen(buffer) * 8;
SendDlgItemMessage(hWnd, hListBox == hListBox1 ? LISTBOX1_ID : LISTBOX2_ID, (UINT)LB_SETHORIZONTALEXTENT, (WPARAM)SizeOfHBListBox, (LPARAM)0);
}
}
void AddStringInListBoxIfNeed(HWND hListBox, TCHAR* s) {
if (!ContainsString(hListBox, s)) {
SendMessage(hListBox, LB_ADDSTRING, 0, (LPARAM)s);
UpdateListBoxScroll(hListBox);
}
}
bool DeleteSelectedItem(HWND hListBox) {
int selCount = SendMessage(hListBox1, LB_GETSELCOUNT, 0, 0);
int countBuffer[100];
SendMessage(hListBox1, LB_GETSELITEMS, 100, (LPARAM)countBuffer);
for (int i = selCount - 1; i >= 0; --i) {
int itemId = countBuffer[i];
SendMessage(hListBox, LB_DELETESTRING, itemId, 0);
}
UpdateListBoxScroll(hListBox);
return true;
}
void ToRight() {
int selCount = SendMessage(hListBox1, LB_GETSELCOUNT, 0, 0);
int countBuffer[100];
SendMessage(hListBox1, LB_GETSELITEMS, 100, (LPARAM)countBuffer);
if (selCount == 0) {
MessageBox(hWnd, L"Select item in first ListBox", L"Error", MB_OK);
}
else {
for (int i = selCount - 1; i >= 0; --i) {
int itemId = countBuffer[i];
TCHAR buffer[256];
SendMessage(hListBox1, LB_GETTEXT, itemId, (LPARAM)buffer);
AddStringInListBoxIfNeed(hListBox2, buffer);
}
DeleteSelectedItem(hListBox1);
}
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
switch (wmEvent)
{
case BN_CLICKED:
switch (wmId)
{
case BUTTON_ADD_ID:
int len;
len = SendMessage(hEdit, WM_GETTEXTLENGTH, 0, 0);
if (len == 0)
MessageBox(hWnd, L"Fill the text field", L"Error", MB_OK);
else {
TCHAR *buffer = new TCHAR[len];
SendMessage(hEdit, WM_GETTEXT, len + 1, (LPARAM)buffer);
AddStringInListBoxIfNeed(hListBox1, buffer);
SetWindowText(GetDlgItem(hWnd, EDIT_ID), L"");
}
break;
case BUTTON_CLEAR_ID:
SendMessage(hListBox1, LB_RESETCONTENT, 0, 0);
SendMessage(hListBox2, LB_RESETCONTENT, 0, 0);
UpdateListBoxScroll(hListBox1);
UpdateListBoxScroll(hListBox2);
break;
case BUTTON_TORIGHT_ID:
ToRight();
break;
case BUTTON_DELETE_ID:
DeleteSelectedItem(hListBox1);
DeleteSelectedItem(hListBox2);
break;
default:
break;
}
break;
default:
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: Add any drawing code here...
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
// 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;
}
return (INT_PTR)FALSE;
}
| [
"comp.disk2013@yandex.by"
] | comp.disk2013@yandex.by |
ad31014f563687593afcefd929df1bd15b9d230b | ddb2870ac22217c7f58e02ecb9b4e12e06ac3034 | /Reference/Header/Export_Utility.inl | 1b6f1c98c55fa49e3cbd6bbc3df657b3d01875ec | [] | no_license | jw96118/Little-NightMare | b147159c4948cd9528882cad08e9c9c253e29d7d | 7c56a4ceb0bf411f6bd4a10c2b834f3d262ba198 | refs/heads/main | 2023-07-04T09:37:46.257693 | 2021-08-16T04:29:28 | 2021-08-16T04:29:28 | 396,616,425 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,505 | inl | #include "Export_Utility.h"
// Management Instance
// Get
CComponent* Get_Component(const _tchar* pLayerTag, const _tchar* pObjTag, const _tchar* pComponentTag, COMPONENTID eID)
{
return CManagement::GetInstance()->Get_Component(pLayerTag, pObjTag, pComponentTag, eID);
}
inline CGameObject * Get_GameObject(const _tchar * pLayerTag, const _tchar * pObjTag)
{
return CManagement::GetInstance()->Get_GameObject(pLayerTag, pObjTag);
}
inline CLayer* Get_Layer(const _tchar* pLayerTag)
{
return CManagement::GetInstance()->Get_Layer(pLayerTag);
}
// Set
HRESULT SetUp_Scene(CScene* pScene)
{
return CManagement::GetInstance()->SetUp_Scene(pScene);
}
// General
HRESULT Create_Management(LPDIRECT3DDEVICE9& pGraphicDev, CManagement** ppManagement, _bool flag)
{
CManagement* pInstance = CManagement::GetInstance();
if (nullptr == pInstance)
return E_FAIL;
FAILED_CHECK_RETURN(pInstance->Ready_Management(pGraphicDev, flag), E_FAIL);
*ppManagement = pInstance;
return S_OK;
}
// Renderer
CRenderer* Get_Renderer(void)
{
return CRenderer::GetInstance();
}
// LightMgr
// Get
// Set
// General
const D3DLIGHT9* Get_LightInfo(const _uint& iIndex)
{
return CLightMgr::GetInstance()->Get_LightInfo(iIndex);
}
D3DLIGHT9* Set_LightInfo(const _uint& iIndex)
{
return CLightMgr::GetInstance()->Set_LightInfo(iIndex);
}
HRESULT Ready_Light(LPDIRECT3DDEVICE9 pGraphicDev,
const D3DLIGHT9* pLightInfo,
const _uint& iIndex)
{
return CLightMgr::GetInstance()->Ready_Light(pGraphicDev, pLightInfo, iIndex);
}
void Render_Light(LPD3DXEFFECT& pEffect)
{
CLightMgr::GetInstance()->Render_Light(pEffect);
}
// PrototypeMgr
// Get
// Set
// General
HRESULT Ready_Prototype(const _tchar* pProtoTag, CComponent* pInstance)
{
return CPrototypeMgr::GetInstance()->Ready_Prototype(pProtoTag, pInstance);
}
CComponent* Clone_Prototype(const _tchar* pProtoTag)
{
return CPrototypeMgr::GetInstance()->Clone_Prototype(pProtoTag);
}
// RenderTargetMgr
// Get
// Set
inline void SetUp_OnShader(LPD3DXEFFECT& pEffect, const _tchar* pTargetTag, const char* pContantName);
// General
HRESULT Ready_RenderTarget(LPDIRECT3DDEVICE9 pGraphicDev,
const _tchar* pTargetTag,
const _uint& iWidth,
const _uint& iHeight,
D3DFORMAT Format,
D3DXCOLOR Color)
{
return CRenderTargetMgr::GetInstance()->Ready_RenderTarget(pGraphicDev, pTargetTag, iWidth, iHeight, Format, Color);
}
HRESULT Ready_MRT(const _tchar* pMRTTag, const _tchar* pTargetTag)
{
return CRenderTargetMgr::GetInstance()->Ready_MRT(pMRTTag, pTargetTag);
}
HRESULT Begin_MRT(const _tchar* pMRTTag)
{
return CRenderTargetMgr::GetInstance()->Begin_MRT(pMRTTag);
}
HRESULT End_MRT(const _tchar* pMRTTag)
{
return CRenderTargetMgr::GetInstance()->End_MRT(pMRTTag);
}
HRESULT Ready_DebugBuffer(const _tchar* pTargetTag,
const _float& fX,
const _float& fY,
const _float& fSizeX,
const _float& fSizeY)
{
return CRenderTargetMgr::GetInstance()->Ready_DebugBuffer(pTargetTag, fX, fY, fSizeX, fSizeY);
}
void Render_DebugBuffer(const _tchar* pMRTTag)
{
CRenderTargetMgr::GetInstance()->Render_DebugBuffer(pMRTTag);
}
void Set_RenderFlag(_bool flag)
{
CRenderTargetMgr::GetInstance()->Set_RenderFlag(flag);
}
// Utility Release
void Release_Utility(void)
{
CRenderTargetMgr::GetInstance()->DestroyInstance();
CPrototypeMgr::GetInstance()->DestroyInstance();
CLightMgr::GetInstance()->DestroyInstance();
CManagement::GetInstance()->DestroyInstance();
CRenderer::GetInstance()->DestroyInstance();
}
| [
"jw96118@naver.com"
] | jw96118@naver.com |
2b89ef9cc8aef621eb6c02c22cb9c500cf488050 | e9ac4bc4ca03773b846d55b5b735eec6fa6e7516 | /server_MPath_proto/src/myHevcdec_v2.cpp | 093c2e6ca2609120489a5b2b3837c3552e8799c9 | [] | no_license | ShawnshanksGui/server_MPath_proto | 522c0baa8155e85243ead00c42a814f1b1e005b8 | dfbcf88ec4f330ab7d496dd78580cda301658470 | refs/heads/master | 2021-09-14T21:47:50.340637 | 2018-05-20T09:55:16 | 2018-05-20T09:55:16 | 119,500,886 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,957 | cpp | #include "chrono"
#include "iostream"
#include "fstream"
#include "sstream"
#include "string"
#include "ios"
#include "cstdio"
//#include "../include/video_reader.h"
using namespace std;
//for test and debug
#define ENABLE_DEBUG
//for test and debug
#ifdef ENABLE_DEBUG
#define REGION_NUM 3
#define FRAME_GOP 50
#define GOP_NUM 2
//the intra pridicted frame
#define I_FRAME 0
//the forward predicted frame
#define P_FRAME 1
struct Nalu_Elem{
bool frameType;
//the start address for each NALU.
int _addr;
//the size for each NALU.
int _size;
};
struct Nalu_Elem nalu[REGION_NUM][(FRAME_GOP+10)*GOP_NUM];
#endif
#define HEVC_NAL_TRAIL_N 0
#define HEVC_NAL_TRAIL_R 1
#define HEVC_NAL_TSA_N 2
#define HEVC_NAL_TSA_R 3
#define HEVC_NAL_STSA_N 4
#define HEVC_NAL_STSA_R 5
#define HEVC_NAL_RADL_N 6
#define HEVC_NAL_RADL_R 7
#define HEVC_NAL_RASL_N 8
#define HEVC_NAL_RASL_R 9
#define HEVC_NAL_BLA_W_LP 16
#define HEVC_NAL_BLA_W_RADL 17
#define HEVC_NAL_BLA_N_LP 18
#define HEVC_NAL_IDR_W_RADL 19
#define HEVC_NAL_IDR_N_LP 20
#define HEVC_NAL_CRA_NUT 21
#define HEVC_NAL_VPS 32
#define HEVC_NAL_SPS 33
#define HEVC_NAL_PPS 34
#define HEVC_NAL_AUD 35
#define HEVC_NAL_EOS_NUT 36
#define HEVC_NAL_EOB_NUT 37
#define HEVC_NAL_FD_NUT 38
#define HEVC_NAL_SEI_PREFIX 39
#define HEVC_NAL_SEI_SUFFIX 40
std::string slurp(std::ifstream &File) {
std::stringstream sstr;
sstr << File.rdbuf();
return sstr.str();
}
int hevc_parser(string &p, int id_region) {
int i = 0;
int num = 0;
uint32_t code = -1;
//the start address for each NALU
// int addr_nalu[40] = {0};
//the size for each NALU
// int size_nalu[40] = {0};
int vps = 0;
int sps = 0;
int pps = 0;
//the number of I frame(B,P).
int cnt_irap = 0;
//the number of non-I frame(B,P).
int cnt_BorP = 0;
auto startTime = std::chrono::high_resolution_clock::now();
for (i = 0; i < p.length(); i++) {
code = (code << 8) + p[i];
if ((code & 0xffffff00) == 0x100) {
char nal2 = p[i + 1];
int type = (code & 0x7E) >> 1;
if (code & 0x81) // forbidden and reserved zero bits
return 0;
if (nal2 & 0xf8) // reserved zero
return 0;
switch (type) {
case HEVC_NAL_VPS:
{
vps++;
nalu[id_region][num].frameType = I_FRAME;
/*
nalu[id_region][num]._addr = i-4;
if(num > 0) {
//derive the size of the last one nalu;
nalu[id_region][num-1]._size=i-4-nalu[id_region][num-1]._addr;
}
*/
nalu[id_region][num]._addr=(p[i-4]==0) ? (i-4) : (i-3);
if(num > 0) {
//derive the size of the last one nalu;
nalu[id_region][num-1]._size = nalu[id_region][num]._addr-nalu[id_region][num-1]._addr;
}
num++;
break;
}
case HEVC_NAL_SPS:
{
/*
sps++;
nalu[id_region][num]._size = i - nalu[id_region][num]._addr;
num++;
nalu[id_region][num]._addr = i;;
*/
break;
}
case HEVC_NAL_PPS:
{
/*
pps++;
nalu[id_region][num]._size = i - nalu[id_region][num]._addr;
num++;
nalu[id_region][num]._addr = i;;
*/
break;
}
case HEVC_NAL_TRAIL_N:
case HEVC_NAL_TRAIL_R:
case HEVC_NAL_TSA_N:
case HEVC_NAL_TSA_R:
case HEVC_NAL_STSA_N:
case HEVC_NAL_STSA_R:
case HEVC_NAL_RADL_N:
case HEVC_NAL_RADL_R:
case HEVC_NAL_RASL_N:
case HEVC_NAL_RASL_R:
{
cnt_BorP++;
nalu[id_region][num]._addr = (p[i-4]==0) ? (i-4) : (i-3);
nalu[id_region][num-1]._size = nalu[id_region][num]._addr - nalu[id_region][num-1]._addr;
nalu[id_region][num].frameType = P_FRAME;
num++;
break;
}
//
case HEVC_NAL_BLA_N_LP:
case HEVC_NAL_BLA_W_LP:
case HEVC_NAL_BLA_W_RADL:
case HEVC_NAL_CRA_NUT:
case HEVC_NAL_IDR_N_LP:
case HEVC_NAL_IDR_W_RADL:
{
cnt_irap++;
/*
nalu[id_region][num].frameType = I_FRAME;
nalu[id_region][num]._size = i - nalu[id_region][num]._addr;
num++;
nalu[id_region][num]._addr = i-3;
*/
// std::cout << "addr of the " << cnt_irap <<
// "'th I frame is " << i;
// std::cout << std::endl;
break;
}
}
}
}
//count the isze of the video segment's last NALU
nalu[id_region][num-1]._size = i - 1 - nalu[id_region][num-1]._addr;
//
//records the eclpsing time for calculating testing time
auto endTime = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>
(endTime - startTime ).count();
printf("the time cost is %ld us\n", duration);
#ifdef ENABLE_DEBUG
{
printf("the number of vps,sps,pps,I_frame,P_frame is %d,%d,%d,%d,%d,respectively\n\n",
vps, sps, pps, cnt_irap, cnt_BorP);
printf("the address of all nalus is following:\n");
for(int i = 0; i < (FRAME_GOP+10)*GOP_NUM; i++) {
printf("%d ", nalu[id_region][i]._addr);
}
printf("\n\n");
printf("the nalu size is following:\n");
for(int i = 0; i < (FRAME_GOP+10)*GOP_NUM; i++) {
printf("%d ", nalu[id_region][i]._size);
}
printf("\n");
}
#endif
// if (vps && sps && pps && cnt_irap)
// return 1;
// return 0;
}
#ifdef ENABLE_DEBUG
int main() {
int flag_video = 0;
// std::string _input;
std::ifstream File;
std::string inString;
File.open("../../../video_test/machu_picchu_a_s111_non_B.265", std::ios::in);
// File.open("machu_piccu_8k.265", std::ios::in);
// File.open("input_non_b.265", std::ios::in);
// cin >> _input;
// File.open(_input, std::ios::in);
inString = slurp(File);
flag_video = hevc_parser(inString, 1);
// printf("\nflag_video is %d\n", flag_video);
// std::cout << inString;
return 0;
}
#endif
/*
* RAW HEVC video demuxer
* Copyright (c) 2013 Dirk Farin <dirk.farin@gmail.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
#include "libavcodec/hevc.h"
#include "avformat.h"
#include "rawdec.h"
static int hevc_probe(AVProbeData *p)
{
uint32_t code = -1;
int vps = 0, sps = 0, pps = 0, cnt_irap = 0;
int i;
for (i = 0; i < p->buf_size - 1; i++) {
code = (code << 8) + p->buf[i];
if ((code & 0xffffff00) == 0x100) {
uint8_t nal2 = p->buf[i + 1];
int type = (code & 0x7E) >> 1;
if (code & 0x81) // forbidden and reserved zero bits
return 0;
if (nal2 & 0xf8) // reserved zero
return 0;
switch (type) {
case HEVC_NAL_VPS: vps++; break;
case HEVC_NAL_SPS: sps++; break;
case HEVC_NAL_PPS: pps++; break;
case HEVC_NAL_BLA_N_LP:
case HEVC_NAL_BLA_W_LP:
case HEVC_NAL_BLA_W_RADL:
case HEVC_NAL_CRA_NUT:
case HEVC_NAL_IDR_N_LP:
case HEVC_NAL_IDR_W_RADL: cnt_irap++; break;
}
}
}
if (vps && sps && pps && cnt_irap)
return AVPROBE_SCORE_EXTENSION + 1; // 1 more than .mpg
return 0;
}
FF_DEF_RAWVIDEO_DEMUXER(hevc, "raw HEVC video", hevc_probe, "hevc,h265,265", AV_CODEC_ID_HEVC)
*/ | [
"fei467475649@gmail.com"
] | fei467475649@gmail.com |
0067888ee9c33c26b7b8488de6a54aac5aae0130 | 157e2e7049b52d7fcab19c32af2da6671f97bc6a | /spectral/jtreespectral/Eigen/src/plugins/CommonCwiseUnaryOps.h | 261ddc00e2425c2a31df013ce95ed35933d8ea96 | [] | no_license | pranjul23/NASA | b5526b2f1aa192bc2a671f812e1ee8a68be20706 | 14c1a1eccaae7f9e16f277f22d79475391534c48 | refs/heads/master | 2020-04-01T18:45:02.678578 | 2014-01-30T05:30:04 | 2014-01-30T05:30:04 | 10,201,519 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,554 | h | // This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2009 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// Eigen is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// Alternatively, you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>.
// This file is a base class plugin containing common coefficient wise functions.
#ifndef EIGEN_PARSED_BY_DOXYGEN
/** \internal Represents a scalar multiple of an expression */
typedef CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const Derived> ScalarMultipleReturnType;
/** \internal Represents a quotient of an expression by a scalar*/
typedef CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>, const Derived> ScalarQuotient1ReturnType;
/** \internal the return type of conjugate() */
typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
const CwiseUnaryOp<internal::scalar_conjugate_op<Scalar>, const Derived>,
const Derived&
>::type ConjugateReturnType;
/** \internal the return type of real() const */
typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
const CwiseUnaryOp<internal::scalar_real_op<Scalar>, const Derived>,
const Derived&
>::type RealReturnType;
/** \internal the return type of real() */
typedef typename internal::conditional<NumTraits<Scalar>::IsComplex,
CwiseUnaryView<internal::scalar_real_ref_op<Scalar>, Derived>,
Derived&
>::type NonConstRealReturnType;
/** \internal the return type of imag() const */
typedef CwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived> ImagReturnType;
/** \internal the return type of imag() */
typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType;
#endif // not EIGEN_PARSED_BY_DOXYGEN
/** \returns an expression of the opposite of \c *this
*/
inline const CwiseUnaryOp<internal::scalar_opposite_op<typename internal::traits<Derived>::Scalar>, const Derived>
operator-() const { return derived(); }
/** \returns an expression of \c *this scaled by the scalar factor \a scalar */
inline const ScalarMultipleReturnType
operator*(const Scalar& scalar) const
{
return CwiseUnaryOp<internal::scalar_multiple_op<Scalar>, const Derived>
(derived(), internal::scalar_multiple_op<Scalar>(scalar));
}
#ifdef EIGEN_PARSED_BY_DOXYGEN
const ScalarMultipleReturnType operator*(const RealScalar& scalar) const;
#endif
/** \returns an expression of \c *this divided by the scalar value \a scalar */
inline const CwiseUnaryOp<internal::scalar_quotient1_op<typename internal::traits<Derived>::Scalar>, const Derived>
operator/(const Scalar& scalar) const
{
return CwiseUnaryOp<internal::scalar_quotient1_op<Scalar>, const Derived>
(derived(), internal::scalar_quotient1_op<Scalar>(scalar));
}
/** Overloaded for efficient real matrix times complex scalar value */
inline const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived>
operator*(const std::complex<Scalar>& scalar) const
{
return CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived>
(*static_cast<const Derived*>(this), internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >(scalar));
}
inline friend const ScalarMultipleReturnType
operator*(const Scalar& scalar, const StorageBaseType& matrix)
{ return matrix*scalar; }
inline friend const CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >, const Derived>
operator*(const std::complex<Scalar>& scalar, const StorageBaseType& matrix)
{ return matrix*scalar; }
/** \returns an expression of *this with the \a Scalar type casted to
* \a NewScalar.
*
* The template parameter \a NewScalar is the type we are casting the scalars to.
*
* \sa class CwiseUnaryOp
*/
template<typename NewType>
typename internal::cast_return_type<Derived,const CwiseUnaryOp<internal::scalar_cast_op<typename internal::traits<Derived>::Scalar, NewType>, const Derived> >::type
cast() const
{
return derived();
}
/** \returns an expression of the complex conjugate of \c *this.
*
* \sa adjoint() */
inline ConjugateReturnType
conjugate() const
{
return ConjugateReturnType(derived());
}
/** \returns a read-only expression of the real part of \c *this.
*
* \sa imag() */
inline RealReturnType
real() const { return derived(); }
/** \returns an read-only expression of the imaginary part of \c *this.
*
* \sa real() */
inline const ImagReturnType
imag() const { return derived(); }
/** \brief Apply a unary operator coefficient-wise
* \param[in] func Functor implementing the unary operator
* \tparam CustomUnaryOp Type of \a func
* \returns An expression of a custom coefficient-wise unary operator \a func of *this
*
* The function \c ptr_fun() from the C++ standard library can be used to make functors out of normal functions.
*
* Example:
* \include class_CwiseUnaryOp_ptrfun.cpp
* Output: \verbinclude class_CwiseUnaryOp_ptrfun.out
*
* Genuine functors allow for more possibilities, for instance it may contain a state.
*
* Example:
* \include class_CwiseUnaryOp.cpp
* Output: \verbinclude class_CwiseUnaryOp.out
*
* \sa class CwiseUnaryOp, class CwiseBinaryOp
*/
template<typename CustomUnaryOp>
inline const CwiseUnaryOp<CustomUnaryOp, const Derived>
unaryExpr(const CustomUnaryOp& func = CustomUnaryOp()) const
{
return CwiseUnaryOp<CustomUnaryOp, const Derived>(derived(), func);
}
/** \returns an expression of a custom coefficient-wise unary operator \a func of *this
*
* The template parameter \a CustomUnaryOp is the type of the functor
* of the custom unary operator.
*
* Example:
* \include class_CwiseUnaryOp.cpp
* Output: \verbinclude class_CwiseUnaryOp.out
*
* \sa class CwiseUnaryOp, class CwiseBinaryOp
*/
template<typename CustomViewOp>
inline const CwiseUnaryView<CustomViewOp, const Derived>
unaryViewExpr(const CustomViewOp& func = CustomViewOp()) const
{
return CwiseUnaryView<CustomViewOp, const Derived>(derived(), func);
}
/** \returns a non const expression of the real part of \c *this.
*
* \sa imag() */
inline NonConstRealReturnType
real() { return derived(); }
/** \returns a non const expression of the imaginary part of \c *this.
*
* \sa real() */
inline NonConstImagReturnType
imag() { return derived(); }
| [
"igoraries@gmail.com"
] | igoraries@gmail.com |
6aaec4bbc93121ca38fad721532d74e2ee544a40 | 9030ce2789a58888904d0c50c21591632eddffd7 | /SDK/ARKSurvivalEvolved_DinoSettings_Carnivore_Small_Kaprosuchus_parameters.hpp | 7a8b5d5686b0c1aad30ba37d0bbb1c4dbe170337 | [
"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 | 842 | hpp | #pragma once
// ARKSurvivalEvolved (332.8) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "ARKSurvivalEvolved_DinoSettings_Carnivore_Small_Kaprosuchus_classes.hpp"
namespace sdk
{
//---------------------------------------------------------------------------
//Parameters
//---------------------------------------------------------------------------
// Function DinoSettings_Carnivore_Small_Kaprosuchus.DinoSettings_Carnivore_Small_Kaprosuchus_C.ExecuteUbergraph_DinoSettings_Carnivore_Small_Kaprosuchus
struct UDinoSettings_Carnivore_Small_Kaprosuchus_C_ExecuteUbergraph_DinoSettings_Carnivore_Small_Kaprosuchus_Params
{
int EntryPoint; // (Parm, ZeroConstructor, IsPlainOldData)
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"sergey.2bite@gmail.com"
] | sergey.2bite@gmail.com |
28015cf2b91703073dd8b45d7934840385123ce9 | 5835b9bd44fb6a886b58e3c433b9fee2b28590b3 | /0216_combination_sum_iii/combination_sum.cc | 40189b1d7d6b564b617dcc94f9328acce3840815 | [
"MIT"
] | permissive | begeekmyfriend/leetcode | feef7a21f43a4a3b21756ee5b614f3a31e8af526 | f88bcf8006a12047bcc045ea25f2a46813baeb53 | refs/heads/master | 2023-07-08T10:28:18.623237 | 2023-01-09T11:45:36 | 2023-01-09T11:45:36 | 37,474,686 | 3,346 | 982 | MIT | 2021-10-05T16:10:15 | 2015-06-15T15:44:58 | C | UTF-8 | C++ | false | false | 666 | cc | #include <stdc++.h>
using namespace std;
class Solution {
public:
vector<vector<int>> combinationSum3(int k, int n) {
vector<vector<int>> res;
dfs(1, 9, k, n, res);
return res;
}
private:
vector<int> stack;
void dfs(int start, int size, int k, int target, vector<vector<int>>& res) {
if (stack.size() == k) {
if (target == 0) {
res.push_back(stack);
}
} else {
for (int i = start; i <= size; i++) {
stack.push_back(i);
dfs(i + 1, size, k, target - i, res);
stack.pop_back();
}
}
}
};
| [
"begeekmyfriend@gmail.com"
] | begeekmyfriend@gmail.com |
d561dcd30e820b1f2f9a7a7e647d26d2e80c028f | 8ae9bdbb56622e7eb2fe7cf700b8fe4b7bd6e7ae | /llvm-3.8.0-r267675/lib/IR/Dominators.cpp | 37a4e68e6cdd8a42226bfd5be5852d45013683f1 | [
"NCSA"
] | permissive | mapu/toolchains | f61aa8b64d1dce5e618f0ff919d91dd5b664e901 | 3a6fea03c6a7738091e980b9cdee0447eb08bb1d | refs/heads/master | 2021-09-16T00:07:16.731713 | 2017-12-29T04:09:01 | 2017-12-29T04:09:01 | 104,563,481 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,398 | cpp | //===- Dominators.cpp - Dominator Calculation -----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements simple dominator construction algorithms for finding
// forward dominators. Postdominators are available in libanalysis, but are not
// included in libvmcore, because it's not needed. Forward dominators are
// needed to support the Verifier pass.
//
//===----------------------------------------------------------------------===//
#include "llvm/IR/Dominators.h"
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/IR/CFG.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/GenericDomTreeConstruction.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
using namespace llvm;
// Always verify dominfo if expensive checking is enabled.
#ifdef XDEBUG
static bool VerifyDomInfo = true;
#else
static bool VerifyDomInfo = false;
#endif
static cl::opt<bool,true>
VerifyDomInfoX("verify-dom-info", cl::location(VerifyDomInfo),
cl::desc("Verify dominator info (time consuming)"));
bool BasicBlockEdge::isSingleEdge() const {
const TerminatorInst *TI = Start->getTerminator();
unsigned NumEdgesToEnd = 0;
for (unsigned int i = 0, n = TI->getNumSuccessors(); i < n; ++i) {
if (TI->getSuccessor(i) == End)
++NumEdgesToEnd;
if (NumEdgesToEnd >= 2)
return false;
}
assert(NumEdgesToEnd == 1);
return true;
}
//===----------------------------------------------------------------------===//
// DominatorTree Implementation
//===----------------------------------------------------------------------===//
//
// Provide public access to DominatorTree information. Implementation details
// can be found in Dominators.h, GenericDomTree.h, and
// GenericDomTreeConstruction.h.
//
//===----------------------------------------------------------------------===//
template class llvm::DomTreeNodeBase<BasicBlock>;
template class llvm::DominatorTreeBase<BasicBlock>;
template void llvm::Calculate<Function, BasicBlock *>(
DominatorTreeBase<GraphTraits<BasicBlock *>::NodeType> &DT, Function &F);
template void llvm::Calculate<Function, Inverse<BasicBlock *>>(
DominatorTreeBase<GraphTraits<Inverse<BasicBlock *>>::NodeType> &DT,
Function &F);
// dominates - Return true if Def dominates a use in User. This performs
// the special checks necessary if Def and User are in the same basic block.
// Note that Def doesn't dominate a use in Def itself!
bool DominatorTree::dominates(const Instruction *Def,
const Instruction *User) const {
const BasicBlock *UseBB = User->getParent();
const BasicBlock *DefBB = Def->getParent();
// Any unreachable use is dominated, even if Def == User.
if (!isReachableFromEntry(UseBB))
return true;
// Unreachable definitions don't dominate anything.
if (!isReachableFromEntry(DefBB))
return false;
// An instruction doesn't dominate a use in itself.
if (Def == User)
return false;
// The value defined by an invoke dominates an instruction only if it
// dominates every instruction in UseBB.
// A PHI is dominated only if the instruction dominates every possible use in
// the UseBB.
if (isa<InvokeInst>(Def) || isa<PHINode>(User))
return dominates(Def, UseBB);
if (DefBB != UseBB)
return dominates(DefBB, UseBB);
// Loop through the basic block until we find Def or User.
BasicBlock::const_iterator I = DefBB->begin();
for (; &*I != Def && &*I != User; ++I)
/*empty*/;
return &*I == Def;
}
// true if Def would dominate a use in any instruction in UseBB.
// note that dominates(Def, Def->getParent()) is false.
bool DominatorTree::dominates(const Instruction *Def,
const BasicBlock *UseBB) const {
const BasicBlock *DefBB = Def->getParent();
// Any unreachable use is dominated, even if DefBB == UseBB.
if (!isReachableFromEntry(UseBB))
return true;
// Unreachable definitions don't dominate anything.
if (!isReachableFromEntry(DefBB))
return false;
if (DefBB == UseBB)
return false;
// Invoke results are only usable in the normal destination, not in the
// exceptional destination.
if (const auto *II = dyn_cast<InvokeInst>(Def)) {
BasicBlock *NormalDest = II->getNormalDest();
BasicBlockEdge E(DefBB, NormalDest);
return dominates(E, UseBB);
}
return dominates(DefBB, UseBB);
}
bool DominatorTree::dominates(const BasicBlockEdge &BBE,
const BasicBlock *UseBB) const {
// Assert that we have a single edge. We could handle them by simply
// returning false, but since isSingleEdge is linear on the number of
// edges, the callers can normally handle them more efficiently.
assert(BBE.isSingleEdge() &&
"This function is not efficient in handling multiple edges");
// If the BB the edge ends in doesn't dominate the use BB, then the
// edge also doesn't.
const BasicBlock *Start = BBE.getStart();
const BasicBlock *End = BBE.getEnd();
if (!dominates(End, UseBB))
return false;
// Simple case: if the end BB has a single predecessor, the fact that it
// dominates the use block implies that the edge also does.
if (End->getSinglePredecessor())
return true;
// The normal edge from the invoke is critical. Conceptually, what we would
// like to do is split it and check if the new block dominates the use.
// With X being the new block, the graph would look like:
//
// DefBB
// /\ . .
// / \ . .
// / \ . .
// / \ | |
// A X B C
// | \ | /
// . \|/
// . NormalDest
// .
//
// Given the definition of dominance, NormalDest is dominated by X iff X
// dominates all of NormalDest's predecessors (X, B, C in the example). X
// trivially dominates itself, so we only have to find if it dominates the
// other predecessors. Since the only way out of X is via NormalDest, X can
// only properly dominate a node if NormalDest dominates that node too.
for (const_pred_iterator PI = pred_begin(End), E = pred_end(End);
PI != E; ++PI) {
const BasicBlock *BB = *PI;
if (BB == Start)
continue;
if (!dominates(End, BB))
return false;
}
return true;
}
bool DominatorTree::dominates(const BasicBlockEdge &BBE, const Use &U) const {
// Assert that we have a single edge. We could handle them by simply
// returning false, but since isSingleEdge is linear on the number of
// edges, the callers can normally handle them more efficiently.
assert(BBE.isSingleEdge() &&
"This function is not efficient in handling multiple edges");
Instruction *UserInst = cast<Instruction>(U.getUser());
// A PHI in the end of the edge is dominated by it.
PHINode *PN = dyn_cast<PHINode>(UserInst);
if (PN && PN->getParent() == BBE.getEnd() &&
PN->getIncomingBlock(U) == BBE.getStart())
return true;
// Otherwise use the edge-dominates-block query, which
// handles the crazy critical edge cases properly.
const BasicBlock *UseBB;
if (PN)
UseBB = PN->getIncomingBlock(U);
else
UseBB = UserInst->getParent();
return dominates(BBE, UseBB);
}
bool DominatorTree::dominates(const Instruction *Def, const Use &U) const {
Instruction *UserInst = cast<Instruction>(U.getUser());
const BasicBlock *DefBB = Def->getParent();
// Determine the block in which the use happens. PHI nodes use
// their operands on edges; simulate this by thinking of the use
// happening at the end of the predecessor block.
const BasicBlock *UseBB;
if (PHINode *PN = dyn_cast<PHINode>(UserInst))
UseBB = PN->getIncomingBlock(U);
else
UseBB = UserInst->getParent();
// Any unreachable use is dominated, even if Def == User.
if (!isReachableFromEntry(UseBB))
return true;
// Unreachable definitions don't dominate anything.
if (!isReachableFromEntry(DefBB))
return false;
// Invoke instructions define their return values on the edges to their normal
// successors, so we have to handle them specially.
// Among other things, this means they don't dominate anything in
// their own block, except possibly a phi, so we don't need to
// walk the block in any case.
if (const InvokeInst *II = dyn_cast<InvokeInst>(Def)) {
BasicBlock *NormalDest = II->getNormalDest();
BasicBlockEdge E(DefBB, NormalDest);
return dominates(E, U);
}
// If the def and use are in different blocks, do a simple CFG dominator
// tree query.
if (DefBB != UseBB)
return dominates(DefBB, UseBB);
// Ok, def and use are in the same block. If the def is an invoke, it
// doesn't dominate anything in the block. If it's a PHI, it dominates
// everything in the block.
if (isa<PHINode>(UserInst))
return true;
// Otherwise, just loop through the basic block until we find Def or User.
BasicBlock::const_iterator I = DefBB->begin();
for (; &*I != Def && &*I != UserInst; ++I)
/*empty*/;
return &*I != UserInst;
}
bool DominatorTree::isReachableFromEntry(const Use &U) const {
Instruction *I = dyn_cast<Instruction>(U.getUser());
// ConstantExprs aren't really reachable from the entry block, but they
// don't need to be treated like unreachable code either.
if (!I) return true;
// PHI nodes use their operands on their incoming edges.
if (PHINode *PN = dyn_cast<PHINode>(I))
return isReachableFromEntry(PN->getIncomingBlock(U));
// Everything else uses their operands in their own block.
return isReachableFromEntry(I->getParent());
}
void DominatorTree::verifyDomTree() const {
Function &F = *getRoot()->getParent();
DominatorTree OtherDT;
OtherDT.recalculate(F);
if (compare(OtherDT)) {
errs() << "DominatorTree is not up to date!\nComputed:\n";
print(errs());
errs() << "\nActual:\n";
OtherDT.print(errs());
abort();
}
}
//===----------------------------------------------------------------------===//
// DominatorTreeAnalysis and related pass implementations
//===----------------------------------------------------------------------===//
//
// This implements the DominatorTreeAnalysis which is used with the new pass
// manager. It also implements some methods from utility passes.
//
//===----------------------------------------------------------------------===//
DominatorTree DominatorTreeAnalysis::run(Function &F) {
DominatorTree DT;
DT.recalculate(F);
return DT;
}
char DominatorTreeAnalysis::PassID;
DominatorTreePrinterPass::DominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses DominatorTreePrinterPass::run(Function &F,
FunctionAnalysisManager &AM) {
OS << "DominatorTree for function: " << F.getName() << "\n";
AM.getResult<DominatorTreeAnalysis>(F).print(OS);
return PreservedAnalyses::all();
}
PreservedAnalyses DominatorTreeVerifierPass::run(Function &F,
FunctionAnalysisManager &AM) {
AM.getResult<DominatorTreeAnalysis>(F).verifyDomTree();
return PreservedAnalyses::all();
}
//===----------------------------------------------------------------------===//
// DominatorTreeWrapperPass Implementation
//===----------------------------------------------------------------------===//
//
// The implementation details of the wrapper pass that holds a DominatorTree
// suitable for use with the legacy pass manager.
//
//===----------------------------------------------------------------------===//
char DominatorTreeWrapperPass::ID = 0;
INITIALIZE_PASS(DominatorTreeWrapperPass, "domtree",
"Dominator Tree Construction", true, true)
bool DominatorTreeWrapperPass::runOnFunction(Function &F) {
DT.recalculate(F);
return false;
}
void DominatorTreeWrapperPass::verifyAnalysis() const {
if (VerifyDomInfo)
DT.verifyDomTree();
}
void DominatorTreeWrapperPass::print(raw_ostream &OS, const Module *) const {
DT.print(OS);
}
| [
"wangl@cb94f8c2-beb9-42d2-aaaf-6dc30ea5c36a"
] | wangl@cb94f8c2-beb9-42d2-aaaf-6dc30ea5c36a |
24d8c37f45b4e34cdc8a1360d58f6ca0fcd9a5fb | f07352ad4b071ed5e801f7a91028606911d8906a | /examples/rocketwar/src/shared/network/protocol.hpp | e158431bab3a1bb6feb5ae7cdc5c7806c0eb41b1 | [
"MIT"
] | permissive | AlexAUT/rocketWar | 426362513eca048d2dcb63dd76b87b1fc52f0cf6 | edea1c703755e198b1ad8909c82e5d8d56c443ef | refs/heads/master | 2020-05-19T09:41:44.905120 | 2019-08-11T12:07:56 | 2019-08-11T12:07:56 | 184,954,093 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,447 | hpp | #pragma once
#include "packet.hpp"
#include <aw/util/types.hpp>
#include <aw/util/reflection/typeDescriptorClass.hpp>
#include <aw/util/reflection/typeDescriptorEnum.hpp>
#include <aw/util/reflection/types/primitiveTypes.hpp>
#include <aw/util/reflection/types/vector.hpp>
#include <aw/util/type/bitwiseEnum.hpp>
namespace network
{
enum class Command : aw::uint8
{
Connect = 1,
Acknowledge = 2,
Disconnect = 4,
};
enum class TransmissionType : aw::uint8
{
Unreliable = 1,
Reliable = 2,
};
using ChannelId = aw::uint8;
// This channel is used for connection management. You should avoid using it for anything else
inline constexpr aw::uint8 ManagementChannelId = 0xFF;
struct ProtocolHeader
{
aw::uint8 channelId;
REFLECT();
};
struct ChannelHeader
{
Command command;
TransmissionType transmission;
aw::uint16 packetId;
REFLECT()
};
namespace packet
{
struct Acknowledge
{
std::vector<aw::uint16> packetIds;
REFLECT()
};
} // namespace packet
} // namespace network
REFLECT_ENUM(network::Command)
REFLECT_ENUM(network::TransmissionType)
REFLECT_BEGIN(network::ProtocolHeader)
REFLECT_MEMBER(channelId)
REFLECT_END(network::ProtocolHeader)
REFLECT_BEGIN(network::ChannelHeader)
REFLECT_MEMBER(command)
REFLECT_MEMBER(transmission)
REFLECT_MEMBER(packetId)
REFLECT_END(network::ChannelHeader)
REFLECT_BEGIN(network::packet::Acknowledge)
REFLECT_MEMBER(packetIds)
REFLECT_END(network::packet::Acknowledge)
| [
"alexander.weinrauch@gmail.com"
] | alexander.weinrauch@gmail.com |
70e0dded17e80fd5965b2d1ff20d53f58ad93653 | 89dedd7f3c7acc81d12e2bcb2e716f9af9e5fa04 | /third_party/WebKit/Source/core/css/cssom/CSSVariableReferenceValueTest.cpp | 457b236574178cbf6989076ee4dffa35f5c8b7c4 | [
"BSD-2-Clause",
"LGPL-2.1-only",
"LGPL-2.0-only",
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer",
"GPL-2.0-only",
"LicenseRef-scancode-other-copyleft",
"BSD-3-Clause"
] | permissive | bino7/chromium | 8d26f84a1b6e38a73d1b97fea6057c634eff68cb | 4666a6bb6fdcb1114afecf77bdaa239d9787b752 | refs/heads/master | 2022-12-22T14:31:53.913081 | 2016-09-06T10:05:11 | 2016-09-06T10:05:11 | 67,410,510 | 1 | 3 | BSD-3-Clause | 2022-12-17T03:08:52 | 2016-09-05T10:11:59 | null | UTF-8 | C++ | false | false | 2,198 | cpp | // 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.
#include "core/css/cssom/CSSStyleVariableReferenceValue.h"
#include "core/css/cssom/CSSTokenStreamValue.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace blink {
namespace {
StringOrCSSVariableReferenceValue getStringOrCSSVariableReferenceValue(String str)
{
StringOrCSSVariableReferenceValue temp;
temp.setString(str);
return temp;
}
StringOrCSSVariableReferenceValue getStringOrCSSVariableReferenceValue(CSSStyleVariableReferenceValue* ref)
{
StringOrCSSVariableReferenceValue temp;
temp.setCSSVariableReferenceValue(ref);
return temp;
}
CSSTokenStreamValue* tokenStreamValueFromString(String str)
{
HeapVector<StringOrCSSVariableReferenceValue> fragments;
fragments.append(getStringOrCSSVariableReferenceValue(str));
return CSSTokenStreamValue::create(fragments);
}
TEST(CSSVariableReferenceValueTest, EmptyList)
{
HeapVector<StringOrCSSVariableReferenceValue> fragments;
CSSTokenStreamValue* tokenStreamValue = CSSTokenStreamValue::create(fragments);
CSSStyleVariableReferenceValue* ref = CSSStyleVariableReferenceValue::create("test", tokenStreamValue);
EXPECT_EQ(ref->variable(), "test");
EXPECT_EQ(ref->fallback(), tokenStreamValue);
}
TEST(CSSVariableReferenceValueTest, MixedList)
{
HeapVector<StringOrCSSVariableReferenceValue> fragments;
StringOrCSSVariableReferenceValue x = getStringOrCSSVariableReferenceValue("Str");
StringOrCSSVariableReferenceValue y = getStringOrCSSVariableReferenceValue(CSSStyleVariableReferenceValue::create("Variable", tokenStreamValueFromString("Fallback")));
StringOrCSSVariableReferenceValue z;
fragments.append(x);
fragments.append(y);
fragments.append(z);
CSSTokenStreamValue* tokenStreamValue = CSSTokenStreamValue::create(fragments);
CSSStyleVariableReferenceValue* ref = CSSStyleVariableReferenceValue::create("test", tokenStreamValue);
EXPECT_EQ(ref->variable(), "test");
EXPECT_EQ(ref->fallback(), tokenStreamValue);
}
} // namespace
} // namespace blink
| [
"bino.zh@gmail.com"
] | bino.zh@gmail.com |
e12eea177997d836edc99ac1393c3a3dc5f95064 | c124ebdd41bf145ec6e9b97a4fd3068359f7e589 | /src/TMinimalSpanningTrack.hxx | 8a6ea90079674b5199671b2a434fbd7822713064 | [] | no_license | captain-col/captRecon | fc764bf5e2c114567df380bc919e043f2c891d7d | 71bba82827a4c2830027511018ddd241559e6271 | refs/heads/master | 2021-01-23T06:15:18.625000 | 2019-03-21T20:11:13 | 2019-03-21T20:11:13 | 102,495,440 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,924 | hxx | #ifndef TMinimalSpanningTrack_hxx_seen
#define TMinimalSpanningTrack_hxx_seen
#include <TAlgorithm.hxx>
#include <TAlgorithmResult.hxx>
namespace CP {
class TMinimalSpanningTrack;
};
/// This takes a algorithm result with clusters (e.g. from TClusterSlice or
/// TClusterMerge), and turns them into track candidates. The candidates are
/// found by forming a minimal spanning tree for all of the clusters based on
/// the distance between the clusters. The spanning tree is then turned into
/// a (possibly) large set of tracks that are intended for later processing,
/// plus any clusters that don't get added to a track. The tracks are fit
/// using the TSegmentTrackFit.
///
/// \warning The result TReconObjectContainer (in the TAlgorithmResult) will
/// probably contain both tracks and clusters.
class CP::TMinimalSpanningTrack
: public CP::TAlgorithm {
public:
TMinimalSpanningTrack();
virtual ~TMinimalSpanningTrack();
/// Apply the algorithm.
CP::THandle<CP::TAlgorithmResult>
Process(const CP::TAlgorithmResult& input,
const CP::TAlgorithmResult& input1 = CP::TAlgorithmResult::Empty,
const CP::TAlgorithmResult& input2 = CP::TAlgorithmResult::Empty);
private:
/// The maximum distance between cluster centroids for an edge to be
/// included in the graph. This is an optimization to help the algorithm
/// beat the n-squared problem before the hit distance cut is applied.
double fDistCut;
/// The maximum distance between clusters based on the closest hits. This
/// is a "slightly" fuzzy cut since the distance is based on
/// ClusterVicinity and not the actual closest approach. Any clusters
/// that are closer than this will have an edge placed into the graph.
/// This is an optimization to help short circuit the algorithm and reduce
/// the total number of edges.
double fHitDistCut;
};
#endif
| [
"clark.mcgrew@stonybrook.edu"
] | clark.mcgrew@stonybrook.edu |
ca224a817c9249e93ed3588868d09dde5da9391b | 29b34bd462e6749b6c34f1a56c838db0250763d0 | /TRICOUNT.cpp | 5202b8a96d35b319736cb7c45759b27d07ef481b | [] | no_license | aashishsingh2803/spojsolutions | 7da2f7d769777fcbad95a295a102bfbe55f1f61e | 140c714ac11ff16b7021017993768f2b9cb1c9b8 | refs/heads/master | 2021-01-20T14:07:30.803714 | 2017-02-21T23:44:07 | 2017-02-21T23:44:07 | 82,737,803 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 314 | cpp | #include <stdio.h>
#include <bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
unsigned long long int n,sum;
cin>>n;
if(n%2==0)
{
sum=n*(n+2)*(2*n+1)/8;
cout<<sum<<"\n";
}
else
{
sum=(n*(n+2)*(2*n+1)-1)/8;
cout<<sum<<"\n";
}
}
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
debc5c15a201c34cd6eda5bb8ad24b138a4274f3 | 3cf9f927fbc747090091642d37fb803b606b7e2f | /inc/sfe/twraptext.inl | 65780fa2013205c9e1129a3b4fa4c6515ec783dc | [] | no_license | Breush/evilly-evil-villains | d734dd7ce97c727fab8e4a67097170ef7f381d22 | f499963e9c2cfdc7c4fed42ca7b8c3d2bc7ecbe9 | refs/heads/master | 2022-07-09T18:24:18.996382 | 2022-06-22T07:08:38 | 2022-06-22T07:08:38 | 29,420,434 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,803 | inl | #include "tools/tools.hpp"
#include "tools/int.hpp"
#include <sstream>
namespace sfe
{
//-------------------//
//----- Routine -----//
template<class Text_t>
void WrapText<Text_t>::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform *= getTransform();
target.draw(m_text, states);
}
//--------------------//
//----- Wrappers -----//
template<class Text_t>
void WrapText<Text_t>::setString(const sf::String& string)
{
m_wrapString = string.toWideString();
rewrap();
}
template<class Text_t>
void WrapText<Text_t>::setFillColor(const sf::Color& color)
{
m_text.setFillColor(color);
}
template<class Text_t>
void WrapText<Text_t>::setOutlineColor(const sf::Color& color)
{
m_text.setOutlineColor(color);
}
template<class Text_t>
void WrapText<Text_t>::setOutlineThickness(float thickness)
{
m_text.setOutlineThickness(thickness);
}
template<class Text_t>
void WrapText<Text_t>::setCharacterSize(uint characterSize)
{
m_text.setCharacterSize(characterSize);
rewrap();
}
template<class Text_t>
void WrapText<Text_t>::setFont(const sf::Font& font)
{
m_text.setFont(font);
rewrap();
}
template<class Text_t>
void WrapText<Text_t>::setStyle(uint32 style)
{
m_text.setStyle(style);
rewrap();
}
//-------------------//
//----- Fitting -----//
template<class Text_t>
void WrapText<Text_t>::fitWidth(float inFitWidth)
{
m_fitWidth = inFitWidth;
rewrap();
}
//-----------------------------------//
//----- Internal changes update -----//
template<class Text_t>
void WrapText<Text_t>::rewrap()
{
returnif (m_fitWidth < 0.f);
// Word wrap - greedy algorithm
std::wstring prevString, string;
uint i = 0u;
while (i != m_wrapString.size()) {
std::wstring word;
wchar_t c;
// Get word
while (i < m_wrapString.size() && !iswspace(c = m_wrapString[i])) {
word += c;
++i;
}
// Update string, and add a Return character
// between last words if we went to far
string += word;
m_text.setString(string);
if (boundsSize(m_text).x > m_fitWidth) {
string = prevString + L'\n' + word;
m_text.setString(string);
}
prevString = string;
// Add separators
while (i < m_wrapString.size() && iswspace(c = m_wrapString[i])) {
string += c;
++i;
}
}
}
}
| [
"alexis.breust@gmail.com"
] | alexis.breust@gmail.com |
8b597c975d63505f2de6bfbcd811a6be31f86009 | 1577d73708a280359f6ced3e323f42b9ae7a4eab | /src/paint.cpp | 552b605b1bdba0c3a80f25be627dfc3c8266c1f3 | [
"MIT"
] | permissive | jklingen/paint | f67a4d3edd9e8e2961ea4c9085665467c8f105d9 | 58fd3ed34431c6cdd99e74f7a65d914a61ad45c6 | refs/heads/master | 2020-12-25T09:07:56.565927 | 2014-09-22T18:38:06 | 2014-09-22T18:38:06 | 20,573,082 | 0 | 0 | null | 2014-09-22T18:38:07 | 2014-06-06T18:01:56 | C++ | UTF-8 | C++ | false | false | 2,602 | cpp | /*
Copyright (c) 2014 kimmoli kimmo.lindholm@gmail.com @likimmo
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.
*/
#ifdef QT_QML_DEBUG
#include <QtQuick>
#endif
#include <sailfishapp.h>
#include <QtQml>
#include <QScopedPointer>
#include <QQuickView>
#include <QQmlEngine>
#include <QGuiApplication>
#include <QQmlContext>
#include <QCoreApplication>
#include "PainterClass.h"
#include "IconProvider.h"
#include "filemodel.h"
#include "nemothumbnailitem.h"
#include "nemothumbnailprovider.h"
int main(int argc, char *argv[])
{
qmlRegisterType<PainterClass>("harbour.paint.PainterClass", 1, 0, "Painter");
qmlRegisterType<Filemodel>("harbour.paint.Filemodel", 1, 0, "Filemodel");
qmlRegisterType<NemoThumbnailItem>("harbour.paint.Thumbnailer", 1, 0, "Thumbnail");
NemoThumbnailLoader *loader = new NemoThumbnailLoader;
loader->start(QThread::IdlePriority);
qAddPostRoutine(NemoThumbnailLoader::shutdown);
QScopedPointer<QGuiApplication> app(SailfishApp::application(argc, argv));
QTranslator translator;
translator.load("translations_" + QLocale::system().name(), "/usr/share/harbour-paint/i18n");
app->installTranslator(&translator);
QScopedPointer<QQuickView> view(SailfishApp::createView());
QQmlEngine *engine = view->engine();
engine->addImageProvider(QLatin1String("paintIcons"), new IconProvider);
engine->addImageProvider(QLatin1String("paintThumbnail"), new NemoThumbnailProvider);
view->setSource(SailfishApp::pathTo("qml/paint.qml"));
view->show();
return app->exec();
}
| [
"kimmo.lindholm@eke.fi"
] | kimmo.lindholm@eke.fi |
6f2591e907020ccf2d23e32dabee69999b00cf61 | 591b6b01d261750275b61c2f6dad55692b28c2ad | /FINAL_PROJECT/PR_Final_Simulation/PR_Final_Simulation/Town.h | 612de0145aaebedf8b95c79ae665e86c3cd16dab | [] | no_license | JoelSchroeder/CS273 | ec59c6a4a2f611597c9b87f417bb30d1ac9bf2eb | 28ea981d7eef15d502c64774941c33bc7639f081 | refs/heads/master | 2021-04-27T13:08:51.259309 | 2018-05-17T22:54:11 | 2018-05-17T22:54:11 | 122,433,517 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,816 | h | #ifndef TOWN_H_
#define TOWN_H_
#include <vector>
#include "Resident.h"
#include <iterator>
#include <set>
#include <stack>
#include "Waiting_Room.h"
#include "Emergency_Room.h"
#include "Random.h"
Random random;
class Town
{
private:
std::vector<Resident> residents;
int size;
int arrival_rate;
Emergency_Room *the_emergency_room;
Waiting_Room *the_waiting_room;
public:
Town(int rate, int docs, int nurs)//constructor for the town
{
size = 2000;
arrival_rate = rate;
std::set<string> names = initialize_names();
for (set<string>::iterator it = names.begin(); it != names.end(); ++it)
{
Resident new_res(*it);
residents.push_back(new_res);
}
the_waiting_room = new Waiting_Room();
the_emergency_room = new Emergency_Room(docs, nurs);
}
//reads the names form the files
std::set<string> initialize_names() {
std::set<string> names;
std::ifstream file("residents_of_273ville.txt");
std::ifstream file2("surnames_of_273ville.txt");
std::string line;
std::string line2;
for (int i = 0; i < 2000; i++) {
std::getline(file, line);
std::getline(file2, line2);
names.insert((line + " ") + line2);
}
file.close();
file2.close();
return names;
}
void run_simulation()
{
// run the simulation
for (int clock = 0; clock < 10080; ++clock)
{
//decide if a resident gets sick this round
if (random.next_int(60) < arrival_rate)
{
//find a random resident to become a patient
int sr = random.next_int(2000);
std::string name = residents[sr].get_name();
the_waiting_room->update(name, clock);
}
//update the ER
the_emergency_room->update(clock);
}
}
};
#endif | [
"noreply@github.com"
] | noreply@github.com |
ba214319e5862b13e186c88c97cff17d105c917b | 0ae250b35f040eacf05c3567b7f37b15a5c92d05 | /Program 1/Header.h | fd54f76864902e5db65364fbb5ee159225279816 | [] | no_license | milg15/exercisesC | edb88f725f66d7a8049779ae48f792af144ae68a | 1d8c270a0fb28b837f944575292bcbf083e77dbb | refs/heads/master | 2021-09-24T08:18:10.170317 | 2018-10-05T16:49:21 | 2018-10-05T16:49:21 | 104,624,448 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 704 | h | #include <iostream>
//markov incompleto
using namespace std;
enum Climas {nub, pnub, sol, psol};
char *NClimas[] = { "Nublado", "Parcialmente Nublado", "Soleado", "Parcialmente Soleado" };
void anadirClima(Climas * &vector, short &n, Climas cDay) {
if (n < 30)
vector[n] = cDay;
else if (n<=80) {
Climas *temp = new Climas[n];
for (short i = 0; i < n-1; i++)
temp[i] = vector[i];
temp[n-1] = cDay;
delete[] vector;
vector = temp;
}
else
return;
cout << vector[n-1];
n++;
return;
}
void mostrarClima(Climas *vector, short n) {
for (short i = 0; i < n; i++)
cout << "Dia " << i + 1 << " " << NClimas[int(vector[i])] << endl;
return;
}
| [
"noreply@github.com"
] | noreply@github.com |
7dd98a9ea29362dae4e7249e84a8200c06042571 | 95924c0f2f92c2aeb4aded2483acb3013887210f | /cpp/IntCodes.cpp | ab85fd10c2b906b129d03968107a04f67ed13be2 | [] | no_license | mimikrija/AdventOfCode2019 | e3455146f8ade942321a4ad661dca9a8560bde3d | 4bf772d69dc8d20ef530c9d5e3343449fa748862 | refs/heads/master | 2021-11-14T04:22:35.004787 | 2021-11-05T21:14:23 | 2021-11-05T21:18:51 | 225,138,614 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,121 | cpp | #include "IntCodes.h"
using namespace std;
int GetCode(int BigCode)
{
if (BigCode < 100) return BigCode;
else return BigCode % 10;
}
vector<int> CodesAndModes(int BigCode)
{
// code and modes would be more precise
// but this rhymes.
vector<int> CodesAndModes(4,0);
// 0-th entry is the code
CodesAndModes.at(0) = GetCode(BigCode);
// 1-th entry is the first parameter.. etc.
CodesAndModes.at(1) = (BigCode / 100) % 10;
CodesAndModes.at(2) = (BigCode / 1000) % 10;
CodesAndModes.at(3) = (BigCode / 10000) % 10;
// yes, this could have been a loop but it is
// actually more clear like this!
return CodesAndModes;
}
int NumberOfParameters(int code)
{
switch (code)
{
case 1: case 2: case 7: case 8:
return 3;
case 3: case 4: case 9:
return 1;
case 5: case 6:
return 2;
}
}
int GetResult(int code, int first, int second, int third)
{
switch (code)
{
case 1:
return first + second;
case 2:
return first*second;
case 4:
return first;
case 5: // FirstParameter != 0 ? pos = SecondParameter : pos += ParametersInCommand + 1;
if (first != 0) return second;
else return third;
break;
case 6: //FirstParameter == 0 ? pos = SecondParameter : pos += ParametersInCommand + 1;
if (first == 0) return second;
else return third;
break;
case 7:
if (first < second) return 1;
else return 0;
case 8:
if (first == second) return 1;
else return 0;
default:
return 0;
}
}
int OptCode(vector<int>& Program, int DefaultInput, bool &IsFinished, int &pos, int OptionalInput)
{
// Program is taken by reference because it is changed and needs to remain that way
// even after this runs
// Default Input depends on the day:
// day 02 - no input modes present, Input is a dummy
// day 05 - only one input per run, Input is defined in 05th_of_2019.cpp
// day 07 - two possible inputs: Input is the one that is always taken (from
// previous amplifier). OptionalInput is the phase setting of the amplifier.
// OptionalInput goes together with InitialRun boolean which governs whether
// to use it or not.
bool PhaseInput = true; // this makes sense only if OptionalInput is present (day 07)
// IsFinished, taken by reference as it serves to communicate to the main program
// whether that program is finished or not (hit code 99)
// pos position in the program. In days 02 and 05 not used, so we provide 0,
// otherwise this is provided as reference so that we can continue where we left
// off last time a program was run (day 07)
int Output = 0;
while (pos < Program.size())
{
int result;
vector<int> CodeAndMode = CodesAndModes(Program.at(pos));
int code = CodeAndMode.at(0);
if (code == 99)
{
pos++; // useless, but for the sake of completeness.
IsFinished = true;
return 0; //not that it matters?
// ugh I have to return something from this function, but I take care that
// the last (this) output is ignored when calling this function.
}
int ParametersInCommand = NumberOfParameters(code);
// get parameter indices
vector<int> ParameterIndices(ParametersInCommand);
auto it = CodeAndMode.begin() + 1;
for (auto& p : ParameterIndices)
{
int mode = *it;
int rel = it - CodeAndMode.begin();
it++;
switch (mode)
{
case 0: // position mode
p = Program.at(pos + rel);
break;
case 1: // imediate mode
p = pos + rel;
break;
//case 2: // relative mode
//p =
default:
break;
}
}
int PositionFirstParameter, PositionSecondParameter, PositionThirdParameter;
if (ParametersInCommand >= 1) PositionFirstParameter = ParameterIndices.at(0);
if (ParametersInCommand >= 2) PositionSecondParameter = ParameterIndices.at(1);
if (ParametersInCommand >= 3) PositionThirdParameter = ParameterIndices.at(2);
int first, second, third, WritePosition;
switch (code)
{
case 1: case 2: case 7: case 8:
first = Program.at(PositionFirstParameter);
second = Program.at(PositionSecondParameter);
result = GetResult(code, first, second);
WritePosition = PositionThirdParameter;
pos += ParametersInCommand + 1;
break;
case 3:
WritePosition = PositionFirstParameter;
OptionalInput >= 0 ? result = OptionalInput : result = DefaultInput;
if (PhaseInput) PhaseInput = false;
else result = DefaultInput;
pos += ParametersInCommand + 1;
break;
case 4:
result = Program.at(PositionFirstParameter);
pos += ParametersInCommand + 1;
Output = result;
break;
case 5:
first = Program.at(PositionFirstParameter);
second = Program.at(PositionSecondParameter);
third = pos + ParametersInCommand + 1;
pos = GetResult(code, first, second, third);
break;
case 6:
first = Program.at(PositionFirstParameter);
second = Program.at(PositionSecondParameter);
third = pos + ParametersInCommand + 1;
pos = GetResult(code, first, second, third);
break;
default:
break;
}
// write for modes which support writing
if (!(code == 4 || code == 5 || code == 6))
Program.at(WritePosition) = result;
// return if output code is called
if (code == 4) return Output;
}
} | [
"maja.gacesa@gmail.com"
] | maja.gacesa@gmail.com |
924c223a397820b2a2da6949cdc55c50d3dd8555 | 0807bf2ca2967b86a8fb25f07ee4dd07583c88fe | /src/miner.cpp | bcaaa81b5f7541b728b2eccf3551c57bf33b3ff5 | [
"MIT"
] | permissive | dmitriy79/enc | 6161a4542c90b0a7a9dc1a7bb06532f37f7aba06 | 4661d699cbdf77ce7aa1c3289e8629f1c1a645c2 | refs/heads/master | 2020-07-09T23:33:55.032572 | 2019-08-24T04:48:12 | 2019-08-24T04:48:12 | 204,109,457 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,542 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2015 The Bitcoin Core developers
// Copyright (c) 2014-2018 The Dash Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "miner.h"
#include "amount.h"
#include "chain.h"
#include "chainparams.h"
#include "coins.h"
#include "consensus/consensus.h"
#include "consensus/merkle.h"
#include "consensus/validation.h"
#include "hash.h"
#include "validation.h"
#include "net.h"
#include "policy/policy.h"
#include "pow.h"
#include "primitives/transaction.h"
#include "script/standard.h"
#include "timedata.h"
#include "txmempool.h"
#include "util.h"
#include "utilmoneystr.h"
#include "masternode-payments.h"
#include "masternode-sync.h"
#include "validationinterface.h"
#include "evo/specialtx.h"
#include "evo/cbtx.h"
#include "evo/simplifiedmns.h"
#include "evo/deterministicmns.h"
#include "llmq/quorums_blockprocessor.h"
#include "llmq/quorums_chainlocks.h"
#include <algorithm>
#include <boost/thread.hpp>
#include <boost/tuple/tuple.hpp>
#include <queue>
#include <utility>
//////////////////////////////////////////////////////////////////////////////
//
// EncocoinMiner
//
//
// Unconfirmed transactions in the memory pool often depend on other
// transactions in the memory pool. When we select transactions from the
// pool, we select by highest fee rate of a transaction combined with all
// its ancestors.
uint64_t nLastBlockTx = 0;
uint64_t nLastBlockSize = 0;
class ScoreCompare
{
public:
ScoreCompare() {}
bool operator()(const CTxMemPool::txiter a, const CTxMemPool::txiter b)
{
return CompareTxMemPoolEntryByScore()(*b,*a); // Convert to less than
}
};
int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev)
{
int64_t nOldTime = pblock->nTime;
int64_t nNewTime = std::max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
if (nOldTime < nNewTime)
pblock->nTime = nNewTime;
// Updating time can change work required on testnet:
if (consensusParams.fPowAllowMinDifficultyBlocks)
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, consensusParams);
return nNewTime - nOldTime;
}
BlockAssembler::Options::Options() {
blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);
nBlockMaxSize = DEFAULT_BLOCK_MAX_SIZE;
}
BlockAssembler::BlockAssembler(const CChainParams& params, const Options& options) : chainparams(params)
{
blockMinFeeRate = options.blockMinFeeRate;
// Limit size to between 1K and MaxBlockSize()-1K for sanity:
nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MaxBlockSize(fDIP0001ActiveAtTip) - 1000), (unsigned int)options.nBlockMaxSize));
}
static BlockAssembler::Options DefaultOptions(const CChainParams& params)
{
// Block resource limits
BlockAssembler::Options options;
options.nBlockMaxSize = DEFAULT_BLOCK_MAX_SIZE;
if (IsArgSet("-blockmaxsize")) {
options.nBlockMaxSize = GetArg("-blockmaxsize", DEFAULT_BLOCK_MAX_SIZE);
}
if (IsArgSet("-blockmintxfee")) {
CAmount n = 0;
ParseMoney(GetArg("-blockmintxfee", ""), n);
options.blockMinFeeRate = CFeeRate(n);
} else {
options.blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);
}
return options;
}
BlockAssembler::BlockAssembler(const CChainParams& params) : BlockAssembler(params, DefaultOptions(params)) {}
void BlockAssembler::resetBlock()
{
inBlock.clear();
// Reserve space for coinbase tx
nBlockSize = 1000;
nBlockSigOps = 100;
// These counters do not include coinbase tx
nBlockTx = 0;
nFees = 0;
}
std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
{
int64_t nTimeStart = GetTimeMicros();
resetBlock();
pblocktemplate.reset(new CBlockTemplate());
if(!pblocktemplate.get())
return nullptr;
pblock = &pblocktemplate->block; // pointer for convenience
// Add dummy coinbase tx as first transaction
pblock->vtx.emplace_back();
pblocktemplate->vTxFees.push_back(-1); // updated at end
pblocktemplate->vTxSigOps.push_back(-1); // updated at end
LOCK2(cs_main, mempool.cs);
CBlockIndex* pindexPrev = chainActive.Tip();
nHeight = pindexPrev->nHeight + 1;
bool fDIP0003Active_context = nHeight >= chainparams.GetConsensus().DIP0003Height;
bool fDIP0008Active_context = VersionBitsState(chainActive.Tip(), chainparams.GetConsensus(), Consensus::DEPLOYMENT_DIP0008, versionbitscache) == THRESHOLD_ACTIVE;
pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus(), chainparams.BIP9CheckMasternodesUpgraded());
// -regtest only: allow overriding block.nVersion with
// -blockversion=N to test forking scenarios
if (chainparams.MineBlocksOnDemand())
pblock->nVersion = GetArg("-blockversion", pblock->nVersion);
pblock->nTime = GetAdjustedTime();
const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast();
nLockTimeCutoff = (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST)
? nMedianTimePast
: pblock->GetBlockTime();
if (fDIP0003Active_context) {
for (auto& p : chainparams.GetConsensus().llmqs) {
CTransactionRef qcTx;
if (llmq::quorumBlockProcessor->GetMinableCommitmentTx(p.first, nHeight, qcTx)) {
pblock->vtx.emplace_back(qcTx);
pblocktemplate->vTxFees.emplace_back(0);
pblocktemplate->vTxSigOps.emplace_back(0);
nBlockSize += qcTx->GetTotalSize();
++nBlockTx;
}
}
}
int nPackagesSelected = 0;
int nDescendantsUpdated = 0;
addPackageTxs(nPackagesSelected, nDescendantsUpdated);
int64_t nTime1 = GetTimeMicros();
nLastBlockTx = nBlockTx;
nLastBlockSize = nBlockSize;
LogPrintf("CreateNewBlock(): total size %u txs: %u fees: %ld sigops %d\n", nBlockSize, nBlockTx, nFees, nBlockSigOps);
// Create coinbase transaction.
CMutableTransaction coinbaseTx;
coinbaseTx.vin.resize(1);
coinbaseTx.vin[0].prevout.SetNull();
coinbaseTx.vout.resize(1);
coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
// NOTE: unlike in bitcoin, we need to pass PREVIOUS block height here
CAmount blockReward = nFees + GetBlockSubsidy(pindexPrev->nBits, pindexPrev->nHeight, Params().GetConsensus());
// Compute regular coinbase transaction.
coinbaseTx.vout[0].nValue = blockReward;
if (!fDIP0003Active_context) {
coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
} else {
coinbaseTx.vin[0].scriptSig = CScript() << OP_RETURN;
coinbaseTx.nVersion = 3;
coinbaseTx.nType = TRANSACTION_COINBASE;
CCbTx cbTx;
if (fDIP0008Active_context) {
cbTx.nVersion = 2;
} else {
cbTx.nVersion = 1;
}
cbTx.nHeight = nHeight;
CValidationState state;
if (!CalcCbTxMerkleRootMNList(*pblock, pindexPrev, cbTx.merkleRootMNList, state)) {
throw std::runtime_error(strprintf("%s: CalcCbTxMerkleRootMNList failed: %s", __func__, FormatStateMessage(state)));
}
if (fDIP0008Active_context) {
if (!CalcCbTxMerkleRootQuorums(*pblock, pindexPrev, cbTx.merkleRootQuorums, state)) {
throw std::runtime_error(strprintf("%s: CalcCbTxMerkleRootQuorums failed: %s", __func__, FormatStateMessage(state)));
}
}
SetTxPayload(coinbaseTx, cbTx);
}
// Update coinbase transaction with additional info about masternode and governance payments,
// get some info back to pass to getblocktemplate
FillBlockPayments(coinbaseTx, nHeight, blockReward, pblocktemplate->voutMasternodePayments, pblocktemplate->voutSuperblockPayments);
// LogPrintf("CreateNewBlock -- nBlockHeight %d blockReward %lld txoutMasternode %s coinbaseTx %s",
// nHeight, blockReward, pblocktemplate->txoutsMasternode.ToString(), coinbaseTx.ToString());
pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
pblocktemplate->vTxFees[0] = -nFees;
// Fill in header
pblock->hashPrevBlock = pindexPrev->GetBlockHash();
UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
pblock->nNonce = 0;
pblocktemplate->nPrevBits = pindexPrev->nBits;
pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(*pblock->vtx[0]);
CValidationState state;
if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) {
throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, FormatStateMessage(state)));
}
int64_t nTime2 = GetTimeMicros();
LogPrint("bench", "CreateNewBlock() packages: %.2fms (%d packages, %d updated descendants), validity: %.2fms (total %.2fms)\n", 0.001 * (nTime1 - nTimeStart), nPackagesSelected, nDescendantsUpdated, 0.001 * (nTime2 - nTime1), 0.001 * (nTime2 - nTimeStart));
return std::move(pblocktemplate);
}
void BlockAssembler::onlyUnconfirmed(CTxMemPool::setEntries& testSet)
{
for (CTxMemPool::setEntries::iterator iit = testSet.begin(); iit != testSet.end(); ) {
// Only test txs not already in the block
if (inBlock.count(*iit)) {
testSet.erase(iit++);
}
else {
iit++;
}
}
}
bool BlockAssembler::TestPackage(uint64_t packageSize, unsigned int packageSigOps)
{
if (nBlockSize + packageSize >= nBlockMaxSize)
return false;
if (nBlockSigOps + packageSigOps >= MaxBlockSigOps(fDIP0001ActiveAtTip))
return false;
return true;
}
// Perform transaction-level checks before adding to block:
// - transaction finality (locktime)
// - safe TXs in regard to ChainLocks
bool BlockAssembler::TestPackageTransactions(const CTxMemPool::setEntries& package)
{
BOOST_FOREACH (const CTxMemPool::txiter it, package) {
if (!IsFinalTx(it->GetTx(), nHeight, nLockTimeCutoff))
return false;
if (!llmq::chainLocksHandler->IsTxSafeForMining(it->GetTx().GetHash())) {
return false;
}
}
return true;
}
void BlockAssembler::AddToBlock(CTxMemPool::txiter iter)
{
pblock->vtx.emplace_back(iter->GetSharedTx());
pblocktemplate->vTxFees.push_back(iter->GetFee());
pblocktemplate->vTxSigOps.push_back(iter->GetSigOpCount());
nBlockSize += iter->GetTxSize();
++nBlockTx;
nBlockSigOps += iter->GetSigOpCount();
nFees += iter->GetFee();
inBlock.insert(iter);
bool fPrintPriority = GetBoolArg("-printpriority", DEFAULT_PRINTPRIORITY);
if (fPrintPriority) {
LogPrintf("fee %s txid %s\n",
CFeeRate(iter->GetModifiedFee(), iter->GetTxSize()).ToString(),
iter->GetTx().GetHash().ToString());
}
}
int BlockAssembler::UpdatePackagesForAdded(const CTxMemPool::setEntries& alreadyAdded,
indexed_modified_transaction_set &mapModifiedTx)
{
int nDescendantsUpdated = 0;
BOOST_FOREACH(const CTxMemPool::txiter it, alreadyAdded) {
CTxMemPool::setEntries descendants;
mempool.CalculateDescendants(it, descendants);
// Insert all descendants (not yet in block) into the modified set
BOOST_FOREACH(CTxMemPool::txiter desc, descendants) {
if (alreadyAdded.count(desc))
continue;
++nDescendantsUpdated;
modtxiter mit = mapModifiedTx.find(desc);
if (mit == mapModifiedTx.end()) {
CTxMemPoolModifiedEntry modEntry(desc);
modEntry.nSizeWithAncestors -= it->GetTxSize();
modEntry.nModFeesWithAncestors -= it->GetModifiedFee();
modEntry.nSigOpCountWithAncestors -= it->GetSigOpCount();
mapModifiedTx.insert(modEntry);
} else {
mapModifiedTx.modify(mit, update_for_parent_inclusion(it));
}
}
}
return nDescendantsUpdated;
}
// Skip entries in mapTx that are already in a block or are present
// in mapModifiedTx (which implies that the mapTx ancestor state is
// stale due to ancestor inclusion in the block)
// Also skip transactions that we've already failed to add. This can happen if
// we consider a transaction in mapModifiedTx and it fails: we can then
// potentially consider it again while walking mapTx. It's currently
// guaranteed to fail again, but as a belt-and-suspenders check we put it in
// failedTx and avoid re-evaluation, since the re-evaluation would be using
// cached size/sigops/fee values that are not actually correct.
bool BlockAssembler::SkipMapTxEntry(CTxMemPool::txiter it, indexed_modified_transaction_set &mapModifiedTx, CTxMemPool::setEntries &failedTx)
{
assert (it != mempool.mapTx.end());
if (mapModifiedTx.count(it) || inBlock.count(it) || failedTx.count(it))
return true;
return false;
}
void BlockAssembler::SortForBlock(const CTxMemPool::setEntries& package, CTxMemPool::txiter entry, std::vector<CTxMemPool::txiter>& sortedEntries)
{
// Sort package by ancestor count
// If a transaction A depends on transaction B, then A's ancestor count
// must be greater than B's. So this is sufficient to validly order the
// transactions for block inclusion.
sortedEntries.clear();
sortedEntries.insert(sortedEntries.begin(), package.begin(), package.end());
std::sort(sortedEntries.begin(), sortedEntries.end(), CompareTxIterByAncestorCount());
}
// This transaction selection algorithm orders the mempool based
// on feerate of a transaction including all unconfirmed ancestors.
// Since we don't remove transactions from the mempool as we select them
// for block inclusion, we need an alternate method of updating the feerate
// of a transaction with its not-yet-selected ancestors as we go.
// This is accomplished by walking the in-mempool descendants of selected
// transactions and storing a temporary modified state in mapModifiedTxs.
// Each time through the loop, we compare the best transaction in
// mapModifiedTxs with the next transaction in the mempool to decide what
// transaction package to work on next.
void BlockAssembler::addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated)
{
// mapModifiedTx will store sorted packages after they are modified
// because some of their txs are already in the block
indexed_modified_transaction_set mapModifiedTx;
// Keep track of entries that failed inclusion, to avoid duplicate work
CTxMemPool::setEntries failedTx;
// Start by adding all descendants of previously added txs to mapModifiedTx
// and modifying them for their already included ancestors
UpdatePackagesForAdded(inBlock, mapModifiedTx);
CTxMemPool::indexed_transaction_set::index<ancestor_score>::type::iterator mi = mempool.mapTx.get<ancestor_score>().begin();
CTxMemPool::txiter iter;
// Limit the number of attempts to add transactions to the block when it is
// close to full; this is just a simple heuristic to finish quickly if the
// mempool has a lot of entries.
const int64_t MAX_CONSECUTIVE_FAILURES = 1000;
int64_t nConsecutiveFailed = 0;
while (mi != mempool.mapTx.get<ancestor_score>().end() || !mapModifiedTx.empty())
{
// First try to find a new transaction in mapTx to evaluate.
if (mi != mempool.mapTx.get<ancestor_score>().end() &&
SkipMapTxEntry(mempool.mapTx.project<0>(mi), mapModifiedTx, failedTx)) {
++mi;
continue;
}
// Now that mi is not stale, determine which transaction to evaluate:
// the next entry from mapTx, or the best from mapModifiedTx?
bool fUsingModified = false;
modtxscoreiter modit = mapModifiedTx.get<ancestor_score>().begin();
if (mi == mempool.mapTx.get<ancestor_score>().end()) {
// We're out of entries in mapTx; use the entry from mapModifiedTx
iter = modit->iter;
fUsingModified = true;
} else {
// Try to compare the mapTx entry to the mapModifiedTx entry
iter = mempool.mapTx.project<0>(mi);
if (modit != mapModifiedTx.get<ancestor_score>().end() &&
CompareModifiedEntry()(*modit, CTxMemPoolModifiedEntry(iter))) {
// The best entry in mapModifiedTx has higher score
// than the one from mapTx.
// Switch which transaction (package) to consider
iter = modit->iter;
fUsingModified = true;
} else {
// Either no entry in mapModifiedTx, or it's worse than mapTx.
// Increment mi for the next loop iteration.
++mi;
}
}
// We skip mapTx entries that are inBlock, and mapModifiedTx shouldn't
// contain anything that is inBlock.
assert(!inBlock.count(iter));
uint64_t packageSize = iter->GetSizeWithAncestors();
CAmount packageFees = iter->GetModFeesWithAncestors();
unsigned int packageSigOps = iter->GetSigOpCountWithAncestors();
if (fUsingModified) {
packageSize = modit->nSizeWithAncestors;
packageFees = modit->nModFeesWithAncestors;
packageSigOps = modit->nSigOpCountWithAncestors;
}
if (packageFees < blockMinFeeRate.GetFee(packageSize)) {
// Everything else we might consider has a lower fee rate
return;
}
if (!TestPackage(packageSize, packageSigOps)) {
if (fUsingModified) {
// Since we always look at the best entry in mapModifiedTx,
// we must erase failed entries so that we can consider the
// next best entry on the next loop iteration
mapModifiedTx.get<ancestor_score>().erase(modit);
failedTx.insert(iter);
}
++nConsecutiveFailed;
if (nConsecutiveFailed > MAX_CONSECUTIVE_FAILURES && nBlockSize > nBlockMaxSize - 1000) {
// Give up if we're close to full and haven't succeeded in a while
break;
}
continue;
}
CTxMemPool::setEntries ancestors;
uint64_t nNoLimit = std::numeric_limits<uint64_t>::max();
std::string dummy;
mempool.CalculateMemPoolAncestors(*iter, ancestors, nNoLimit, nNoLimit, nNoLimit, nNoLimit, dummy, false);
onlyUnconfirmed(ancestors);
ancestors.insert(iter);
// Test if all tx's are Final and safe
if (!TestPackageTransactions(ancestors)) {
if (fUsingModified) {
mapModifiedTx.get<ancestor_score>().erase(modit);
failedTx.insert(iter);
}
continue;
}
// This transaction will make it in; reset the failed counter.
nConsecutiveFailed = 0;
// Package can be added. Sort the entries in a valid order.
std::vector<CTxMemPool::txiter> sortedEntries;
SortForBlock(ancestors, iter, sortedEntries);
for (size_t i=0; i<sortedEntries.size(); ++i) {
AddToBlock(sortedEntries[i]);
// Erase from the modified set, if present
mapModifiedTx.erase(sortedEntries[i]);
}
++nPackagesSelected;
// Update transactions that depend on each of these
nDescendantsUpdated += UpdatePackagesForAdded(ancestors, mapModifiedTx);
}
}
void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce)
{
// Update nExtraNonce
static uint256 hashPrevBlock;
if (hashPrevBlock != pblock->hashPrevBlock)
{
nExtraNonce = 0;
hashPrevBlock = pblock->hashPrevBlock;
}
++nExtraNonce;
unsigned int nHeight = pindexPrev->nHeight+1; // Height first in coinbase required for block.version=2
CMutableTransaction txCoinbase(*pblock->vtx[0]);
txCoinbase.vin[0].scriptSig = (CScript() << nHeight << CScriptNum(nExtraNonce)) + COINBASE_FLAGS;
assert(txCoinbase.vin[0].scriptSig.size() <= 100);
pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
}
| [
"sinoptik79@inbox.ru"
] | sinoptik79@inbox.ru |
e7a230f6c966bfec2a4fb51d245f6d75e7469368 | ee99ead6a052afdd51976829f102220c4b454fc8 | /LibLsp/JsonRpc/serializer.h | ef114d243a84103851ca469205d606e3d1a5b2db | [] | no_license | ShingenTakeda/LspCpp | b80947ed76b6e307923d89aa703f632b5f27af18 | 8b7367be52c70acfe9264b26f76f5aeb68ce8a85 | refs/heads/master | 2022-12-08T08:09:44.113881 | 2020-08-07T09:34:23 | 2020-08-07T09:34:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,209 | h | #pragma once
#include <macro_map.h>
#include "optional.h"
#include <cassert>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
#include <functional>
#include <map>
#include <algorithm>
struct AbsolutePath;
enum class SerializeFormat { Json, MessagePack };
// A tag type that can be used to write `null` to json.
struct JsonNull
{
void swap(JsonNull& arg) noexcept;
};
class Reader {
public:
virtual ~Reader() {}
virtual SerializeFormat Format() const = 0;
virtual bool IsBool() = 0;
virtual bool IsNull() = 0;
virtual bool IsArray() = 0;
virtual bool IsInt() = 0;
virtual bool IsInt64() = 0;
virtual bool IsUint64() = 0;
virtual bool IsDouble() = 0;
virtual bool IsString() = 0;
virtual void GetNull() = 0;
virtual bool GetBool() = 0;
virtual int GetInt() = 0;
virtual uint32_t GetUint32() = 0;
virtual int64_t GetInt64() = 0;
virtual uint64_t GetUint64() = 0;
virtual double GetDouble() = 0;
virtual std::string GetString() = 0;
virtual bool HasMember(const char* x) = 0;
virtual std::unique_ptr<Reader> operator[](const char* x) = 0;
virtual void IterMap( std::function<void(const char*, Reader&)> fn) = 0;
virtual void IterArray(std::function<void(Reader&)> fn) = 0;
virtual void DoMember(const char* name, std::function<void(Reader&)> fn) = 0;
virtual std::string ToString() const = 0;
};
class Writer {
public:
virtual ~Writer() {}
virtual SerializeFormat Format() const = 0;
virtual void Null() = 0;
virtual void Bool(bool x) = 0;
virtual void Int(int x) = 0;
virtual void Uint32(uint32_t x) = 0;
virtual void Int64(int64_t x) = 0;
virtual void Uint64(uint64_t x) = 0;
virtual void Double(double x) = 0;
virtual void String(const char* x) = 0;
virtual void String(const char* x, size_t len) = 0;
virtual void StartArray(size_t) = 0;
virtual void EndArray() = 0;
virtual void StartObject() = 0;
virtual void EndObject() = 0;
virtual void Key(const char* name) = 0;
};
struct optionals_mandatory_tag {};
#define REFLECT_MEMBER_START() ReflectMemberStart(visitor, value)
#define REFLECT_MEMBER_END() ReflectMemberEnd(visitor, value);
#define REFLECT_MEMBER_END1(value) ReflectMemberEnd(visitor, value);
#define REFLECT_MEMBER(name) ReflectMember(visitor, #name, value.name)
#define REFLECT_MEMBER_OPTIONALS(name) \
ReflectMember(visitor, #name, value.name, optionals_mandatory_tag{})
#define REFLECT_MEMBER2(name, value) ReflectMember(visitor, name, value)
#define MAKE_REFLECT_TYPE_PROXY(type_name) \
MAKE_REFLECT_TYPE_PROXY2(type_name, std::underlying_type<type_name>::type)
#define MAKE_REFLECT_TYPE_PROXY2(type, as_type) \
inline void Reflect(Reader& visitor, type& value) { \
as_type value0; \
::Reflect(visitor, value0); \
value = static_cast<type>(value0); \
} \
inline void Reflect(Writer& visitor, type& value) { \
auto value0 = static_cast<as_type>(value); \
::Reflect(visitor, value0); \
}
#define _MAPPABLE_REFLECT_MEMBER(name) REFLECT_MEMBER(name);
#define _MAPPABLE_REFLECT_MEMBER_OPTIONALS(name) REFLECT_MEMBER_OPTIONALS(name);
#define MAKE_REFLECT_EMPTY_STRUCT(type, ...) \
template <typename TVisitor> \
void Reflect(TVisitor& visitor, type& value) { \
REFLECT_MEMBER_START(); \
REFLECT_MEMBER_END(); \
}
#define MAKE_REFLECT_STRUCT(type, ...) \
template <typename TVisitor> \
void Reflect(TVisitor& visitor, type& value) { \
REFLECT_MEMBER_START(); \
MACRO_MAP(_MAPPABLE_REFLECT_MEMBER, __VA_ARGS__) \
REFLECT_MEMBER_END(); \
}
#define _MAPPABLE_SWAP_MEMBER(name) std::swap(name,arg.name);
#define MAKE_SWAP_METHOD(type, ...) \
void swap(type& arg) noexcept{ \
MACRO_MAP(_MAPPABLE_SWAP_MEMBER, __VA_ARGS__) \
}
#define MAKE_REFLECT_STRUCT_OPTIONALS_MANDATORY(type, ...) \
template <typename TVisitor> \
void Reflect(TVisitor& visitor, type& value) { \
REFLECT_MEMBER_START(); \
MACRO_MAP(_MAPPABLE_REFLECT_MEMBER_OPTIONALS, __VA_ARGS__) \
REFLECT_MEMBER_END(); \
}
// clang-format off
// Config has many fields, we need to support at least its number of fields.
#define NUM_VA_ARGS_IMPL(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,N,...) N
#define NUM_VA_ARGS(...) NUM_VA_ARGS_IMPL(__VA_ARGS__,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1)
// clang-format on
#define _MAPPABLE_REFLECT_ARRAY(name) Reflect(visitor, value.name);
// Reflects the struct so it is serialized as an array instead of an object.
// This currently only supports writers.
#define MAKE_REFLECT_STRUCT_WRITER_AS_ARRAY(type, ...) \
inline void Reflect(Writer& visitor, type& value) { \
visitor.StartArray(NUM_VA_ARGS(__VA_ARGS__)); \
MACRO_MAP(_MAPPABLE_REFLECT_ARRAY, __VA_ARGS__) \
visitor.EndArray(); \
}
//// Elementary types
void Reflect(Reader& visitor, uint8_t& value);
void Reflect(Writer& visitor, uint8_t& value);
void Reflect(Reader& visitor, short& value);
void Reflect(Writer& visitor, short& value);
void Reflect(Reader& visitor, unsigned short& value);
void Reflect(Writer& visitor, unsigned short& value);
void Reflect(Reader& visitor, int& value);
void Reflect(Writer& visitor, int& value);
void Reflect(Reader& visitor, unsigned& value);
void Reflect(Writer& visitor, unsigned& value);
void Reflect(Reader& visitor, long& value);
void Reflect(Writer& visitor, long& value);
void Reflect(Reader& visitor, unsigned long& value);
void Reflect(Writer& visitor, unsigned long& value);
void Reflect(Reader& visitor, long long& value);
void Reflect(Writer& visitor, long long& value);
void Reflect(Reader& visitor, unsigned long long& value);
void Reflect(Writer& visitor, unsigned long long& value);
void Reflect(Reader& visitor, double& value);
void Reflect(Writer& visitor, double& value);
void Reflect(Reader& visitor, bool& value);
void Reflect(Writer& visitor, bool& value);
void Reflect(Reader& visitor, std::string& value);
void Reflect(Writer& visitor, std::string& value);
void Reflect(Reader& visitor, JsonNull& value);
void Reflect(Writer& visitor, JsonNull& value);
void Reflect(Reader& visitor, SerializeFormat& value);
void Reflect(Writer& visitor, SerializeFormat& value);
//// Type constructors
template <typename T>
void Reflect(Reader& visitor, optional<T>& value) {
if (visitor.IsNull()) {
visitor.GetNull();
return;
}
T real_value;
Reflect(visitor, real_value);
value = std::move(real_value);
}
template <typename T>
void Reflect(Writer& visitor, optional<T>& value) {
if (value)
Reflect(visitor, *value);
else
visitor.Null();
}
template <typename T>
void ReflectMember(Writer& visitor, const char* name, optional<T>& value) {
// For TypeScript optional property key?: value in the spec,
// We omit both key and value if value is std::nullopt (null) for JsonWriter
// to reduce output. But keep it for other serialization formats.
if (value || visitor.Format() != SerializeFormat::Json) {
visitor.Key(name);
Reflect(visitor, value);
}
}
template <typename T>
void ReflectMember(Writer& visitor,
const char* name,
T& value,
optionals_mandatory_tag) {
visitor.Key(name);
Reflect(visitor, value);
}
template <typename T>
void ReflectMember(Reader& visitor,
const char* name,
T& value,
optionals_mandatory_tag) {
Reflect(visitor, value);
}
template<class T >
void Reflect(Reader& visitor, std::map<std::string, T>& value)
{
visitor.IterMap([&](const char* name,Reader& entry) {
T entry_value;
Reflect(entry, entry_value);
value[name]=(std::move(entry_value));
});
}
template<class _Ty >
void Reflect(Writer& visitor, std::map<std::string, _Ty>& value)
{
REFLECT_MEMBER_START();
for (auto& it : value)
{
visitor.Key(it.first.c_str());
Reflect(visitor, it.second);
}
REFLECT_MEMBER_END();
}
// std::vector
template <typename T>
void Reflect(Reader& visitor, std::vector<T>& values) {
visitor.IterArray([&](Reader& entry) {
T entry_value;
Reflect(entry, entry_value);
values.push_back(std::move(entry_value));
});
}
template <typename T>
void Reflect(Writer& visitor, std::vector<T>& values) {
visitor.StartArray(values.size());
for (auto& value : values)
Reflect(visitor, value);
visitor.EndArray();
}
// ReflectMember
inline void DefaultReflectMemberStart(Writer& visitor) {
visitor.StartObject();
}
inline void DefaultReflectMemberStart(Reader& visitor) {}
template <typename T>
bool ReflectMemberStart(Reader& visitor, T& value) {
return false;
}
template <typename T>
bool ReflectMemberStart(Writer& visitor, T& value) {
visitor.StartObject();
return true;
}
template <typename T>
void ReflectMemberEnd(Reader& visitor, T& value) {}
template <typename T>
void ReflectMemberEnd(Writer& visitor, T& value) {
visitor.EndObject();
}
template <typename T>
void ReflectMember(Reader& visitor, const char* name, T& value) {
visitor.DoMember(name, [&](Reader& child) { Reflect(child, value); });
}
template <typename T>
void ReflectMember(Writer& visitor, const char* name, T& value) {
visitor.Key(name);
Reflect(visitor, value);
}
template<class _Ty1, class _Ty2>
void Reflect(Writer& visitor, std::pair< optional<_Ty1>, optional<_Ty2> >& value)
{
if (value.first)
{
Reflect(visitor, value.first);
}
else if (value.second)
{
Reflect(visitor, value.second);
}
}
template<class _Ty2>
void Reflect(Reader& visitor, std::pair< optional<bool>, optional<_Ty2> >& value)
{
if(visitor.IsBool())
{
Reflect(visitor, value.first);
return;
}
Reflect(visitor, value.second);
}
template<class _Ty1, class _Ty2>
void Reflect(Reader& visitor, std::pair< optional<_Ty1>, optional<_Ty2> >& value)
{
try
{
Reflect(visitor, value.second);
}
catch (...)
{
Reflect(visitor, value.first);
}
}
| [
"731784510@qq.com"
] | 731784510@qq.com |
990ac139b2fb52ea67d9cfcd2ef41b485f52499b | e60ca08722245d732f86701cf28b581ac5eeb737 | /xbmc/music/tags/VorbisTag.h | 63b366ed6af0a2f1abbb43defc7c67626dfcf488 | [] | no_license | paulopina21/plxJukebox-11 | 6d915e60b3890ce01bc8a9e560342c982f32fbc7 | 193996ac99b99badab3a1d422806942afca2ad01 | refs/heads/master | 2020-04-09T13:31:35.220058 | 2013-02-06T17:31:23 | 2013-02-06T17:31:23 | 8,056,228 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 307 | h |
#include "Tag.h"
namespace MUSIC_INFO
{
#pragma once
class CVorbisTag : public CTag
{
public:
CVorbisTag(void);
virtual ~CVorbisTag(void);
int ParseTagEntry(CStdString& strTagEntry);
private:
void SplitEntry(const CStdString& strTagEntry, CStdString& strTagType, CStdString& strTagValue);
};
}
| [
"pontesmail@gmail.com"
] | pontesmail@gmail.com |
a7d02ee352cc790ed548e6265b3edd1db4e742ef | 258a8d35efb2f35aca22de0ed8391010ad31efbb | /segmentsFitting2D/segmentsFitting2D/squareModel.cpp | 3eed8a0bbb29fab7b03b1b5b358f62596294b82a | [] | no_license | hatsil/thesis | b8c88a0ebab1462156cde10a674f35449b1bc9e8 | ae26983ed69e3863287be8188a66c5ef3971b3d0 | refs/heads/master | 2020-03-26T09:35:33.730729 | 2018-10-09T13:08:48 | 2018-10-09T13:08:48 | 144,754,326 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 267 | cpp | #include "squareModel.hpp"
namespace thesis {
SquareModel::SquareModel():
positions({ {-1, 1}, {-1, -1}, {1, -1}, {1, 1} }),
texCoords({ {0, 0}, {0, 1}, {1, 1}, {1, 0} }),
indices({ 0, 2, 1, 0, 3, 2 }) {}
SquareModel::~SquareModel() {}
} /* namespace thesis */
| [
"tsahisa@post.bgu.ac.il"
] | tsahisa@post.bgu.ac.il |
3719406237c8b89a244fa4c7f9a689e7a8d34ed7 | fe2362eda423bb3574b651c21ebacbd6a1a9ac2a | /VTK-7.1.1/IO/Core/vtkGlobFileNames.h | 7ef3310d70ddb8a98ae1309d73fe43cda4a420d5 | [
"BSD-3-Clause"
] | permissive | likewatchk/python-pcl | 1c09c6b3e9de0acbe2f88ac36a858fe4b27cfaaf | 2a66797719f1b5af7d6a0d0893f697b3786db461 | refs/heads/master | 2023-01-04T06:17:19.652585 | 2020-10-15T21:26:58 | 2020-10-15T21:26:58 | 262,235,188 | 0 | 0 | NOASSERTION | 2020-05-08T05:29:02 | 2020-05-08T05:29:01 | null | UTF-8 | C++ | false | false | 3,807 | h | /*=========================================================================
Program: Visualization Toolkit
Module: vtkGlobFileNames.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
/**
* @class vtkGlobFileNames
* @brief find files that match a wildcard pattern
*
* vtkGlobFileNames is a utility for finding files and directories
* that match a given wildcard pattern. Allowed wildcards are
* *, ?, [...], [!...]. The "*" wildcard matches any substring,
* the "?" matches any single character, the [...] matches any one of
* the enclosed characters, e.g. [abc] will match one of a, b, or c,
* while [0-9] will match any digit, and [!...] will match any single
* character except for the ones within the brackets. Special
* treatment is given to "/" (or "\" on Windows) because these are
* path separators. These are never matched by a wildcard, they are
* only matched with another file separator.
* @warning
* This function performs case-sensitive matches on UNIX and
* case-insensitive matches on Windows.
* @sa
* vtkDirectory
*/
#ifndef vtkGlobFileNames_h
#define vtkGlobFileNames_h
#include "vtkIOCoreModule.h" // For export macro
#include "vtkObject.h"
class vtkStringArray;
class VTKIOCORE_EXPORT vtkGlobFileNames : public vtkObject
{
public:
//@{
/**
* Return the class name as a string.
*/
vtkTypeMacro(vtkGlobFileNames,vtkObject);
//@}
/**
* Create a new vtkGlobFileNames object.
*/
static vtkGlobFileNames *New();
/**
* Print directory to stream.
*/
void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
/**
* Reset the glob by clearing the list of output filenames.
*/
void Reset();
//@{
/**
* Set the directory in which to perform the glob. If this is
* not set, then the current directory will be used. Also, if
* you use a glob pattern that contains absolute path (one that
* starts with "/" or a drive letter) then that absolute path
* will be used and Directory will be ignored.
*/
vtkSetStringMacro(Directory);
vtkGetStringMacro(Directory);
//@}
/**
* Search for all files that match the given expression,
* sort them, and add them to the output. This method can
* be called repeatedly to add files matching additional patterns.
* Returns 1 if successful, otherwise returns zero.
*/
int AddFileNames(const char* pattern);
//@{
/**
* Recurse into subdirectories.
*/
vtkSetMacro(Recurse, int);
vtkBooleanMacro(Recurse, int);
vtkGetMacro(Recurse, int);
//@}
/**
* Return the number of files found.
*/
int GetNumberOfFileNames();
/**
* Return the file at the given index, the indexing is 0 based.
*/
const char* GetNthFileName(int index);
//@{
/**
* Get an array that contains all the file names.
*/
vtkGetObjectMacro(FileNames, vtkStringArray);
//@}
protected:
//@{
/**
* Set the wildcard pattern.
*/
vtkSetStringMacro(Pattern);
vtkGetStringMacro(Pattern);
//@}
vtkGlobFileNames();
~vtkGlobFileNames();
private:
char* Directory; // Directory for search.
char* Pattern; // Wildcard pattern
int Recurse; // Recurse into subdirectories
vtkStringArray *FileNames; // VTK array of files
private:
vtkGlobFileNames(const vtkGlobFileNames&) VTK_DELETE_FUNCTION;
void operator=(const vtkGlobFileNames&) VTK_DELETE_FUNCTION;
};
#endif
| [
"likewatchk@gmail.com"
] | likewatchk@gmail.com |
e80227045e2985c216df8549cd7306e70d4f268f | de13afca11214483621369f0d055fee7dc9741aa | /tic_tac_toe.cpp | 47e669c0f5c744aa873e80ab3652eb5e7ab1aaea | [] | no_license | dhrupakpatel/game | ec0518a545ec47a94cafdcf5c9ee6e5e3882c49d | 634ee1593280e521bd11ee415698d71fb64e04fc | refs/heads/master | 2020-10-01T11:53:57.926115 | 2019-12-14T06:50:51 | 2019-12-14T06:50:51 | 227,532,578 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 406 | cpp | #include <iostream>
#include "tic_tac_toe.h"
using namespace std;
int main()
{
int count=0;
Draw();
while (true)
{
count++;
Input();
TogglePlayer();
Draw();
if (Win() == 'X')
{
cout << "X wins" << endl;
break;
}
else if (Win() == 'O')
{
cout << "O wins" << endl;
break;
}
if (count >= 9)
{
cout << "Draw" << endl;
break;
}
}
system("pause");
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
433eeab330e650e67742c9825616de266daef2be | ff084134e271b3cd5947e9d70341cd7ec4cb2082 | /Prog3/TrabalhoC++/util/FileNotFoundException.h | 24ad95a1d6e152f7c087278f676da7d56a88a4ea | [] | no_license | HenriqueCruz5341/UFES | 0feeac8236da421d52758b4219f3a3a4b70a10a7 | 1f411e3a25430ee25f7e1bc8b0a393af6ff2408d | refs/heads/main | 2022-08-08T07:20:04.600028 | 2022-07-19T02:49:38 | 2022-07-19T02:49:38 | 209,062,477 | 2 | 0 | null | 2021-02-21T21:11:45 | 2019-09-17T13:32:14 | C | UTF-8 | C++ | false | false | 526 | h | #ifndef FILENOTFOUNDEXCEPTION_H
#define FILENOTFOUNDEXCEPTION_H
#include <string>
using namespace std;
class FileNotFoundException {
private:
string message;
public:
FileNotFoundException(const string& message);
string get_message();
~FileNotFoundException();
};
FileNotFoundException::FileNotFoundException(const string& message) {
this->message = message;
}
string FileNotFoundException::get_message() {
return this->message;
}
FileNotFoundException::~FileNotFoundException() {
}
#endif | [
"henriquepaulinocruz@hotmail.com"
] | henriquepaulinocruz@hotmail.com |
8c780dd9df6ededa18568b98835737249ef9ed20 | 128c759c5c22506c5e7fd76efaba4d5eac451d2a | /Memory.cpp | e7112e4fa7677f34e3fb10e1f1ecebf7f3d1cb26 | [
"MIT"
] | permissive | magnusfahlin/cuckoo_clock_controller | 18eb07f208ee4a06c8be59e7c0d62cac86e47554 | 58595e682e50bf8a65723f01a640527dff5bcf3a | refs/heads/master | 2020-04-11T15:35:33.358214 | 2019-01-05T04:47:40 | 2019-01-05T04:54:21 | 161,896,611 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,598 | cpp |
#include <SoftwareSerial.h>
#include "memory.h"
#include "logger.h"
#include <EEPROM.h>
#include <time.h>
void clearMemory()
{
EEPROM.begin(512);
logger("Clear memory");
for (int i = 0 ; i < EEPROM.length() ; i++) {
if(EEPROM.read(i) != 0) //skip already "empty" addresses
{
EEPROM.write(i, 0); //write 0 to address i
}
}
EEPROM.commit();
EEPROM.end();
logger("Memory cleared");
}
void saveState(int address, State* state) {
char str[120];
sprintf(str, "Save address = %i counter = %i, interval = %lf, time= %s", address, state->counter, state->intervalInSeconds, ctime(&(state->timeStamp)));
logger(str);
EEPROM.begin(512);
if (address + sizeof(State) > EEPROM.length())
{
clearMemory();
return;
}
EEPROM.put(address, *state);
address = address + sizeof(State);
EEPROM.commit();
EEPROM.end();
}
bool readState(int* nextAddress, State* state) {
*nextAddress = 0;
bool result = false;
EEPROM.begin(512);
int i = 0;
while(i < EEPROM.length())
{
State readState;
EEPROM.get(i, readState);
if (readState.counter != 0) {
memcpy((void*)state, (void*)&readState, sizeof(State));
*nextAddress = i + sizeof(State);
result = true;
}
i = i + sizeof(State);
if (i > EEPROM.length())
break;
}
EEPROM.end();
char str[120];
sprintf(str, "Read nextAddress = %i counter = %i, interval = %lf, time= %s", *nextAddress, state->counter, state->intervalInSeconds, ctime(&(state->timeStamp)));
logger(str);
return result;
}
| [
"magnus@fahlin.org"
] | magnus@fahlin.org |
e5c2fe5b31cf4636fc82143ae88ba4314fc26667 | ba7f467e4e1a37486d0da56139919c59678bbaa6 | /src/main.hpp | ad0d718786cf2b1a7e31d44f3e3f03c910588736 | [] | no_license | ExPie/GameBoyEmu | 4d109721d2b46044b1da4493eecd9f98a96767aa | ff86bbccb092b77caac77c64038fa1fcfc08e55a | refs/heads/master | 2020-03-26T21:35:10.621998 | 2018-08-20T09:36:59 | 2018-08-20T09:36:59 | 145,396,562 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 128 | hpp | #ifndef MAIN_HPP
#define MAIN_HPP
void printHello();
class Adder {
public:
static int add(int, int);
};
#endif
| [
"noreply@github.com"
] | noreply@github.com |
5944e2fbbcc574b288190689651ae2c28e2b95d2 | 81b6521d8204a962b908094deb8998c291cdb07b | /Multi-University-2016-round4/1009.cpp | c7d1f0df2bb1665f01cbeba028896ac69d4c8acc | [] | no_license | doldre/ACM | 9c86c242a347e5b31daa365ddf0e835af7468fa9 | 23e4694fee51831831b1346b8ccc0e97eebef20a | refs/heads/master | 2020-04-12T02:29:59.345719 | 2017-04-10T08:15:10 | 2017-04-10T08:15:10 | 55,833,991 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,131 | cpp | /************************************************
*Author :mathon
*Email :luoxinchen96@gmail.com
*************************************************/
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <stack>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
typedef unsigned long long ull;
#define xx first
#define lowbit(x) (x&-x)
#define yy second
#define pr(x) cout << #x << " " << x << " "
#define prln(x) cout << #x << " " << x << endl
const int MAXN = 300010;
const int MAXM = 800010;
const int INF = 0x3f3f3f3f;
struct Edge {
int to, nxt, cap, flow;
}edge[MAXM];
int tol;
int head[MAXN];
int gap[MAXN], dep[MAXN], pre[MAXN], cur[MAXN];
void init() {
tol = 0;
memset(head, -1, sizeof(head));
}
void add_edge(int u, int v, int w, int rw = 0) {
edge[tol].to = v; edge[tol].cap = w; edge[tol].nxt = head[u];
edge[tol].flow = 0; head[u] = tol++;
edge[tol].to = u; edge[tol].cap = rw; edge[tol].nxt = head[v];
edge[tol].flow = 0; head[v] = tol++;
}
// 起始点，终点， 点的数目，编号无所谓
int sap(int start, int end, int N) {
memset(gap, 0, sizeof(gap));
memset(dep, 0, sizeof(dep));
memcpy(cur, head, sizeof(head));
int u = start;
pre[u] = -1;
gap[0] = N;
int ans = 0;
while(dep[start] < N) {
if(u == end) {
int Min = INF;
for (int i = pre[u]; i != -1; i = pre[edge[i^1].to])
if(Min > edge[i].cap - edge[i].flow)
Min = edge[i].cap - edge[i].flow;
for (int i = pre[u]; i != -1; i = pre[edge[i^1].to]) {
edge[i].flow += Min;
edge[i^1].flow -= Min;
}
u = start;
ans += Min;
continue;
}
bool flag = false;
int v;
for (int i = cur[u]; i != -1; i = edge[i].nxt) {
v = edge[i].to;
if(edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u]) {
flag = true;
cur[u] = pre[v] = i;
break;
}
}
if(flag) {
u = v;
continue;
}
int Min = N;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min) {
Min = dep[edge[i].to];
cur[u] = i;
}
}
gap[dep[u]]--;
if(!gap[dep[u]]) return ans;
dep[u] = Min + 1;
gap[dep[u]]++;
if(u != start) u = edge[pre[u]^1].to;
}
return ans;
}
const int maxn = 100 + 5;
char str[maxn];
int A[10], B[10];
int w[maxn][maxn];
int main(void) {
#ifdef MATHON
//freopen("in.txt", "r", stdin);
//freopen("out.txt", "w", stdout);
#endif
int T; scanf("%d", &T);
for (int Cas = 1; Cas <= T; Cas++) {
int n; scanf("%d", &n);
scanf("%s", str);
for (int i = 0; i < 10; i++) {
scanf("%d%d", &A[i], &B[i]);
}
int tot = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &w[i][j]);
tot += w[i][j];
}
}
init();
int s = n * n + n + 15, t = s + 1;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
add_edge(i * n + j, n * n + i, INF, 0);
add_edge(i * n + j, n * n + j, INF, 0);
add_edge(s, i * n + j, w[i][j] + w[j][i], 0);
}
}
for (int i = 0; i < n; i++) {
add_edge(n * n + i, t, A[str[i] - '0'], 0);
add_edge(n * n + i, n * n + n + str[i] - '0', INF, 0);
}
for (int i = 0; i < 10; i++) {
add_edge(n * n + n + i, t, B[i] - A[i], 0);
}
int min_cut = sap(s, t, n * (n - 1) / 2 + n + 10 + 2);
// prln(min_cut);
printf("Case #%d: %d\n", Cas, tot - min_cut);
}
return 0;
}
| [
"luoxinchen96@gmail.com"
] | luoxinchen96@gmail.com |
fd05e6211e5f7243d97ca373a6e14c577dde04f4 | c477953bed4124c1ca4046ac58723eae6e34e6df | /mbed-os-test-program/main.cpp | 20e15ca2ac82089569744e42ab7ba202c832597d | [] | no_license | yuchen0816/mbed01 | 74dfe8e9954fd1d6dbf7fe77e2f138f03ad22931 | 94c176cacee4524e2e65ed50f9823c54606c3b6a | refs/heads/master | 2023-03-10T22:24:01.598211 | 2021-03-01T16:48:07 | 2021-03-01T16:48:07 | 342,738,591 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 514 | cpp | #include "mbed.h"
DigitalOut myled(LED2);
DigitalOut myled2(LED1);
int main()
{
while (1)
{
myled = 1; // set LED2 pin to high
myled2 = 0; // set LED1 pin to low
ThisThread::sleep_for(1s);
myled.write(0); // set LED2 pin to low
myled2.write(1); // set LED1 pin to high
ThisThread::sleep_for(1s);
}
}
| [
"kevinxiao0816@icloud.com"
] | kevinxiao0816@icloud.com |
e04b58a25ab3b35c04417fddb217b450b5a55bf6 | 7524106d9776f24311be4e6050cedd2a10e31282 | /problems/contests/dated/2020_05_04/x2_poj2013/xmain_2_poj2013.cpp | b3732194236cb2169a9db5c60ab46be70f2636fb | [] | no_license | Exr0nProjects/learn_cpp | f0d0ab1fd26adaea18d711c3cce16d63e0b2a7dc | c0fcb9783fa4ce76701fe234599bc13876cc4083 | refs/heads/master | 2023-04-11T08:19:42.923015 | 2021-01-27T02:41:35 | 2021-01-27T02:41:35 | 180,021,931 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 609 | cpp | /*
TASK: 2_poj2013
LANG: C++14
*/
/*
* Problem 2_poj2013 (contests/dated/2020_05_04/2_poj2013)
* Create time: Sat 16 May 2020 @ 12:01 (PDT)
* Accept time: Sat 16 May 2020 @ 12:27 (PDT)
*
*/
#include <iostream>
using namespace std;
const int MX = 31;
char names[MX][MX];
int main()
{
int N, kase=0;
while (scanf("%d", &N) == 1)
{
if (!N) break;
memset(names, 0, sizeof names);
for (int i=0; i<N; ++i)
{
const int pos = i%2 ? N-(i+1)/2 : i/2;
scanf("%s", names[pos]);
}
printf("SET %d\n", ++kase);
for (int i=0; i<N; ++i)
{
printf("%s\n", names[i]);
}
}
return 0;
}
| [
"spotyie@gmail.com"
] | spotyie@gmail.com |
539631b0af79d63385cbe5ba51b493b0b3a4c36a | 766a016b2b203c902f1c7600a1da8b07e1d7cb2f | /DP/DigitDp/ABC_135D.cpp | f5e3c258a6a45365c8ffcf0561b4cc8e637d1905 | [] | no_license | 1604078-MEHEDI/Competitive | f8143e96184b321d3e409890658152538db91c03 | 4f3a0d178d1fd44d4913d5a6bf42b6884829408d | refs/heads/master | 2020-12-17T07:17:53.604618 | 2020-11-08T08:56:36 | 2020-11-08T08:56:36 | 235,286,673 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,198 | cpp | /*بِسْمِ اللَّهِ الرَّحْمَنِ الرَّحِيم*/
//#pragma GCC optimize("O3,unroll-loops")
//#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
typedef long long ll;
using pii = pair<int, int>;
const double PI = acos(-1.0);
const ll mod = 1e9 + 7;
//const ll mod = 998244353;
inline void normal(ll &a) { a %= mod; (a < 0) && (a += mod); }
inline ll modMul(ll a, ll b) { a %= mod, b %= mod; normal(a), normal(b); return (a * b) % mod; }
inline ll modAdd(ll a, ll b) { a %= mod, b %= mod; normal(a), normal(b); return (a + b) % mod; }
inline ll modSub(ll a, ll b) { a %= mod, b %= mod; normal(a), normal(b); a -= b; normal(a); return a; }
inline ll modPow(ll b, ll p) { ll r = 1; while (p) { if (p & 1) r = modMul(r, b); b = modMul(b, b); p >>= 1; } return r; }
inline ll modInverse(ll a) { return modPow(a, mod - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
#define si(x) scanf("%d",&x)
#define sii(x,y) scanf("%d %d",&x,&y)
#define siii(x,y,z) scanf("%d %d %d",&x,&y,&z)
#define sl(x) scanf("%lld",&x)
#define sll(x,y) scanf("%lld %lld",&x,&y)
#define slll(x,y,z) scanf("%lld %lld %lld",&x,&y,&z)
#define ss(ch) scanf("%s",ch)
#define pi(x) printf("%d",x)
#define pii(x,y) printf("%d %d",x,y)
#define piii(x,y,z) printf("%d %d %d",x,y,z)
#define pl(x) printf("%lld",x)
#define pll(x,y) printf("%lld %lld",x,y)
#define plll(x,y,z) printf("%lld %lld %lld",x,y,z)
#define ps(ch) printf("%s",ch)
#define F(i,a,b) for(int i= a; i <= b; i++)
#define R(i,b,a) for(int i= b; i >= a; i--)
#define REP(i,n) for(int i = 0; i < (n); i++)
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
/* for Random Number generate
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
*/
///**
template < typename F, typename S >ostream& operator << ( ostream& os, const pair< F, S > & p ) {return os << "(" << p.first << ", " << p.second << ")";}
template < typename T >ostream &operator << ( ostream & os, const vector< T > &v ) {os << "{"; for (auto it = v.begin(); it != v.end(); ++it) {if ( it != v.begin() ) os << ", "; os << *it;} return os << "}";}
template < typename T >ostream &operator << ( ostream & os, const set< T > &v ) {os << "["; for (auto it = v.begin(); it != v.end(); ++it) {if ( it != v.begin()) os << ", "; os << *it;} return os << "]";}
template < typename F, typename S >ostream &operator << ( ostream & os, const map< F, S > &v ) {os << "["; for (auto it = v.begin(); it != v.end(); ++it) {if ( it != v.begin() ) os << ", "; os << it -> first << " = " << it -> second ;} return os << "]";}
#define dbg(args...) do {cerr << #args << " : "; faltu(args); } while(0)
clock_t tStart = clock();
#define timeStamp dbg("Execution Time: ", (double)(clock() - tStart)/CLOCKS_PER_SEC)
void faltu () { cerr << endl; }
template <typename T>void faltu( T a[], int n ) {for (int i = 0; i < n; ++i) cerr << a[i] << ' '; cerr << endl;}
template <typename T, typename ... hello>
void faltu( T arg, const hello &... rest) { cerr << arg << ' '; faltu(rest...); }
// Program showing a policy-based data structure.
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
#include <functional> // for less
using namespace __gnu_pbds;
// GNU link : https://goo.gl/WVDL6g
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,
tree_order_statistics_node_update>
new_data_set;
// find_by_order(k) – ফাংশনটি kth ordered element এর একটা পয়েন্টার রিটার্ন করে। অর্থাৎ তুমি চাইলেই kth ইন্ডেক্সে কি আছে, সেটা জেনে ফেলতে পারছো!
// order_of_key(x) – ফাংশনটি x এলিমেন্টটা কোন পজিশনে আছে সেটা বলে দেয়।
//*//**___________________________________________________**/
const int N = 100006;
const int M = 17;
vector<int> digits;
int n, D = 13;
ll dp[N][M];
//map<int, bool>vis;
ll go(int pos, int rem) {
//dbg(D);
if (pos == n)return (rem == 5);
ll &ret = dp[pos][rem];
if (~ret) return ret;
ll tot = 0;
if (digits[pos] == 15) {
//if (!vis[pos])
// dbg(digits[pos], pos);
// vis[pos] = true;
int limit = 9;
for (int i = 0; i <= limit; i++) {
tot += go(pos + 1, (rem * 10 + i) % D);
}
}
else {
tot += go(pos + 1, (rem * 10 + digits[pos]) % D);
}
return ret = tot % mod;
}
// D - Digits Parade
//https://atcoder.jp/contests/abc135/tasks/abc135_d
int main()
{
FASTIO
///*
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
//*/
//char ch = '?';
//dbg(ch - '0');
string s;
cin >> s;// >> D;
n = s.size();
for (int i = 0; i < n; i++)
digits.push_back(s[i] - '0');
memset(dp, -1, sizeof dp);
ll ans = go(0, 0);
normal(ans);
cout << ans << "\n";
return 0;
}
| [
"hasanmahadi877@gmail.com"
] | hasanmahadi877@gmail.com |
eebd6ae9441bc1cc6fe2ab621a64f39c281ddd9f | 3cf9e141cc8fee9d490224741297d3eca3f5feff | /C++ Benchmark Programs/Benchmark Files 1/classtester/autogen-sources/source-2384.cpp | 3e0435d184e663637652bdb1f6cdc535ed9866fc | [] | no_license | TeamVault/tauCFI | e0ac60b8106fc1bb9874adc515fc01672b775123 | e677d8cc7acd0b1dd0ac0212ff8362fcd4178c10 | refs/heads/master | 2023-05-30T20:57:13.450360 | 2021-06-14T09:10:24 | 2021-06-14T09:10:24 | 154,563,655 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,511 | cpp | struct c0;
void __attribute__ ((noinline)) tester0(c0* p);
struct c0
{
bool active0;
c0() : active0(true) {}
virtual ~c0()
{
tester0(this);
active0 = false;
}
virtual void f0(){}
};
void __attribute__ ((noinline)) tester0(c0* p)
{
p->f0();
}
struct c1;
void __attribute__ ((noinline)) tester1(c1* p);
struct c1
{
bool active1;
c1() : active1(true) {}
virtual ~c1()
{
tester1(this);
active1 = false;
}
virtual void f1(){}
};
void __attribute__ ((noinline)) tester1(c1* p)
{
p->f1();
}
struct c2;
void __attribute__ ((noinline)) tester2(c2* p);
struct c2
{
bool active2;
c2() : active2(true) {}
virtual ~c2()
{
tester2(this);
active2 = false;
}
virtual void f2(){}
};
void __attribute__ ((noinline)) tester2(c2* p)
{
p->f2();
}
struct c3;
void __attribute__ ((noinline)) tester3(c3* p);
struct c3 : c1, virtual c2, virtual c0
{
bool active3;
c3() : active3(true) {}
virtual ~c3()
{
tester3(this);
c0 *p0_0 = (c0*)(c3*)(this);
tester0(p0_0);
c1 *p1_0 = (c1*)(c3*)(this);
tester1(p1_0);
c2 *p2_0 = (c2*)(c3*)(this);
tester2(p2_0);
active3 = false;
}
virtual void f3(){}
};
void __attribute__ ((noinline)) tester3(c3* p)
{
p->f3();
if (p->active1)
p->f1();
if (p->active0)
p->f0();
if (p->active2)
p->f2();
}
struct c4;
void __attribute__ ((noinline)) tester4(c4* p);
struct c4 : virtual c1, virtual c2, c0
{
bool active4;
c4() : active4(true) {}
virtual ~c4()
{
tester4(this);
c0 *p0_0 = (c0*)(c4*)(this);
tester0(p0_0);
c1 *p1_0 = (c1*)(c4*)(this);
tester1(p1_0);
c2 *p2_0 = (c2*)(c4*)(this);
tester2(p2_0);
active4 = false;
}
virtual void f4(){}
};
void __attribute__ ((noinline)) tester4(c4* p)
{
p->f4();
if (p->active0)
p->f0();
if (p->active1)
p->f1();
if (p->active2)
p->f2();
}
int __attribute__ ((noinline)) inc(int v) {return ++v;}
int main()
{
c0* ptrs0[25];
ptrs0[0] = (c0*)(new c0());
ptrs0[1] = (c0*)(c3*)(new c3());
ptrs0[2] = (c0*)(c4*)(new c4());
for (int i=0;i<3;i=inc(i))
{
tester0(ptrs0[i]);
delete ptrs0[i];
}
c1* ptrs1[25];
ptrs1[0] = (c1*)(new c1());
ptrs1[1] = (c1*)(c3*)(new c3());
ptrs1[2] = (c1*)(c4*)(new c4());
for (int i=0;i<3;i=inc(i))
{
tester1(ptrs1[i]);
delete ptrs1[i];
}
c2* ptrs2[25];
ptrs2[0] = (c2*)(new c2());
ptrs2[1] = (c2*)(c3*)(new c3());
ptrs2[2] = (c2*)(c4*)(new c4());
for (int i=0;i<3;i=inc(i))
{
tester2(ptrs2[i]);
delete ptrs2[i];
}
c3* ptrs3[25];
ptrs3[0] = (c3*)(new c3());
for (int i=0;i<1;i=inc(i))
{
tester3(ptrs3[i]);
delete ptrs3[i];
}
c4* ptrs4[25];
ptrs4[0] = (c4*)(new c4());
for (int i=0;i<1;i=inc(i))
{
tester4(ptrs4[i]);
delete ptrs4[i];
}
return 0;
}
| [
"ga72foq@mytum.de"
] | ga72foq@mytum.de |
497a0dd2d66e1ec94a43b5c49dc6b369baf3c8b2 | 21d7beb924a92b8479ded6814beab931d82fcf64 | /Temp/StagingArea/Data/il2cppOutput/Il2CppMetadataRegistration.cpp | 8a15dedb0e73156204b83b18edefc51b6ca3f3ca | [] | no_license | DeepExplorer/Hololens-Project-Unity3D-Solar-System-Simulator | f10559b3854b3bd6f7ae104268939ff7541424cb | 528f7fd0e83d277dfa702c04e19db141149dcc83 | refs/heads/master | 2021-01-23T03:48:17.782501 | 2017-03-24T21:29:41 | 2017-03-24T21:29:41 | 86,125,590 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,096 | cpp | #include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include "class-internals.h"
#include "codegen/il2cpp-codegen.h"
extern Il2CppGenericClass* const s_Il2CppGenericTypes[];
extern const Il2CppGenericInst* const g_Il2CppGenericInstTable[];
extern const Il2CppGenericMethodFunctionsDefinitions s_Il2CppGenericMethodFunctions[];
extern const Il2CppType* const g_Il2CppTypeTable[];
extern const Il2CppMethodSpec g_Il2CppMethodSpecTable[];
extern const int32_t* g_FieldOffsetTable[];
extern const Il2CppTypeDefinitionSizes* g_Il2CppTypeDefinitionSizesTable[];
extern void** const g_MetadataUsages[];
extern const Il2CppMetadataRegistration g_MetadataRegistration =
{
1060,
s_Il2CppGenericTypes,
310,
g_Il2CppGenericInstTable,
1785,
s_Il2CppGenericMethodFunctions,
5229,
g_Il2CppTypeTable,
1970,
g_Il2CppMethodSpecTable,
1354,
g_FieldOffsetTable,
1354,
g_Il2CppTypeDefinitionSizesTable,
4820,
g_MetadataUsages,
};
| [
"ddong1@andrew.cmu.edu"
] | ddong1@andrew.cmu.edu |
904d6a6307ece35e6d4a24fac592623ff1a3e2b9 | 87d2a6c5afaa00ba4467a406a38464f407bc4115 | /gsm/src/with_bug/gsm/solution1/syn/systemc/Quantization_and_cod.h | 92650c7453c2c2dc15456421169d7f480e7622ee | [] | no_license | koodg123/aqed-dac2020-results | a27c2971d3f9ca716280e3a5f615424789d1a202 | 7e59696026f06ecfecaab62bb7902a781fe43d67 | refs/heads/master | 2022-11-22T01:36:58.244512 | 2020-07-29T17:35:26 | 2020-07-29T17:35:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,838 | h | // ==============================================================
// RTL generated by Vivado(TM) HLS - High-Level Synthesis from C, C++ and SystemC
// Version: 2018.2
// Copyright (C) 1986-2018 Xilinx, Inc. All Rights Reserved.
//
// ===========================================================
#ifndef _Quantization_and_cod_HH_
#define _Quantization_and_cod_HH_
#include "systemc.h"
#include "AESL_pkg.h"
#include "gsm_add.h"
#include "aqed_top_mul_mul_eOg.h"
#include "Quantization_and_dEe.h"
namespace ap_rtl {
struct Quantization_and_cod : public sc_module {
// Port declarations 7
sc_in_clk ap_clk;
sc_in< sc_logic > ap_rst;
sc_in< sc_logic > ap_start;
sc_out< sc_logic > ap_done;
sc_out< sc_logic > ap_idle;
sc_out< sc_logic > ap_ready;
sc_in< sc_lv<4> > LAR_offset;
sc_signal< sc_lv<13> > ap_var_for_const0;
// Module declarations
Quantization_and_cod(sc_module_name name);
SC_HAS_PROCESS(Quantization_and_cod);
~Quantization_and_cod();
sc_trace_file* mVcdFile;
Quantization_and_dEe* LARc_out_U;
gsm_add* grp_gsm_add_fu_197;
gsm_add* grp_gsm_add_fu_204;
gsm_add* grp_gsm_add_fu_212;
gsm_add* grp_gsm_add_fu_219;
aqed_top_mul_mul_eOg<1,1,15,8,23>* aqed_top_mul_mul_eOg_U19;
aqed_top_mul_mul_eOg<1,1,15,8,23>* aqed_top_mul_mul_eOg_U20;
aqed_top_mul_mul_eOg<1,1,15,8,23>* aqed_top_mul_mul_eOg_U21;
sc_signal< sc_lv<8> > ap_CS_fsm;
sc_signal< sc_logic > ap_CS_fsm_state1;
sc_signal< sc_lv<4> > LARc_out_address0;
sc_signal< sc_logic > LARc_out_ce0;
sc_signal< sc_logic > LARc_out_we0;
sc_signal< sc_lv<8> > LARc_out_d0;
sc_signal< sc_lv<8> > LARc_out_q0;
sc_signal< sc_lv<4> > LARc_out_address1;
sc_signal< sc_logic > LARc_out_ce1;
sc_signal< sc_logic > LARc_out_we1;
sc_signal< sc_lv<8> > LARc_out_d1;
sc_signal< sc_lv<8> > LARc_out_q1;
sc_signal< sc_lv<8> > reg_253;
sc_signal< sc_logic > ap_CS_fsm_state2;
sc_signal< sc_logic > ap_CS_fsm_state5;
sc_signal< sc_lv<8> > reg_257;
sc_signal< sc_lv<4> > LARc_out_addr_reg_1080;
sc_signal< sc_lv<4> > LARc_out_addr_1_reg_1085;
sc_signal< sc_lv<4> > LARc_out_addr_2_reg_1090;
sc_signal< sc_lv<4> > LARc_out_addr_3_reg_1095;
sc_signal< sc_lv<8> > LARc_out_load_2_reg_1100;
sc_signal< sc_logic > ap_CS_fsm_state3;
sc_signal< sc_lv<8> > LARc_out_load_3_reg_1106;
sc_signal< sc_lv<4> > LARc_out_addr_4_reg_1112;
sc_signal< sc_lv<4> > LARc_out_addr_5_reg_1117;
sc_signal< sc_lv<8> > LARc_out_load_4_reg_1122;
sc_signal< sc_logic > ap_CS_fsm_state4;
sc_signal< sc_lv<8> > LARc_out_load_5_reg_1127;
sc_signal< sc_lv<4> > LARc_out_addr_6_reg_1133;
sc_signal< sc_lv<4> > LARc_out_addr_7_reg_1138;
sc_signal< sc_logic > grp_gsm_add_fu_197_ap_ready;
sc_signal< sc_lv<16> > grp_gsm_add_fu_197_a;
sc_signal< sc_lv<13> > grp_gsm_add_fu_197_b;
sc_signal< sc_lv<16> > grp_gsm_add_fu_197_ap_return;
sc_signal< sc_logic > grp_gsm_add_fu_204_ap_ready;
sc_signal< sc_lv<16> > grp_gsm_add_fu_204_ap_return;
sc_signal< sc_logic > grp_gsm_add_fu_212_ap_ready;
sc_signal< sc_lv<16> > grp_gsm_add_fu_212_a;
sc_signal< sc_lv<13> > grp_gsm_add_fu_212_b;
sc_signal< sc_lv<16> > grp_gsm_add_fu_212_ap_return;
sc_signal< sc_logic > grp_gsm_add_fu_219_ap_ready;
sc_signal< sc_lv<16> > grp_gsm_add_fu_219_ap_return;
sc_signal< sc_lv<16> > temp_fu_377_p1;
sc_signal< sc_lv<16> > temp_6_fu_575_p1;
sc_signal< sc_logic > ap_CS_fsm_state6;
sc_signal< sc_lv<16> > temp_12_fu_745_p1;
sc_signal< sc_logic > ap_CS_fsm_state7;
sc_signal< sc_lv<16> > temp_18_fu_916_p1;
sc_signal< sc_logic > ap_CS_fsm_state8;
sc_signal< sc_lv<16> > temp_3_fu_477_p1;
sc_signal< sc_lv<16> > temp_9_fu_673_p1;
sc_signal< sc_lv<16> > temp_15_fu_843_p1;
sc_signal< sc_lv<16> > temp_21_fu_989_p1;
sc_signal< sc_lv<64> > LAR_offset_cast1_fu_261_p1;
sc_signal< sc_lv<64> > sum_cast_fu_272_p1;
sc_signal< sc_lv<64> > sum2_cast_fu_282_p1;
sc_signal< sc_lv<64> > sum4_cast_fu_292_p1;
sc_signal< sc_lv<64> > sum6_cast_fu_302_p1;
sc_signal< sc_lv<64> > sum8_cast_fu_312_p1;
sc_signal< sc_lv<64> > sum3_cast_fu_322_p1;
sc_signal< sc_lv<64> > sum5_cast_fu_332_p1;
sc_signal< sc_lv<8> > tmp_11_fu_428_p3;
sc_signal< sc_lv<8> > tmp_21_fu_528_p3;
sc_signal< sc_lv<8> > tmp_28_fu_626_p3;
sc_signal< sc_lv<8> > tmp_37_fu_724_p3;
sc_signal< sc_lv<8> > tmp_43_fu_796_p3;
sc_signal< sc_lv<8> > tmp_51_fu_894_p3;
sc_signal< sc_lv<8> > tmp_57_fu_967_p3;
sc_signal< sc_lv<8> > tmp_63_fu_1040_p3;
sc_signal< sc_lv<4> > sum_fu_266_p2;
sc_signal< sc_lv<4> > sum2_fu_277_p2;
sc_signal< sc_lv<4> > sum4_fu_287_p2;
sc_signal< sc_lv<4> > sum6_fu_297_p2;
sc_signal< sc_lv<4> > sum8_fu_307_p2;
sc_signal< sc_lv<4> > sum3_fu_317_p2;
sc_signal< sc_lv<4> > sum5_fu_327_p2;
sc_signal< sc_lv<22> > tmp_fu_337_p3;
sc_signal< sc_lv<20> > tmp_1_fu_349_p3;
sc_signal< sc_lv<23> > p_shl1_cast_fu_357_p1;
sc_signal< sc_lv<23> > p_shl9_cast_fu_345_p1;
sc_signal< sc_lv<23> > tmp_28_i_fu_361_p2;
sc_signal< sc_lv<8> > tmp_13_fu_367_p4;
sc_signal< sc_lv<7> > grp_fu_233_p4;
sc_signal< sc_lv<2> > tmp_17_fu_386_p4;
sc_signal< sc_lv<8> > temp_3_cast_fu_382_p1;
sc_signal< sc_lv<1> > icmp_fu_396_p2;
sc_signal< sc_lv<1> > tmp_9_fu_402_p2;
sc_signal< sc_lv<1> > tmp_3_fu_422_p2;
sc_signal< sc_lv<8> > tmp_13_cast_fu_414_p3;
sc_signal< sc_lv<8> > tmp_s_fu_408_p2;
sc_signal< sc_lv<22> > tmp_2_fu_437_p3;
sc_signal< sc_lv<20> > tmp_7_fu_449_p3;
sc_signal< sc_lv<23> > p_shl8_cast_fu_457_p1;
sc_signal< sc_lv<23> > p_shl7_cast_fu_445_p1;
sc_signal< sc_lv<23> > tmp_28_i2_fu_461_p2;
sc_signal< sc_lv<8> > tmp_22_fu_467_p4;
sc_signal< sc_lv<7> > grp_fu_243_p4;
sc_signal< sc_lv<2> > tmp_26_fu_486_p4;
sc_signal< sc_lv<8> > temp_7_cast_fu_482_p1;
sc_signal< sc_lv<1> > icmp1_fu_496_p2;
sc_signal< sc_lv<1> > tmp_15_fu_502_p2;
sc_signal< sc_lv<1> > tmp_4_fu_522_p2;
sc_signal< sc_lv<8> > tmp_22_cast_fu_514_p3;
sc_signal< sc_lv<8> > tmp_19_fu_508_p2;
sc_signal< sc_lv<22> > tmp_23_fu_537_p3;
sc_signal< sc_lv<20> > tmp_24_fu_548_p3;
sc_signal< sc_lv<23> > p_shl6_cast_fu_555_p1;
sc_signal< sc_lv<23> > p_shl5_cast_fu_544_p1;
sc_signal< sc_lv<23> > tmp_28_i6_fu_559_p2;
sc_signal< sc_lv<8> > tmp_29_fu_565_p4;
sc_signal< sc_lv<3> > tmp_33_fu_584_p4;
sc_signal< sc_lv<8> > temp_11_cast_fu_580_p1;
sc_signal< sc_lv<1> > icmp2_fu_594_p2;
sc_signal< sc_lv<1> > tmp_25_fu_600_p2;
sc_signal< sc_lv<1> > tmp_5_fu_620_p2;
sc_signal< sc_lv<8> > tmp_29_cast_fu_612_p3;
sc_signal< sc_lv<8> > tmp_27_fu_606_p2;
sc_signal< sc_lv<22> > tmp_30_fu_635_p3;
sc_signal< sc_lv<20> > tmp_31_fu_646_p3;
sc_signal< sc_lv<23> > p_shl4_cast_fu_653_p1;
sc_signal< sc_lv<23> > p_shl3_cast_fu_642_p1;
sc_signal< sc_lv<23> > tmp_28_i1_fu_657_p2;
sc_signal< sc_lv<8> > tmp_36_fu_663_p4;
sc_signal< sc_lv<3> > tmp_39_fu_682_p4;
sc_signal< sc_lv<8> > temp_15_cast_fu_678_p1;
sc_signal< sc_lv<1> > icmp3_fu_692_p2;
sc_signal< sc_lv<1> > tmp_32_fu_698_p2;
sc_signal< sc_lv<1> > tmp_35_fu_718_p2;
sc_signal< sc_lv<8> > tmp_36_cast_fu_710_p3;
sc_signal< sc_lv<8> > tmp_34_fu_704_p2;
sc_signal< sc_lv<23> > tmp_28_i3_fu_1049_p2;
sc_signal< sc_lv<8> > tmp_42_fu_736_p4;
sc_signal< sc_lv<4> > tmp_47_fu_754_p4;
sc_signal< sc_lv<8> > temp_19_cast_fu_750_p1;
sc_signal< sc_lv<1> > icmp4_fu_764_p2;
sc_signal< sc_lv<1> > tmp_38_fu_770_p2;
sc_signal< sc_lv<1> > tmp_41_fu_790_p2;
sc_signal< sc_lv<8> > tmp_42_cast_fu_782_p3;
sc_signal< sc_lv<8> > tmp_40_fu_776_p2;
sc_signal< sc_lv<22> > tmp_44_fu_805_p3;
sc_signal< sc_lv<18> > tmp_45_fu_816_p3;
sc_signal< sc_lv<23> > p_shl_cast_fu_812_p1;
sc_signal< sc_lv<23> > p_shl2_cast_fu_823_p1;
sc_signal< sc_lv<23> > tmp_28_i4_fu_827_p2;
sc_signal< sc_lv<8> > tmp_50_fu_833_p4;
sc_signal< sc_lv<4> > tmp_53_fu_852_p4;
sc_signal< sc_lv<8> > temp_23_cast_fu_848_p1;
sc_signal< sc_lv<1> > icmp5_fu_862_p2;
sc_signal< sc_lv<1> > tmp_46_fu_868_p2;
sc_signal< sc_lv<1> > tmp_49_fu_888_p2;
sc_signal< sc_lv<8> > tmp_50_cast_fu_880_p3;
sc_signal< sc_lv<8> > tmp_48_fu_874_p2;
sc_signal< sc_lv<23> > tmp_28_i5_fu_1056_p2;
sc_signal< sc_lv<8> > tmp_56_fu_907_p4;
sc_signal< sc_lv<5> > tmp_59_fu_925_p4;
sc_signal< sc_lv<8> > temp_27_cast_fu_921_p1;
sc_signal< sc_lv<1> > icmp6_fu_935_p2;
sc_signal< sc_lv<1> > tmp_52_fu_941_p2;
sc_signal< sc_lv<1> > tmp_55_fu_961_p2;
sc_signal< sc_lv<8> > tmp_56_cast_fu_953_p3;
sc_signal< sc_lv<8> > tmp_54_fu_947_p2;
sc_signal< sc_lv<23> > tmp_28_i7_fu_1063_p2;
sc_signal< sc_lv<8> > tmp_62_fu_980_p4;
sc_signal< sc_lv<5> > tmp_65_fu_998_p4;
sc_signal< sc_lv<8> > temp_31_cast_fu_994_p1;
sc_signal< sc_lv<1> > icmp7_fu_1008_p2;
sc_signal< sc_lv<1> > tmp_58_fu_1014_p2;
sc_signal< sc_lv<1> > tmp_61_fu_1034_p2;
sc_signal< sc_lv<8> > tmp_62_cast_fu_1026_p3;
sc_signal< sc_lv<8> > tmp_60_fu_1020_p2;
sc_signal< sc_lv<15> > tmp_28_i3_fu_1049_p0;
sc_signal< sc_lv<15> > tmp_28_i5_fu_1056_p0;
sc_signal< sc_lv<15> > tmp_28_i7_fu_1063_p0;
sc_signal< sc_lv<8> > ap_NS_fsm;
static const sc_logic ap_const_logic_1;
static const sc_logic ap_const_logic_0;
static const sc_lv<8> ap_ST_fsm_state1;
static const sc_lv<8> ap_ST_fsm_state2;
static const sc_lv<8> ap_ST_fsm_state3;
static const sc_lv<8> ap_ST_fsm_state4;
static const sc_lv<8> ap_ST_fsm_state5;
static const sc_lv<8> ap_ST_fsm_state6;
static const sc_lv<8> ap_ST_fsm_state7;
static const sc_lv<8> ap_ST_fsm_state8;
static const sc_lv<32> ap_const_lv32_0;
static const sc_lv<32> ap_const_lv32_1;
static const sc_lv<32> ap_const_lv32_4;
static const sc_lv<32> ap_const_lv32_2;
static const sc_lv<32> ap_const_lv32_3;
static const sc_lv<32> ap_const_lv32_5;
static const sc_lv<32> ap_const_lv32_6;
static const sc_lv<32> ap_const_lv32_7;
static const sc_lv<13> ap_const_lv13_0;
static const sc_lv<13> ap_const_lv13_800;
static const sc_lv<13> ap_const_lv13_5E;
static const sc_lv<13> ap_const_lv13_1EAB;
static const sc_lv<13> ap_const_lv13_100;
static const sc_lv<13> ap_const_lv13_1600;
static const sc_lv<13> ap_const_lv13_1900;
static const sc_lv<13> ap_const_lv13_1B88;
static const sc_lv<32> ap_const_lv32_9;
static const sc_lv<32> ap_const_lv32_F;
static const sc_lv<4> ap_const_lv4_1;
static const sc_lv<4> ap_const_lv4_2;
static const sc_lv<4> ap_const_lv4_3;
static const sc_lv<4> ap_const_lv4_4;
static const sc_lv<4> ap_const_lv4_5;
static const sc_lv<4> ap_const_lv4_6;
static const sc_lv<4> ap_const_lv4_7;
static const sc_lv<14> ap_const_lv14_0;
static const sc_lv<12> ap_const_lv12_0;
static const sc_lv<32> ap_const_lv32_16;
static const sc_lv<32> ap_const_lv32_E;
static const sc_lv<2> ap_const_lv2_1;
static const sc_lv<7> ap_const_lv7_60;
static const sc_lv<8> ap_const_lv8_20;
static const sc_lv<8> ap_const_lv8_3F;
static const sc_lv<8> ap_const_lv8_0;
static const sc_lv<32> ap_const_lv32_D;
static const sc_lv<3> ap_const_lv3_0;
static const sc_lv<7> ap_const_lv7_70;
static const sc_lv<8> ap_const_lv8_10;
static const sc_lv<8> ap_const_lv8_1F;
static const sc_lv<32> ap_const_lv32_C;
static const sc_lv<4> ap_const_lv4_0;
static const sc_lv<7> ap_const_lv7_78;
static const sc_lv<8> ap_const_lv8_8;
static const sc_lv<8> ap_const_lv8_F;
static const sc_lv<10> ap_const_lv10_0;
static const sc_lv<32> ap_const_lv32_B;
static const sc_lv<5> ap_const_lv5_0;
static const sc_lv<7> ap_const_lv7_7C;
static const sc_lv<8> ap_const_lv8_4;
static const sc_lv<8> ap_const_lv8_7;
static const sc_lv<23> ap_const_lv23_368C;
static const sc_lv<23> ap_const_lv23_2156;
static const sc_lv<23> ap_const_lv23_234C;
static const bool ap_const_boolean_1;
// Thread declarations
void thread_ap_var_for_const0();
void thread_ap_clk_no_reset_();
void thread_LAR_offset_cast1_fu_261_p1();
void thread_LARc_out_address0();
void thread_LARc_out_address1();
void thread_LARc_out_ce0();
void thread_LARc_out_ce1();
void thread_LARc_out_d0();
void thread_LARc_out_d1();
void thread_LARc_out_we0();
void thread_LARc_out_we1();
void thread_ap_CS_fsm_state1();
void thread_ap_CS_fsm_state2();
void thread_ap_CS_fsm_state3();
void thread_ap_CS_fsm_state4();
void thread_ap_CS_fsm_state5();
void thread_ap_CS_fsm_state6();
void thread_ap_CS_fsm_state7();
void thread_ap_CS_fsm_state8();
void thread_ap_done();
void thread_ap_idle();
void thread_ap_ready();
void thread_grp_fu_233_p4();
void thread_grp_fu_243_p4();
void thread_grp_gsm_add_fu_197_a();
void thread_grp_gsm_add_fu_197_b();
void thread_grp_gsm_add_fu_212_a();
void thread_grp_gsm_add_fu_212_b();
void thread_icmp1_fu_496_p2();
void thread_icmp2_fu_594_p2();
void thread_icmp3_fu_692_p2();
void thread_icmp4_fu_764_p2();
void thread_icmp5_fu_862_p2();
void thread_icmp6_fu_935_p2();
void thread_icmp7_fu_1008_p2();
void thread_icmp_fu_396_p2();
void thread_p_shl1_cast_fu_357_p1();
void thread_p_shl2_cast_fu_823_p1();
void thread_p_shl3_cast_fu_642_p1();
void thread_p_shl4_cast_fu_653_p1();
void thread_p_shl5_cast_fu_544_p1();
void thread_p_shl6_cast_fu_555_p1();
void thread_p_shl7_cast_fu_445_p1();
void thread_p_shl8_cast_fu_457_p1();
void thread_p_shl9_cast_fu_345_p1();
void thread_p_shl_cast_fu_812_p1();
void thread_sum2_cast_fu_282_p1();
void thread_sum2_fu_277_p2();
void thread_sum3_cast_fu_322_p1();
void thread_sum3_fu_317_p2();
void thread_sum4_cast_fu_292_p1();
void thread_sum4_fu_287_p2();
void thread_sum5_cast_fu_332_p1();
void thread_sum5_fu_327_p2();
void thread_sum6_cast_fu_302_p1();
void thread_sum6_fu_297_p2();
void thread_sum8_cast_fu_312_p1();
void thread_sum8_fu_307_p2();
void thread_sum_cast_fu_272_p1();
void thread_sum_fu_266_p2();
void thread_temp_11_cast_fu_580_p1();
void thread_temp_12_fu_745_p1();
void thread_temp_15_cast_fu_678_p1();
void thread_temp_15_fu_843_p1();
void thread_temp_18_fu_916_p1();
void thread_temp_19_cast_fu_750_p1();
void thread_temp_21_fu_989_p1();
void thread_temp_23_cast_fu_848_p1();
void thread_temp_27_cast_fu_921_p1();
void thread_temp_31_cast_fu_994_p1();
void thread_temp_3_cast_fu_382_p1();
void thread_temp_3_fu_477_p1();
void thread_temp_6_fu_575_p1();
void thread_temp_7_cast_fu_482_p1();
void thread_temp_9_fu_673_p1();
void thread_temp_fu_377_p1();
void thread_tmp_11_fu_428_p3();
void thread_tmp_13_cast_fu_414_p3();
void thread_tmp_13_fu_367_p4();
void thread_tmp_15_fu_502_p2();
void thread_tmp_17_fu_386_p4();
void thread_tmp_19_fu_508_p2();
void thread_tmp_1_fu_349_p3();
void thread_tmp_21_fu_528_p3();
void thread_tmp_22_cast_fu_514_p3();
void thread_tmp_22_fu_467_p4();
void thread_tmp_23_fu_537_p3();
void thread_tmp_24_fu_548_p3();
void thread_tmp_25_fu_600_p2();
void thread_tmp_26_fu_486_p4();
void thread_tmp_27_fu_606_p2();
void thread_tmp_28_fu_626_p3();
void thread_tmp_28_i1_fu_657_p2();
void thread_tmp_28_i2_fu_461_p2();
void thread_tmp_28_i3_fu_1049_p0();
void thread_tmp_28_i4_fu_827_p2();
void thread_tmp_28_i5_fu_1056_p0();
void thread_tmp_28_i6_fu_559_p2();
void thread_tmp_28_i7_fu_1063_p0();
void thread_tmp_28_i_fu_361_p2();
void thread_tmp_29_cast_fu_612_p3();
void thread_tmp_29_fu_565_p4();
void thread_tmp_2_fu_437_p3();
void thread_tmp_30_fu_635_p3();
void thread_tmp_31_fu_646_p3();
void thread_tmp_32_fu_698_p2();
void thread_tmp_33_fu_584_p4();
void thread_tmp_34_fu_704_p2();
void thread_tmp_35_fu_718_p2();
void thread_tmp_36_cast_fu_710_p3();
void thread_tmp_36_fu_663_p4();
void thread_tmp_37_fu_724_p3();
void thread_tmp_38_fu_770_p2();
void thread_tmp_39_fu_682_p4();
void thread_tmp_3_fu_422_p2();
void thread_tmp_40_fu_776_p2();
void thread_tmp_41_fu_790_p2();
void thread_tmp_42_cast_fu_782_p3();
void thread_tmp_42_fu_736_p4();
void thread_tmp_43_fu_796_p3();
void thread_tmp_44_fu_805_p3();
void thread_tmp_45_fu_816_p3();
void thread_tmp_46_fu_868_p2();
void thread_tmp_47_fu_754_p4();
void thread_tmp_48_fu_874_p2();
void thread_tmp_49_fu_888_p2();
void thread_tmp_4_fu_522_p2();
void thread_tmp_50_cast_fu_880_p3();
void thread_tmp_50_fu_833_p4();
void thread_tmp_51_fu_894_p3();
void thread_tmp_52_fu_941_p2();
void thread_tmp_53_fu_852_p4();
void thread_tmp_54_fu_947_p2();
void thread_tmp_55_fu_961_p2();
void thread_tmp_56_cast_fu_953_p3();
void thread_tmp_56_fu_907_p4();
void thread_tmp_57_fu_967_p3();
void thread_tmp_58_fu_1014_p2();
void thread_tmp_59_fu_925_p4();
void thread_tmp_5_fu_620_p2();
void thread_tmp_60_fu_1020_p2();
void thread_tmp_61_fu_1034_p2();
void thread_tmp_62_cast_fu_1026_p3();
void thread_tmp_62_fu_980_p4();
void thread_tmp_63_fu_1040_p3();
void thread_tmp_65_fu_998_p4();
void thread_tmp_7_fu_449_p3();
void thread_tmp_9_fu_402_p2();
void thread_tmp_fu_337_p3();
void thread_tmp_s_fu_408_p2();
void thread_ap_NS_fsm();
};
}
using namespace ap_rtl;
#endif
| [
"esingh@rsg1.stanford.edu"
] | esingh@rsg1.stanford.edu |
03e56d564c4f2d5956be90ab0831e2033431a148 | 83b760ac2f72d08f46c424917ebbf4424f7531be | /src/CommandExpression.h | e7f4e7e76b678690055f2ec6343b68f594d56a54 | [] | no_license | elyawy/stepping_stone1 | 96582517883d458a7136d57db832f650abd5fe73 | 8ac70c372105f4f583e5ded5c0fc2082fabadbc2 | refs/heads/master | 2020-04-11T04:33:01.479821 | 2018-12-29T21:38:21 | 2018-12-29T21:38:21 | 161,515,934 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 507 | h | //
// Created by elyawy on 12/16/18.
//
#ifndef STEPPING_STONE1_COMMANDEXPRESSION_H
#define STEPPING_STONE1_COMMANDEXPRESSION_H
#include "Expression.h"
#include "Command.h"
#include <vector>
class CommandExpression: public Expression {
private:
Command *command;
public:
explicit CommandExpression(Command *command);
double calculate(mapHandler &mapH) override;
~CommandExpression() override;
std::string stringify() override;
};
#endif //STEPPING_STONE1_COMMANDEXPRESSION_H
| [
"elya.wygoda@gmail.com"
] | elya.wygoda@gmail.com |
cd2958be4f8de40db09617a528b3c5185e757af5 | 8424364474156e6b057678ff4d4afabdfd914aad | /include/pipeline/pipe_pair.hpp | 5d6717a0b230d9be7a38d74773cd5ad1ffae01e1 | [
"MIT"
] | permissive | kerwinzxc/pipeline | fcb278a87305e77e4f2adb72a9ad2ae728c3cd76 | 31fffe6af101da57513eebca7518b1e434f5de87 | refs/heads/master | 2022-12-31T11:52:39.187233 | 2020-10-13T21:52:55 | 2020-10-13T21:52:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,062 | hpp | #pragma once
#include <pipeline/details.hpp>
namespace pipeline {
template <typename T1, typename T2> class pipe_pair {
T1 left_;
T2 right_;
public:
pipe_pair(T1 left, T2 right) : left_(left), right_(right) {}
template <typename... T> decltype(auto) operator()(T &&... args) {
typedef typename std::result_of<T1(T...)>::type left_result_type;
if constexpr (!std::is_same<left_result_type, void>::value) {
return right_(left_(std::forward<T>(args)...));
} else {
left_(std::forward<T>(args)...);
return right_();
}
}
template <typename T3> auto operator|(T3 &&rhs) {
return pipe_pair<pipe_pair<T1, T2>, T3>(*this, std::forward<T3>(rhs));
}
};
template <typename T1, typename T2> auto pipe(T1 &&t1, T2 &&t2) {
return pipe_pair<T1, T2>(std::forward<T1>(t1), std::forward<T2>(t2));
}
template <typename T1, typename T2, typename... T> auto pipe(T1 &&t1, T2 &&t2, T &&... args) {
return pipe(pipe<T1, T2>(std::forward<T1>(t1), std::forward<T2>(t2)), std::forward<T>(args)...);
}
} // namespace pipeline | [
"pranav.srinivas.kumar@gmail.com"
] | pranav.srinivas.kumar@gmail.com |
62459c74d4b5997e2b8ad5d4d0e1d1930563f03a | b511bb6461363cf84afa52189603bd9d1a11ad34 | /code/bear_and_finding_criminal.cpp | 26f3c67ea7c734997933575a9b6704a24d4c9beb | [] | no_license | masumr/problem_solve | ec0059479425e49cc4c76a107556972e1c545e89 | 1ad4ec3e27f28f10662c68bbc268eaad9f5a1a9e | refs/heads/master | 2021-01-16T19:07:01.198885 | 2017-08-12T21:21:59 | 2017-08-12T21:21:59 | 100,135,794 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 408 | cpp | #include<bits/stdc++.h>
#define For(i,a,b) for(i=a;i<=b;i++)
using namespace std;
int main()
{
int t1,t2,sum,arr[100],i,count=0;
cin>>t1>>t2;
For(i,1,t1){cin>>arr[i];}
For(i,1,t1){
if(arr[i]==1 && 2*t2-i>0 && 2*t2-i<=t1 && arr[i]==arr[2*t2-i])
count++;
if(arr[i]==1 && (2*t2-i<=0 || 2*t2-i>t1))
count++;
}
cout<<count<<endl;
}
| [
"masumr455@gmial.com"
] | masumr455@gmial.com |
5191702c5ce47ab90d89591f2301d438cd11a750 | 877fff5bb313ccd23d1d01bf23b1e1f2b13bb85a | /app/src/main/cpp/dir7941/dir7942/dir8062/dir8063/dir12766/dir12767/dir13029/dir15097/dir18970/file19164.cpp | 429b6cdc8d1fab7ef29b49e511a849df4415fed4 | [] | no_license | tgeng/HugeProject | 829c3bdfb7cbaf57727c41263212d4a67e3eb93d | 4488d3b765e8827636ce5e878baacdf388710ef2 | refs/heads/master | 2022-08-21T16:58:54.161627 | 2020-05-28T01:54:03 | 2020-05-28T01:54:03 | 267,468,475 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 115 | cpp | #ifndef file19164
#error "macro file19164 must be defined"
#endif
static const char* file19164String = "file19164"; | [
"tgeng@google.com"
] | tgeng@google.com |
198e25e0211e28132be726ba5e40e6895d05a3f2 | 9bc82a513c67d9f652a92f0ebb49779194c35633 | /onewirelibrary/OneWire++/LOW_deviceID.cpp | 143fb1403b2444f1f99ecee89b9fb1baf447cedf | [] | no_license | colek/homeis | 94ceef311059cab29cfb86aa0af541735944c2f5 | 7dd4c999bee6bd0557e56d9e85114f5084df0eb8 | refs/heads/master | 2021-01-15T10:59:53.608874 | 2016-05-16T19:32:37 | 2016-05-16T19:32:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,368 | cpp | /***************************************************************************
LOW_deviceID.cpp - description
-------------------
begin : Sat Jul 6 2002
copyright : (C) 2002 by Harald Roelle
email : roelle@informatik.uni-muenchen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "LOW_deviceID.h"
#include "LOW_helper_crc.h"
//=====================================================================================
//
// public constructors
//
LOW_deviceID::LOW_deviceID() :
LOW_deviceIDRaw()
{
}
LOW_deviceID::LOW_deviceID( const LOW_deviceID &inDeviceID) :
LOW_deviceIDRaw( inDeviceID)
{
checkCRC();
}
LOW_deviceID::LOW_deviceID( const devRomID_t &inRomID) :
LOW_deviceIDRaw( inRomID)
{
checkCRC();
}
LOW_deviceID::LOW_deviceID( uint32_t inHighInt, uint32_t inLowInt) :
LOW_deviceIDRaw( inHighInt, inLowInt)
{
checkCRC();
}
LOW_deviceID::LOW_deviceID( const byteVec_t &inRomID) :
LOW_deviceIDRaw( inRomID)
{
checkCRC();
}
LOW_deviceID::LOW_deviceID( const LOW_deviceIDRaw &inDevIDRaw) :
LOW_deviceIDRaw( inDevIDRaw)
{
checkCRC();
}
LOW_deviceID::~LOW_deviceID()
{
}
//=====================================================================================
//
// private methods
//
void LOW_deviceID::checkCRC()
{
__LOW_SYNCHRONIZE_METHOD_READ__
if ( LOW_helper_CRC::calcCRC8( romID, sizeof( romID)) != 0 )
throw LOW_helper_CRC::crc_error( "CRC checksum error in ROM ID", __FILE__, __LINE__);
}
void LOW_deviceID::setBit( const uint8_t /*inBitNum*/, const bool /*inValue*/)
{
}
void LOW_deviceID::setFamilyCode( const devFamCode_t /*inFamCode*/)
{
}
| [
"root@debian.localdomain"
] | root@debian.localdomain |
eb069a018a85df47023691c4183ffd5a2505fd07 | e2aca07940cde5a34022bd5f2daaca3ba4961c9e | /AnimationFSM/Animation.h | 659b6d415f2bf601664dde4bfbc3f35951c01bf8 | [] | no_license | AshleighHenry/FSMAni | de062a20aab6c94178ebe1741f49590f98ebf6a0 | 0a4a5b828f09ec1480f3c7a6444034bd4c332fd6 | refs/heads/master | 2020-04-04T17:46:37.824524 | 2018-11-12T11:01:32 | 2018-11-12T11:01:32 | 156,135,174 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 771 | h | #ifndef ANIMATION_H
#define ANIMATION_H
class Animation
{
// Please review very good article on Stackoverflow
// which covers some solutions to circular dependacies
// https://stackoverflow.com/questions/625799/resolve-build-errors-due-to-circular-dependency-amongst-classes
private:
class State* m_current; // note order of m_current is
// prior to setCurrent
class State* m_previous;
public:
Animation();
~Animation();
void setCurrent(State* s);
void setPrevious(State* s);
State* getCurrent();
State* getPrevious();
void idle();
void jumping();
void climbing();
void walking();
void swordsmanship();
void shoveling();
// Try uncommenting and comment the declaration above
//private:
// class State* m_current;
};
#endif // !ANIMATION_H
| [
"34344066+AshleighHenry@users.noreply.github.com"
] | 34344066+AshleighHenry@users.noreply.github.com |
ef06b02333a8bb2f261b35ae117e6bdd8bd4a3b0 | ef36544b396de62f3520e0f4396d1060dd34e29f | /C++11And14/main.cpp | 77ecef7ab44782323f5302e77ca1e6ee57f10ca9 | [] | no_license | dargouder/CPPSandbox | 092c87dba18bec1af583b4c8003ff7da447387dc | b4c9b0ab9da034acc27d258b7e66928adf223e4c | refs/heads/master | 2016-08-11T13:23:12.868249 | 2016-01-13T22:35:10 | 2016-01-13T22:35:10 | 49,006,730 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 181 | cpp | #include "SmartPointers.h"
#include "DiamondProblem.h"
#include "BasicTemplates.h"
int main() {
//TestUniquePtrMove();
//TestDiamondProblem();
TestBasicTemplate();
return 0;
} | [
"dargouder@gmail.com"
] | dargouder@gmail.com |
6426251c16063a13c01542590d842ed54f2275d9 | 6360920d56576528524ef306d5d110d881e6dd24 | /SkellyDefense/Source/SkellyDefense/SkellyDefensePlayerState.h | 6984ea6420ed0cfc757d87c8679544bf1996bc76 | [] | no_license | DylanWard14/Stones-Bones | 19f07edbcfb2f527739a7d576f0265ad02039f1f | 942411e1013cb671db5b9e19644f80fd0dced9c7 | refs/heads/master | 2021-01-23T01:52:06.249569 | 2017-04-30T07:18:41 | 2017-04-30T07:18:41 | 85,941,934 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 309 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "GameFramework/PlayerState.h"
#include "SkellyDefensePlayerState.generated.h"
UCLASS()
class SKELLYDEFENSE_API ASkellyDefensePlayerState : public APlayerState
{
GENERATED_BODY()
public:
private:
};
| [
"dylan.ward@iinet.net.au"
] | dylan.ward@iinet.net.au |
9527f96d6fb2d8b19021e8d3aee33fcd2f1660dd | e95fa74aa013255ffe80aff51223c1877ede6ecd | /C10_Libraries/Plugins/VRExpansionPlugin/OpenVRExpansionPlugin/Intermediate/Build/Win64/UE4/Inc/OpenVRExpansionPlugin/OpenVRExpansionFunctionLibrary.gen.cpp | c135f1f9ceedee7672ab6a6908f7ce1df80575e4 | [
"MIT"
] | permissive | PacktPublishing/Unreal-Engine-4-Virtual-Reality-Projects | 259151037a9e3d682ffd2036d4e6d4647d1765bd | 49d512598d32f224f1484e72543ea6862388a391 | refs/heads/master | 2023-01-29T18:02:26.072416 | 2023-01-18T09:59:22 | 2023-01-18T09:59:22 | 182,068,224 | 37 | 20 | null | null | null | null | UTF-8 | C++ | false | false | 232,544 | cpp | // Copyright 1998-2019 Epic Games, Inc. All Rights Reserved.
/*===========================================================================
Generated code exported from UnrealHeaderTool.
DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/
#include "UObject/GeneratedCppIncludes.h"
#include "OpenVRExpansionPlugin/Public/OpenVRExpansionFunctionLibrary.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeOpenVRExpansionFunctionLibrary() {}
// Cross Module References
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRHMDDeviceType();
UPackage* Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Matrix34();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_UInt64();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Int32();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Float();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Bool();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_String();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EBPSteamVRTrackedDeviceType();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EAsyncBlueprintResultSwitch();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EOpenVRCameraFrameType();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch();
OPENVREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRTrackedDeviceClass();
OPENVREXPANSIONPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FBPOpenVRCameraHandle();
OPENVREXPANSIONPLUGIN_API UClass* Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_NoRegister();
OPENVREXPANSIONPLUGIN_API UClass* Z_Construct_UClass_UOpenVRExpansionFunctionLibrary();
ENGINE_API UClass* Z_Construct_UClass_UBlueprintFunctionLibrary();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D();
ENGINE_API UClass* Z_Construct_UClass_UTexture2D_NoRegister();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FColor();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture();
PROCEDURALMESHCOMPONENT_API UClass* Z_Construct_UClass_UProceduralMeshComponent_NoRegister();
COREUOBJECT_API UClass* Z_Construct_UClass_UObject_NoRegister();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FTransform();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride();
ENGINE_API UClass* Z_Construct_UClass_UTexture_NoRegister();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair();
OPENVREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering();
// End Cross Module References
static UEnum* EBPOpenVRHMDDeviceType_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRHMDDeviceType, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EBPOpenVRHMDDeviceType"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EBPOpenVRHMDDeviceType>()
{
return EBPOpenVRHMDDeviceType_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EBPOpenVRHMDDeviceType(EBPOpenVRHMDDeviceType_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EBPOpenVRHMDDeviceType"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRHMDDeviceType_Hash() { return 262680962U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRHMDDeviceType()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EBPOpenVRHMDDeviceType"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRHMDDeviceType_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EBPOpenVRHMDDeviceType::DT_SteamVR", (int64)EBPOpenVRHMDDeviceType::DT_SteamVR },
{ "EBPOpenVRHMDDeviceType::DT_Vive", (int64)EBPOpenVRHMDDeviceType::DT_Vive },
{ "EBPOpenVRHMDDeviceType::DT_OculusHMD", (int64)EBPOpenVRHMDDeviceType::DT_OculusHMD },
{ "EBPOpenVRHMDDeviceType::DT_WindowsMR", (int64)EBPOpenVRHMDDeviceType::DT_WindowsMR },
{ "EBPOpenVRHMDDeviceType::DT_OSVR", (int64)EBPOpenVRHMDDeviceType::DT_OSVR },
{ "EBPOpenVRHMDDeviceType::DT_Unknown", (int64)EBPOpenVRHMDDeviceType::DT_Unknown },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "IsBlueprintBase", "true" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "This needs to be updated as the original gets changed, that or hope they make the original blueprint accessible." },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EBPOpenVRHMDDeviceType",
"EBPOpenVRHMDDeviceType",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EVRDeviceProperty_Matrix34_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Matrix34, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EVRDeviceProperty_Matrix34"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EVRDeviceProperty_Matrix34>()
{
return EVRDeviceProperty_Matrix34_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EVRDeviceProperty_Matrix34(EVRDeviceProperty_Matrix34_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EVRDeviceProperty_Matrix34"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Matrix34_Hash() { return 89680998U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Matrix34()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EVRDeviceProperty_Matrix34"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Matrix34_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EVRDeviceProperty_Matrix34::Prop_StatusDisplayTransform_Matrix34_1013", (int64)EVRDeviceProperty_Matrix34::Prop_StatusDisplayTransform_Matrix34_1013 },
{ "EVRDeviceProperty_Matrix34::HMDProp_CameraToHeadTransform_Matrix34_2016", (int64)EVRDeviceProperty_Matrix34::HMDProp_CameraToHeadTransform_Matrix34_2016 },
{ "EVRDeviceProperty_Matrix34::HMDProp_CameraToHeadTransforms_Matrix34_2055", (int64)EVRDeviceProperty_Matrix34::HMDProp_CameraToHeadTransforms_Matrix34_2055 },
{ "EVRDeviceProperty_Matrix34::HMDProp_ImuToHeadTransform_Matrix34_2063", (int64)EVRDeviceProperty_Matrix34::HMDProp_ImuToHeadTransform_Matrix34_2063 },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "HMDProp_CameraToHeadTransform_Matrix34_2016.DisplayName", "HMDProp_CameraToHeadTransform_Matrix34" },
{ "HMDProp_CameraToHeadTransform_Matrix34_2016.ToolTip", "1 Prefix = 2000 series" },
{ "HMDProp_CameraToHeadTransforms_Matrix34_2055.DisplayName", "HMDProp_CameraToHeadTransforms_Matrix34" },
{ "HMDProp_ImuToHeadTransform_Matrix34_2063.DisplayName", "HMDProp_ImToHeadTransform_Matrix34" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "Prop_StatusDisplayTransform_Matrix34_1013.DisplayName", "Prop_StatusDisplayTransform_Matrix34" },
{ "Prop_StatusDisplayTransform_Matrix34_1013.ToolTip", "No prefix = 1000 series" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EVRDeviceProperty_Matrix34",
"EVRDeviceProperty_Matrix34",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EVRDeviceProperty_UInt64_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_UInt64, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EVRDeviceProperty_UInt64"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EVRDeviceProperty_UInt64>()
{
return EVRDeviceProperty_UInt64_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EVRDeviceProperty_UInt64(EVRDeviceProperty_UInt64_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EVRDeviceProperty_UInt64"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_UInt64_Hash() { return 1937427929U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_UInt64()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EVRDeviceProperty_UInt64"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_UInt64_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EVRDeviceProperty_UInt64::Prop_HardwareRevision_Uint64_1017", (int64)EVRDeviceProperty_UInt64::Prop_HardwareRevision_Uint64_1017 },
{ "EVRDeviceProperty_UInt64::Prop_FirmwareVersion_Uint64_1018", (int64)EVRDeviceProperty_UInt64::Prop_FirmwareVersion_Uint64_1018 },
{ "EVRDeviceProperty_UInt64::Prop_FPGAVersion_Uint64_1019", (int64)EVRDeviceProperty_UInt64::Prop_FPGAVersion_Uint64_1019 },
{ "EVRDeviceProperty_UInt64::Prop_VRCVersion_Uint64_1020", (int64)EVRDeviceProperty_UInt64::Prop_VRCVersion_Uint64_1020 },
{ "EVRDeviceProperty_UInt64::Prop_RadioVersion_Uint64_1021", (int64)EVRDeviceProperty_UInt64::Prop_RadioVersion_Uint64_1021 },
{ "EVRDeviceProperty_UInt64::Prop_DongleVersion_Uint64_1022", (int64)EVRDeviceProperty_UInt64::Prop_DongleVersion_Uint64_1022 },
{ "EVRDeviceProperty_UInt64::Prop_ParentDriver_Uint64_1034", (int64)EVRDeviceProperty_UInt64::Prop_ParentDriver_Uint64_1034 },
{ "EVRDeviceProperty_UInt64::HMDProp_CurrentUniverseId_Uint64_2004", (int64)EVRDeviceProperty_UInt64::HMDProp_CurrentUniverseId_Uint64_2004 },
{ "EVRDeviceProperty_UInt64::HMDProp_PreviousUniverseId_Uint64_2005", (int64)EVRDeviceProperty_UInt64::HMDProp_PreviousUniverseId_Uint64_2005 },
{ "EVRDeviceProperty_UInt64::HMDProp_DisplayFirmwareVersion_Uint64_2006", (int64)EVRDeviceProperty_UInt64::HMDProp_DisplayFirmwareVersion_Uint64_2006 },
{ "EVRDeviceProperty_UInt64::HMDProp_CameraFirmwareVersion_Uint64_2027", (int64)EVRDeviceProperty_UInt64::HMDProp_CameraFirmwareVersion_Uint64_2027 },
{ "EVRDeviceProperty_UInt64::HMDProp_DisplayFPGAVersion_Uint64_2029", (int64)EVRDeviceProperty_UInt64::HMDProp_DisplayFPGAVersion_Uint64_2029 },
{ "EVRDeviceProperty_UInt64::HMDProp_DisplayBootloaderVersion_Uint64_2030", (int64)EVRDeviceProperty_UInt64::HMDProp_DisplayBootloaderVersion_Uint64_2030 },
{ "EVRDeviceProperty_UInt64::HMDProp_DisplayHardwareVersion_Uint64_2031", (int64)EVRDeviceProperty_UInt64::HMDProp_DisplayHardwareVersion_Uint64_2031 },
{ "EVRDeviceProperty_UInt64::HMDProp_AudioFirmwareVersion_Uint64_2032", (int64)EVRDeviceProperty_UInt64::HMDProp_AudioFirmwareVersion_Uint64_2032 },
{ "EVRDeviceProperty_UInt64::HMDProp_GraphicsAdapterLuid_Uint64_2045", (int64)EVRDeviceProperty_UInt64::HMDProp_GraphicsAdapterLuid_Uint64_2045 },
{ "EVRDeviceProperty_UInt64::HMDProp_AudioBridgeFirmwareVersion_Uint64_2061", (int64)EVRDeviceProperty_UInt64::HMDProp_AudioBridgeFirmwareVersion_Uint64_2061 },
{ "EVRDeviceProperty_UInt64::HMDProp_ImageBridgeFirmwareVersion_Uint64_2062", (int64)EVRDeviceProperty_UInt64::HMDProp_ImageBridgeFirmwareVersion_Uint64_2062 },
{ "EVRDeviceProperty_UInt64::ControllerProp_SupportedButtons_Uint64_3001", (int64)EVRDeviceProperty_UInt64::ControllerProp_SupportedButtons_Uint64_3001 },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "ControllerProp_SupportedButtons_Uint64_3001.DisplayName", "ControllerProp_SupportedButtons_Uint64" },
{ "ControllerProp_SupportedButtons_Uint64_3001.ToolTip", "2 Prefix = 3000 series" },
{ "HMDProp_AudioBridgeFirmwareVersion_Uint64_2061.DisplayName", "HMDProp_AudioBridgeFirmwareVersion_Uint64" },
{ "HMDProp_AudioFirmwareVersion_Uint64_2032.DisplayName", "HMDProp_AudioFirmwareVersion_Uint64" },
{ "HMDProp_CameraFirmwareVersion_Uint64_2027.DisplayName", "HMDProp_CameraFirmwareVersion_Uint64" },
{ "HMDProp_CurrentUniverseId_Uint64_2004.DisplayName", "HMDProp_CurrentUniverseId_Uint64" },
{ "HMDProp_CurrentUniverseId_Uint64_2004.ToolTip", "1 Prefix = 2000 series" },
{ "HMDProp_DisplayBootloaderVersion_Uint64_2030.DisplayName", "HMDProp_DisplayBootloaderVersion_Uint64" },
{ "HMDProp_DisplayFirmwareVersion_Uint64_2006.DisplayName", "HMDProp_DisplayFirmwareVersion_Uint64" },
{ "HMDProp_DisplayFPGAVersion_Uint64_2029.DisplayName", "HMDProp_DisplayFPGAVersion_Uint64" },
{ "HMDProp_DisplayHardwareVersion_Uint64_2031.DisplayName", "HMDProp_DisplayHardwareVersion_Uint64" },
{ "HMDProp_GraphicsAdapterLuid_Uint64_2045.DisplayName", "HMDProp_GraphicsAdapterLuid_Uint64" },
{ "HMDProp_ImageBridgeFirmwareVersion_Uint64_2062.DisplayName", "HMDProp_ImageBridgeFirmwareVersion_Uint64" },
{ "HMDProp_PreviousUniverseId_Uint64_2005.DisplayName", "HMDProp_PreviousUniverseId_Uint64" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "Prop_DongleVersion_Uint64_1022.DisplayName", "Prop_DongleVersion_Uint64" },
{ "Prop_FirmwareVersion_Uint64_1018.DisplayName", "Prop_FirmwareVersion_Uint64" },
{ "Prop_FPGAVersion_Uint64_1019.DisplayName", "Prop_FPGAVersion_Uint64" },
{ "Prop_HardwareRevision_Uint64_1017.DisplayName", "Prop_HardwareRevision_Uint64" },
{ "Prop_HardwareRevision_Uint64_1017.ToolTip", "No prefix = 1000 series" },
{ "Prop_ParentDriver_Uint64_1034.DisplayName", "Prop_ParentDriver_Uint64" },
{ "Prop_RadioVersion_Uint64_1021.DisplayName", "Prop_RadioVersion_Uint64" },
{ "Prop_VRCVersion_Uint64_1020.DisplayName", "Prop_VRCVersion_Uint64" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EVRDeviceProperty_UInt64",
"EVRDeviceProperty_UInt64",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EVRDeviceProperty_Int32_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Int32, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EVRDeviceProperty_Int32"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EVRDeviceProperty_Int32>()
{
return EVRDeviceProperty_Int32_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EVRDeviceProperty_Int32(EVRDeviceProperty_Int32_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EVRDeviceProperty_Int32"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Int32_Hash() { return 1180026245U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Int32()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EVRDeviceProperty_Int32"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Int32_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EVRDeviceProperty_Int32::Prop_DeviceClass_Int32_1029", (int64)EVRDeviceProperty_Int32::Prop_DeviceClass_Int32_1029 },
{ "EVRDeviceProperty_Int32::Prop_NumCameras_Int32_1039", (int64)EVRDeviceProperty_Int32::Prop_NumCameras_Int32_1039 },
{ "EVRDeviceProperty_Int32::Prop_CameraFrameLayout_Int32_1040", (int64)EVRDeviceProperty_Int32::Prop_CameraFrameLayout_Int32_1040 },
{ "EVRDeviceProperty_Int32::HMDProp_DisplayMCType_Int32_2008", (int64)EVRDeviceProperty_Int32::HMDProp_DisplayMCType_Int32_2008 },
{ "EVRDeviceProperty_Int32::HMDProp_EdidVendorID_Int32_2011", (int64)EVRDeviceProperty_Int32::HMDProp_EdidVendorID_Int32_2011 },
{ "EVRDeviceProperty_Int32::HMDProp_EdidProductID_Int32_2015", (int64)EVRDeviceProperty_Int32::HMDProp_EdidProductID_Int32_2015 },
{ "EVRDeviceProperty_Int32::HMDProp_DisplayGCType_Int32_2017", (int64)EVRDeviceProperty_Int32::HMDProp_DisplayGCType_Int32_2017 },
{ "EVRDeviceProperty_Int32::HMDProp_CameraCompatibilityMode_Int32_2033", (int64)EVRDeviceProperty_Int32::HMDProp_CameraCompatibilityMode_Int32_2033 },
{ "EVRDeviceProperty_Int32::HMDProp_DisplayMCImageWidth_Int32_2038", (int64)EVRDeviceProperty_Int32::HMDProp_DisplayMCImageWidth_Int32_2038 },
{ "EVRDeviceProperty_Int32::HMDProp_DisplayMCImageHeight_Int32_2039", (int64)EVRDeviceProperty_Int32::HMDProp_DisplayMCImageHeight_Int32_2039 },
{ "EVRDeviceProperty_Int32::HMDProp_DisplayMCImageNumChannels_Int32_2040", (int64)EVRDeviceProperty_Int32::HMDProp_DisplayMCImageNumChannels_Int32_2040 },
{ "EVRDeviceProperty_Int32::HMDProp_ExpectedTrackingReferenceCount_Int32_2049", (int64)EVRDeviceProperty_Int32::HMDProp_ExpectedTrackingReferenceCount_Int32_2049 },
{ "EVRDeviceProperty_Int32::HMDProp_ExpectedControllerCount_Int32_2050", (int64)EVRDeviceProperty_Int32::HMDProp_ExpectedControllerCount_Int32_2050 },
{ "EVRDeviceProperty_Int32::HMDProp_DistortionMeshResolution_Int32_2056", (int64)EVRDeviceProperty_Int32::HMDProp_DistortionMeshResolution_Int32_2056 },
{ "EVRDeviceProperty_Int32::ControllerProp_Axis0Type_Int32_3002", (int64)EVRDeviceProperty_Int32::ControllerProp_Axis0Type_Int32_3002 },
{ "EVRDeviceProperty_Int32::ControllerPropProp_Axis1Type_Int32_3003", (int64)EVRDeviceProperty_Int32::ControllerPropProp_Axis1Type_Int32_3003 },
{ "EVRDeviceProperty_Int32::ControllerPropProp_Axis2Type_Int32_3004", (int64)EVRDeviceProperty_Int32::ControllerPropProp_Axis2Type_Int32_3004 },
{ "EVRDeviceProperty_Int32::ControllerPropProp_Axis3Type_Int32_3005", (int64)EVRDeviceProperty_Int32::ControllerPropProp_Axis3Type_Int32_3005 },
{ "EVRDeviceProperty_Int32::ControllerPropProp_Axis4Type_Int32_3006", (int64)EVRDeviceProperty_Int32::ControllerPropProp_Axis4Type_Int32_3006 },
{ "EVRDeviceProperty_Int32::ControllerProp_ControllerRoleHint_Int32_3007", (int64)EVRDeviceProperty_Int32::ControllerProp_ControllerRoleHint_Int32_3007 },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "ControllerProp_Axis0Type_Int32_3002.DisplayName", "ControllerProp_Axis0Type_Int32" },
{ "ControllerProp_Axis0Type_Int32_3002.ToolTip", "2 Prefix = 3000 series" },
{ "ControllerProp_ControllerRoleHint_Int32_3007.DisplayName", "ControllerProp_ControllerRoleHint_Int32" },
{ "ControllerPropProp_Axis1Type_Int32_3003.DisplayName", "ControllerPropProp_Axis1Type_Int32" },
{ "ControllerPropProp_Axis2Type_Int32_3004.DisplayName", "ControllerPropProp_Axis2Type_Int32" },
{ "ControllerPropProp_Axis3Type_Int32_3005.DisplayName", "ControllerPropProp_Axis3Type_Int32" },
{ "ControllerPropProp_Axis4Type_Int32_3006.DisplayName", "ControllerPropProp_Axis4Type_Int32" },
{ "HMDProp_CameraCompatibilityMode_Int32_2033.DisplayName", "HMDProp_CameraCompatibilityMode_Int32" },
{ "HMDProp_DisplayGCType_Int32_2017.DisplayName", "HMDProp_DisplayGCType_Int32" },
{ "HMDProp_DisplayMCImageHeight_Int32_2039.DisplayName", "HMDProp_DisplayMCImageHeight_Int32" },
{ "HMDProp_DisplayMCImageNumChannels_Int32_2040.DisplayName", "HMDProp_DisplayMCImageNumChannels_Int32" },
{ "HMDProp_DisplayMCImageWidth_Int32_2038.DisplayName", "HMDProp_DisplayMCImageWidth_Int32" },
{ "HMDProp_DisplayMCType_Int32_2008.DisplayName", "HMDProp_DisplayMCType_Int32" },
{ "HMDProp_DisplayMCType_Int32_2008.ToolTip", "1 Prefix = 2000 series" },
{ "HMDProp_DistortionMeshResolution_Int32_2056.DisplayName", "HMDProp_DistortionMeshResolution_Int32" },
{ "HMDProp_EdidProductID_Int32_2015.DisplayName", "HMDProp_EdidProductID_Int32" },
{ "HMDProp_EdidVendorID_Int32_2011.DisplayName", "HMDProp_EdidVendorID_Int32" },
{ "HMDProp_ExpectedControllerCount_Int32_2050.DisplayName", "HMDProp_ExpectedControllerCount_Int32" },
{ "HMDProp_ExpectedTrackingReferenceCount_Int32_2049.DisplayName", "HMDProp_ExpectedTrackingReferenceCount_Int32" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "Prop_CameraFrameLayout_Int32_1040.DisplayName", "Prop_CameraFrameLayout_Int32" },
{ "Prop_DeviceClass_Int32_1029.DisplayName", "Prop_DeviceClass_Int32" },
{ "Prop_DeviceClass_Int32_1029.ToolTip", "No prefix = 1000 series" },
{ "Prop_NumCameras_Int32_1039.DisplayName", "Prop_NumCameras_Int32" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EVRDeviceProperty_Int32",
"EVRDeviceProperty_Int32",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EVRDeviceProperty_Float_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Float, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EVRDeviceProperty_Float"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EVRDeviceProperty_Float>()
{
return EVRDeviceProperty_Float_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EVRDeviceProperty_Float(EVRDeviceProperty_Float_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EVRDeviceProperty_Float"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Float_Hash() { return 337673807U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Float()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EVRDeviceProperty_Float"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Float_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EVRDeviceProperty_Float::Prop_DeviceBatteryPercentage_Float_1012", (int64)EVRDeviceProperty_Float::Prop_DeviceBatteryPercentage_Float_1012 },
{ "EVRDeviceProperty_Float::HMDProp_SecondsFromVsyncToPhotons_Float_2001", (int64)EVRDeviceProperty_Float::HMDProp_SecondsFromVsyncToPhotons_Float_2001 },
{ "EVRDeviceProperty_Float::HMDProp_DisplayFrequency_Float_2002", (int64)EVRDeviceProperty_Float::HMDProp_DisplayFrequency_Float_2002 },
{ "EVRDeviceProperty_Float::HMDProp_UserIpdMeters_Float_2003", (int64)EVRDeviceProperty_Float::HMDProp_UserIpdMeters_Float_2003 },
{ "EVRDeviceProperty_Float::HMDProp_DisplayMCOffset_Float_2009", (int64)EVRDeviceProperty_Float::HMDProp_DisplayMCOffset_Float_2009 },
{ "EVRDeviceProperty_Float::HMDProp_DisplayMCScale_Float_2010", (int64)EVRDeviceProperty_Float::HMDProp_DisplayMCScale_Float_2010 },
{ "EVRDeviceProperty_Float::HMDProp_DisplayGCBlackClamp_Float_2014", (int64)EVRDeviceProperty_Float::HMDProp_DisplayGCBlackClamp_Float_2014 },
{ "EVRDeviceProperty_Float::HMDProp_DisplayGCOffset_Float_2018", (int64)EVRDeviceProperty_Float::HMDProp_DisplayGCOffset_Float_2018 },
{ "EVRDeviceProperty_Float::HMDProp_DisplayGCScale_Float_2019", (int64)EVRDeviceProperty_Float::HMDProp_DisplayGCScale_Float_2019 },
{ "EVRDeviceProperty_Float::HMDProp_DisplayGCPrescale_Float_2020", (int64)EVRDeviceProperty_Float::HMDProp_DisplayGCPrescale_Float_2020 },
{ "EVRDeviceProperty_Float::HMDProp_LensCenterLeftU_Float_2022", (int64)EVRDeviceProperty_Float::HMDProp_LensCenterLeftU_Float_2022 },
{ "EVRDeviceProperty_Float::HMDProp_LensCenterLeftV_Float_2023", (int64)EVRDeviceProperty_Float::HMDProp_LensCenterLeftV_Float_2023 },
{ "EVRDeviceProperty_Float::HMDProp_LensCenterRightU_Float_2024", (int64)EVRDeviceProperty_Float::HMDProp_LensCenterRightU_Float_2024 },
{ "EVRDeviceProperty_Float::HMDProp_LensCenterRightV_Float_2025", (int64)EVRDeviceProperty_Float::HMDProp_LensCenterRightV_Float_2025 },
{ "EVRDeviceProperty_Float::HMDProp_UserHeadToEyeDepthMeters_Float_2026", (int64)EVRDeviceProperty_Float::HMDProp_UserHeadToEyeDepthMeters_Float_2026 },
{ "EVRDeviceProperty_Float::HMDProp_ScreenshotHorizontalFieldOfViewDegrees_Float_2034", (int64)EVRDeviceProperty_Float::HMDProp_ScreenshotHorizontalFieldOfViewDegrees_Float_2034 },
{ "EVRDeviceProperty_Float::HMDProp_ScreenshotVerticalFieldOfViewDegrees_Float_2035", (int64)EVRDeviceProperty_Float::HMDProp_ScreenshotVerticalFieldOfViewDegrees_Float_2035 },
{ "EVRDeviceProperty_Float::HMDProp_SecondsFromPhotonsToVblank_Float_2042", (int64)EVRDeviceProperty_Float::HMDProp_SecondsFromPhotonsToVblank_Float_2042 },
{ "EVRDeviceProperty_Float::HMDProp_MinimumIpdStepMeters_Float_2060", (int64)EVRDeviceProperty_Float::HMDProp_MinimumIpdStepMeters_Float_2060 },
{ "EVRDeviceProperty_Float::TrackRefProp_FieldOfViewLeftDegrees_Float_4000", (int64)EVRDeviceProperty_Float::TrackRefProp_FieldOfViewLeftDegrees_Float_4000 },
{ "EVRDeviceProperty_Float::TrackRefProp_FieldOfViewRightDegrees_Float_4001", (int64)EVRDeviceProperty_Float::TrackRefProp_FieldOfViewRightDegrees_Float_4001 },
{ "EVRDeviceProperty_Float::TrackRefProp_FieldOfViewTopDegrees_Float_4002", (int64)EVRDeviceProperty_Float::TrackRefProp_FieldOfViewTopDegrees_Float_4002 },
{ "EVRDeviceProperty_Float::TrackRefProp_FieldOfViewBottomDegrees_Float_4003", (int64)EVRDeviceProperty_Float::TrackRefProp_FieldOfViewBottomDegrees_Float_4003 },
{ "EVRDeviceProperty_Float::TrackRefProp_TrackingRangeMinimumMeters_Float_4004", (int64)EVRDeviceProperty_Float::TrackRefProp_TrackingRangeMinimumMeters_Float_4004 },
{ "EVRDeviceProperty_Float::TrackRefProp_TrackingRangeMaximumMeters_Float_4005", (int64)EVRDeviceProperty_Float::TrackRefProp_TrackingRangeMaximumMeters_Float_4005 },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "HMDProp_DisplayFrequency_Float_2002.DisplayName", "HMDProp_DisplayFrequency_Float" },
{ "HMDProp_DisplayGCBlackClamp_Float_2014.DisplayName", "HMDProp_DisplayGCBlackClamp_Float" },
{ "HMDProp_DisplayGCOffset_Float_2018.DisplayName", "HMDProp_DisplayGCOffset_Float" },
{ "HMDProp_DisplayGCPrescale_Float_2020.DisplayName", "HMDProp_DisplayGCPrescale_Float" },
{ "HMDProp_DisplayGCScale_Float_2019.DisplayName", "HMDProp_DisplayGCScale_Float" },
{ "HMDProp_DisplayMCOffset_Float_2009.DisplayName", "HMDProp_DisplayMCOffset_Float" },
{ "HMDProp_DisplayMCScale_Float_2010.DisplayName", "HMDProp_DisplayMCScale_Float" },
{ "HMDProp_LensCenterLeftU_Float_2022.DisplayName", "HMDProp_LensCenterLeftU_Float" },
{ "HMDProp_LensCenterLeftV_Float_2023.DisplayName", "HMDProp_LensCenterLeftV_Float" },
{ "HMDProp_LensCenterRightU_Float_2024.DisplayName", "HMDProp_LensCenterRightU_Float" },
{ "HMDProp_LensCenterRightV_Float_2025.DisplayName", "HMDProp_LensCenterRightV_Float" },
{ "HMDProp_MinimumIpdStepMeters_Float_2060.DisplayName", "HMDProp_MinimumIpdStepMeters_Float" },
{ "HMDProp_ScreenshotHorizontalFieldOfViewDegrees_Float_2034.DisplayName", "HMDProp_ScreenshotHorizontalFieldOfViewDegrees_Float" },
{ "HMDProp_ScreenshotVerticalFieldOfViewDegrees_Float_2035.DisplayName", "HMDProp_ScreenshotVerticalFieldOfViewDegrees_Float" },
{ "HMDProp_SecondsFromPhotonsToVblank_Float_2042.DisplayName", "HMDProp_SecondsFromPhotonsToVblank_Float" },
{ "HMDProp_SecondsFromVsyncToPhotons_Float_2001.DisplayName", "HMDProp_SecondsFromVsyncToPhotons_Float" },
{ "HMDProp_SecondsFromVsyncToPhotons_Float_2001.ToolTip", "1 Prefix = 2000 series" },
{ "HMDProp_UserHeadToEyeDepthMeters_Float_2026.DisplayName", "HMDProp_UserHeadToEyeDepthMeters_Float" },
{ "HMDProp_UserIpdMeters_Float_2003.DisplayName", "HMDProp_UserIpdMeters_Float" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "Prop_DeviceBatteryPercentage_Float_1012.DisplayName", "Prop_DeviceBatteryPercentage_Float" },
{ "Prop_DeviceBatteryPercentage_Float_1012.ToolTip", "No Prefix = 1000 series" },
{ "TrackRefProp_FieldOfViewBottomDegrees_Float_4003.DisplayName", "TrackRefProp_FieldOfViewBottomDegrees_Float" },
{ "TrackRefProp_FieldOfViewLeftDegrees_Float_4000.DisplayName", "TrackRefProp_FieldOfViewLeftDegrees_Float" },
{ "TrackRefProp_FieldOfViewLeftDegrees_Float_4000.ToolTip", "3 Prefix = 4000 series" },
{ "TrackRefProp_FieldOfViewRightDegrees_Float_4001.DisplayName", "TrackRefProp_FieldOfViewRightDegrees_Float" },
{ "TrackRefProp_FieldOfViewTopDegrees_Float_4002.DisplayName", "TrackRefProp_FieldOfViewTopDegrees_Float" },
{ "TrackRefProp_TrackingRangeMaximumMeters_Float_4005.DisplayName", "TrackRefProp_TrackingRangeMaximumMeters_Float" },
{ "TrackRefProp_TrackingRangeMinimumMeters_Float_4004.DisplayName", "TrackRefProp_TrackingRangeMinimumMeters_Float" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EVRDeviceProperty_Float",
"EVRDeviceProperty_Float",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EVRDeviceProperty_Bool_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Bool, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EVRDeviceProperty_Bool"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EVRDeviceProperty_Bool>()
{
return EVRDeviceProperty_Bool_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EVRDeviceProperty_Bool(EVRDeviceProperty_Bool_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EVRDeviceProperty_Bool"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Bool_Hash() { return 686159195U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Bool()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EVRDeviceProperty_Bool"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Bool_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EVRDeviceProperty_Bool::Prop_WillDriftInYaw_Bool_1004", (int64)EVRDeviceProperty_Bool::Prop_WillDriftInYaw_Bool_1004 },
{ "EVRDeviceProperty_Bool::Prop_DeviceIsWireless_Bool_1010", (int64)EVRDeviceProperty_Bool::Prop_DeviceIsWireless_Bool_1010 },
{ "EVRDeviceProperty_Bool::Prop_DeviceIsCharging_Bool_1011", (int64)EVRDeviceProperty_Bool::Prop_DeviceIsCharging_Bool_1011 },
{ "EVRDeviceProperty_Bool::Prop_Firmware_UpdateAvailable_Bool_1014", (int64)EVRDeviceProperty_Bool::Prop_Firmware_UpdateAvailable_Bool_1014 },
{ "EVRDeviceProperty_Bool::Prop_Firmware_ManualUpdate_Bool_1015", (int64)EVRDeviceProperty_Bool::Prop_Firmware_ManualUpdate_Bool_1015 },
{ "EVRDeviceProperty_Bool::Prop_BlockServerShutdown_Bool_1023", (int64)EVRDeviceProperty_Bool::Prop_BlockServerShutdown_Bool_1023 },
{ "EVRDeviceProperty_Bool::Prop_CanUnifyCoordinateSystemWithHmd_Bool_1024", (int64)EVRDeviceProperty_Bool::Prop_CanUnifyCoordinateSystemWithHmd_Bool_1024 },
{ "EVRDeviceProperty_Bool::Prop_ContainsProximitySensor_Bool_1025", (int64)EVRDeviceProperty_Bool::Prop_ContainsProximitySensor_Bool_1025 },
{ "EVRDeviceProperty_Bool::Prop_DeviceProvidesBatteryStatus_Bool_1026", (int64)EVRDeviceProperty_Bool::Prop_DeviceProvidesBatteryStatus_Bool_1026 },
{ "EVRDeviceProperty_Bool::Prop_DeviceCanPowerOff_Bool_1027", (int64)EVRDeviceProperty_Bool::Prop_DeviceCanPowerOff_Bool_1027 },
{ "EVRDeviceProperty_Bool::Prop_HasCamera_Bool_1030", (int64)EVRDeviceProperty_Bool::Prop_HasCamera_Bool_1030 },
{ "EVRDeviceProperty_Bool::Prop_Firmware_ForceUpdateRequired_Bool_1032", (int64)EVRDeviceProperty_Bool::Prop_Firmware_ForceUpdateRequired_Bool_1032 },
{ "EVRDeviceProperty_Bool::Prop_ViveSystemButtonFixRequired_Bool_1033", (int64)EVRDeviceProperty_Bool::Prop_ViveSystemButtonFixRequired_Bool_1033 },
{ "EVRDeviceProperty_Bool::Prop_NeverTracked_Bool_1038", (int64)EVRDeviceProperty_Bool::Prop_NeverTracked_Bool_1038 },
{ "EVRDeviceProperty_Bool::HMDProp_ReportsTimeSinceVSync_Bool_2000", (int64)EVRDeviceProperty_Bool::HMDProp_ReportsTimeSinceVSync_Bool_2000 },
{ "EVRDeviceProperty_Bool::HMDProp_IsOnDesktop_Bool_2007", (int64)EVRDeviceProperty_Bool::HMDProp_IsOnDesktop_Bool_2007 },
{ "EVRDeviceProperty_Bool::HMDProp_DisplaySuppressed_Bool_2036", (int64)EVRDeviceProperty_Bool::HMDProp_DisplaySuppressed_Bool_2036 },
{ "EVRDeviceProperty_Bool::HMDProp_DisplayAllowNightMode_Bool_2037", (int64)EVRDeviceProperty_Bool::HMDProp_DisplayAllowNightMode_Bool_2037 },
{ "EVRDeviceProperty_Bool::HMDProp_DriverDirectModeSendsVsyncEvents_Bool_2043", (int64)EVRDeviceProperty_Bool::HMDProp_DriverDirectModeSendsVsyncEvents_Bool_2043 },
{ "EVRDeviceProperty_Bool::HMDProp_DisplayDebugMode_Bool_2044", (int64)EVRDeviceProperty_Bool::HMDProp_DisplayDebugMode_Bool_2044 },
{ "EVRDeviceProperty_Bool::HMDProp_DoNotApplyPrediction_Bool_2054", (int64)EVRDeviceProperty_Bool::HMDProp_DoNotApplyPrediction_Bool_2054 },
{ "EVRDeviceProperty_Bool::HMDProp_DriverIsDrawingControllers_Bool_2057", (int64)EVRDeviceProperty_Bool::HMDProp_DriverIsDrawingControllers_Bool_2057 },
{ "EVRDeviceProperty_Bool::HMDProp_DriverRequestsApplicationPause_Bool_2058", (int64)EVRDeviceProperty_Bool::HMDProp_DriverRequestsApplicationPause_Bool_2058 },
{ "EVRDeviceProperty_Bool::HMDProp_DriverRequestsReducedRendering_Bool_2059", (int64)EVRDeviceProperty_Bool::HMDProp_DriverRequestsReducedRendering_Bool_2059 },
{ "EVRDeviceProperty_Bool::HMDProp_ConfigurationIncludesLighthouse20Features_Bool_2069", (int64)EVRDeviceProperty_Bool::HMDProp_ConfigurationIncludesLighthouse20Features_Bool_2069 },
{ "EVRDeviceProperty_Bool::DriverProp_HasDisplayComponent_Bool_6002", (int64)EVRDeviceProperty_Bool::DriverProp_HasDisplayComponent_Bool_6002 },
{ "EVRDeviceProperty_Bool::DriverProp_HasControllerComponent_Bool_6003", (int64)EVRDeviceProperty_Bool::DriverProp_HasControllerComponent_Bool_6003 },
{ "EVRDeviceProperty_Bool::DriverProp_HasCameraComponent_Bool_6004", (int64)EVRDeviceProperty_Bool::DriverProp_HasCameraComponent_Bool_6004 },
{ "EVRDeviceProperty_Bool::DriverProp_HasDriverDirectModeComponent_Bool_6005", (int64)EVRDeviceProperty_Bool::DriverProp_HasDriverDirectModeComponent_Bool_6005 },
{ "EVRDeviceProperty_Bool::DriverProp_HasVirtualDisplayComponent_Bool_6006", (int64)EVRDeviceProperty_Bool::DriverProp_HasVirtualDisplayComponent_Bool_6006 },
{ "EVRDeviceProperty_Bool::DriverProp_HasSpatialAnchorsSupport_Bool_6007", (int64)EVRDeviceProperty_Bool::DriverProp_HasSpatialAnchorsSupport_Bool_6007 },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "DriverProp_HasCameraComponent_Bool_6004.DisplayName", "DriverProp_HasCameraComponent_Bool" },
{ "DriverProp_HasControllerComponent_Bool_6003.DisplayName", "DriverProp_HasControllerComponent_Bool" },
{ "DriverProp_HasDisplayComponent_Bool_6002.DisplayName", "DriverProp_HasDisplayComponent_Bool" },
{ "DriverProp_HasDisplayComponent_Bool_6002.ToolTip", "5 prefix = 6000 series" },
{ "DriverProp_HasDriverDirectModeComponent_Bool_6005.DisplayName", "DriverProp_HasDriverDirectModeComponent_Bool" },
{ "DriverProp_HasSpatialAnchorsSupport_Bool_6007.DisplayName", "DriverProp_HasSpatialAnchorsSupport_Bool" },
{ "DriverProp_HasVirtualDisplayComponent_Bool_6006.DisplayName", "DriverProp_HasVirtualDisplayComponent_Bool" },
{ "HMDProp_ConfigurationIncludesLighthouse20Features_Bool_2069.DisplayName", "HMDProp_ConfigurationIncludesLighthouse20Features_Bool" },
{ "HMDProp_DisplayAllowNightMode_Bool_2037.DisplayName", "HMDProp_DisplayAllowNightMode_Bool" },
{ "HMDProp_DisplayDebugMode_Bool_2044.DisplayName", "HMDProp_DisplayDebugMode_Bool" },
{ "HMDProp_DisplaySuppressed_Bool_2036.DisplayName", "HMDProp_DisplaySuppressed_Bool" },
{ "HMDProp_DoNotApplyPrediction_Bool_2054.DisplayName", "HMDProp_DoNotApplyPrediction_Bool" },
{ "HMDProp_DriverDirectModeSendsVsyncEvents_Bool_2043.DisplayName", "HMDProp_DriverDirectModeSendsVsyncEvents_Bool" },
{ "HMDProp_DriverIsDrawingControllers_Bool_2057.DisplayName", "HMDProp_DriverIsDrawingControllers_Bool" },
{ "HMDProp_DriverRequestsApplicationPause_Bool_2058.DisplayName", "HMDProp_DriverRequestsApplicationPause_Bool" },
{ "HMDProp_DriverRequestsReducedRendering_Bool_2059.DisplayName", "HMDProp_DriverRequestsReducedRendering_Bool" },
{ "HMDProp_IsOnDesktop_Bool_2007.DisplayName", "HMDProp_IsOnDesktop_Bool" },
{ "HMDProp_ReportsTimeSinceVSync_Bool_2000.DisplayName", "HMDProp_ReportsTimeSinceVSync_Bool" },
{ "HMDProp_ReportsTimeSinceVSync_Bool_2000.ToolTip", "1 prefix = 2000 series" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "Prop_BlockServerShutdown_Bool_1023.DisplayName", "Prop_BlockServerShutdown_Bool" },
{ "Prop_CanUnifyCoordinateSystemWithHmd_Bool_1024.DisplayName", "Prop_CanUnifyCoordinateSystemWithHmd_Bool" },
{ "Prop_ContainsProximitySensor_Bool_1025.DisplayName", "Prop_ContainsProximitySensor_Bool" },
{ "Prop_DeviceCanPowerOff_Bool_1027.DisplayName", "Prop_DeviceCanPowerOff_Bool" },
{ "Prop_DeviceIsCharging_Bool_1011.DisplayName", "Prop_DeviceIsCharging_Bool" },
{ "Prop_DeviceIsWireless_Bool_1010.DisplayName", "Prop_DeviceIsWireless_Bool" },
{ "Prop_DeviceProvidesBatteryStatus_Bool_1026.DisplayName", "Prop_DeviceProvidesBatteryStatus_Bool" },
{ "Prop_Firmware_ForceUpdateRequired_Bool_1032.DisplayName", "Prop_Firmware_ForceUpdateRequired_Bool" },
{ "Prop_Firmware_ManualUpdate_Bool_1015.DisplayName", "Prop_Firmware_ManualUpdate_Bool" },
{ "Prop_Firmware_UpdateAvailable_Bool_1014.DisplayName", "Prop_Firmware_UpdateAvailable_Bool" },
{ "Prop_HasCamera_Bool_1030.DisplayName", "Prop_HasCamera_Bool" },
{ "Prop_NeverTracked_Bool_1038.DisplayName", "Prop_NeverTracked_Bool" },
{ "Prop_ViveSystemButtonFixRequired_Bool_1033.DisplayName", "Prop_ViveSystemButtonFixRequired_Bool" },
{ "Prop_WillDriftInYaw_Bool_1004.DisplayName", "Prop_WillDriftInYaw_Bool" },
{ "Prop_WillDriftInYaw_Bool_1004.ToolTip", "No prefix = 1000 series" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EVRDeviceProperty_Bool",
"EVRDeviceProperty_Bool",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EVRDeviceProperty_String_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_String, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EVRDeviceProperty_String"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EVRDeviceProperty_String>()
{
return EVRDeviceProperty_String_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EVRDeviceProperty_String(EVRDeviceProperty_String_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EVRDeviceProperty_String"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_String_Hash() { return 2686142950U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_String()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EVRDeviceProperty_String"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_String_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EVRDeviceProperty_String::Prop_TrackingSystemName_String_1000", (int64)EVRDeviceProperty_String::Prop_TrackingSystemName_String_1000 },
{ "EVRDeviceProperty_String::Prop_ModelNumber_String_1001", (int64)EVRDeviceProperty_String::Prop_ModelNumber_String_1001 },
{ "EVRDeviceProperty_String::Prop_SerialNumber_String_1002", (int64)EVRDeviceProperty_String::Prop_SerialNumber_String_1002 },
{ "EVRDeviceProperty_String::Prop_RenderModelName_String_1003", (int64)EVRDeviceProperty_String::Prop_RenderModelName_String_1003 },
{ "EVRDeviceProperty_String::Prop_ManufacturerName_String_1005", (int64)EVRDeviceProperty_String::Prop_ManufacturerName_String_1005 },
{ "EVRDeviceProperty_String::Prop_TrackingFirmwareVersion_String_1006", (int64)EVRDeviceProperty_String::Prop_TrackingFirmwareVersion_String_1006 },
{ "EVRDeviceProperty_String::Prop_HardwareRevision_String_1007", (int64)EVRDeviceProperty_String::Prop_HardwareRevision_String_1007 },
{ "EVRDeviceProperty_String::Prop_AllWirelessDongleDescriptions_String_1008", (int64)EVRDeviceProperty_String::Prop_AllWirelessDongleDescriptions_String_1008 },
{ "EVRDeviceProperty_String::Prop_ConnectedWirelessDongle_String_1009", (int64)EVRDeviceProperty_String::Prop_ConnectedWirelessDongle_String_1009 },
{ "EVRDeviceProperty_String::Prop_Firmware_ManualUpdateURL_String_1016", (int64)EVRDeviceProperty_String::Prop_Firmware_ManualUpdateURL_String_1016 },
{ "EVRDeviceProperty_String::Prop_Firmware_ProgrammingTarget_String_1028", (int64)EVRDeviceProperty_String::Prop_Firmware_ProgrammingTarget_String_1028 },
{ "EVRDeviceProperty_String::Prop_DriverVersion_String_1031", (int64)EVRDeviceProperty_String::Prop_DriverVersion_String_1031 },
{ "EVRDeviceProperty_String::Prop_ResourceRoot_String_1035", (int64)EVRDeviceProperty_String::Prop_ResourceRoot_String_1035 },
{ "EVRDeviceProperty_String::Prop_RegisteredDeviceType_String_1036", (int64)EVRDeviceProperty_String::Prop_RegisteredDeviceType_String_1036 },
{ "EVRDeviceProperty_String::Prop_InputProfileName_String_1037", (int64)EVRDeviceProperty_String::Prop_InputProfileName_String_1037 },
{ "EVRDeviceProperty_String::HMDProp_DisplayMCImageLeft_String_2012", (int64)EVRDeviceProperty_String::HMDProp_DisplayMCImageLeft_String_2012 },
{ "EVRDeviceProperty_String::HMDProp_DisplayMCImageRight_String_2013", (int64)EVRDeviceProperty_String::HMDProp_DisplayMCImageRight_String_2013 },
{ "EVRDeviceProperty_String::HMDProp_DisplayGCImage_String_2021", (int64)EVRDeviceProperty_String::HMDProp_DisplayGCImage_String_2021 },
{ "EVRDeviceProperty_String::HMDProp_CameraFirmwareDescription_String_2028", (int64)EVRDeviceProperty_String::HMDProp_CameraFirmwareDescription_String_2028 },
{ "EVRDeviceProperty_String::HMDProp_DriverProvidedChaperonePath_String_2048", (int64)EVRDeviceProperty_String::HMDProp_DriverProvidedChaperonePath_String_2048 },
{ "EVRDeviceProperty_String::ControllerProp_AttachedDeviceId_String_3000", (int64)EVRDeviceProperty_String::ControllerProp_AttachedDeviceId_String_3000 },
{ "EVRDeviceProperty_String::TrackRefProp_ModeLabel_String_4006", (int64)EVRDeviceProperty_String::TrackRefProp_ModeLabel_String_4006 },
{ "EVRDeviceProperty_String::UIProp_NamedIconPathDeviceOff_String_5001", (int64)EVRDeviceProperty_String::UIProp_NamedIconPathDeviceOff_String_5001 },
{ "EVRDeviceProperty_String::UIProp_NamedIconPathDeviceSearching_String_5002", (int64)EVRDeviceProperty_String::UIProp_NamedIconPathDeviceSearching_String_5002 },
{ "EVRDeviceProperty_String::UIProp_NamedIconPathDeviceSearchingAlert_String_5003", (int64)EVRDeviceProperty_String::UIProp_NamedIconPathDeviceSearchingAlert_String_5003 },
{ "EVRDeviceProperty_String::UIProp_NamedIconPathDeviceReady_String_5004", (int64)EVRDeviceProperty_String::UIProp_NamedIconPathDeviceReady_String_5004 },
{ "EVRDeviceProperty_String::UIProp_NamedIconPathDeviceReadyAlert_String_5005", (int64)EVRDeviceProperty_String::UIProp_NamedIconPathDeviceReadyAlert_String_5005 },
{ "EVRDeviceProperty_String::UIProp_NamedIconPathDeviceNotReady_String_5006", (int64)EVRDeviceProperty_String::UIProp_NamedIconPathDeviceNotReady_String_5006 },
{ "EVRDeviceProperty_String::UIProp_NamedIconPathDeviceStandby_String_5007", (int64)EVRDeviceProperty_String::UIProp_NamedIconPathDeviceStandby_String_5007 },
{ "EVRDeviceProperty_String::UIProp_NamedIconPathDeviceAlertLow_String_5008", (int64)EVRDeviceProperty_String::UIProp_NamedIconPathDeviceAlertLow_String_5008 },
{ "EVRDeviceProperty_String::DriverProp_UserConfigPath_String_6000", (int64)EVRDeviceProperty_String::DriverProp_UserConfigPath_String_6000 },
{ "EVRDeviceProperty_String::DriverProp_InstallPath_String_6001", (int64)EVRDeviceProperty_String::DriverProp_InstallPath_String_6001 },
{ "EVRDeviceProperty_String::DriverProp_ControllerType_String_7000", (int64)EVRDeviceProperty_String::DriverProp_ControllerType_String_7000 },
{ "EVRDeviceProperty_String::DriveerProp_LegacyInputProfile_String_7001", (int64)EVRDeviceProperty_String::DriveerProp_LegacyInputProfile_String_7001 },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "ControllerProp_AttachedDeviceId_String_3000.DisplayName", "ControllerProp_AttachedDeviceId_String" },
{ "ControllerProp_AttachedDeviceId_String_3000.ToolTip", "2 prefix = 3000 series" },
{ "DriveerProp_LegacyInputProfile_String_7001.DisplayName", "DriveerProp_LegacyInputProfile_String" },
{ "DriverProp_ControllerType_String_7000.DisplayName", "DriverProp_ControllerType_String" },
{ "DriverProp_ControllerType_String_7000.ToolTip", "Properties that are set internally based on other information provided by drivers" },
{ "DriverProp_InstallPath_String_6001.DisplayName", "DriverProp_InstallPath_String" },
{ "DriverProp_UserConfigPath_String_6000.DisplayName", "DriverProp_UserConfigPath_String" },
{ "DriverProp_UserConfigPath_String_6000.ToolTip", "5 prefix = 6000 series" },
{ "HMDProp_CameraFirmwareDescription_String_2028.DisplayName", "HMDProp_CameraFirmwareDescription_String" },
{ "HMDProp_DisplayGCImage_String_2021.DisplayName", "HMDProp_DisplayGCImage_String" },
{ "HMDProp_DisplayMCImageLeft_String_2012.DisplayName", "HMDProp_DisplayMCImageLeft_String" },
{ "HMDProp_DisplayMCImageLeft_String_2012.ToolTip", "1 prefix = 2000 series" },
{ "HMDProp_DisplayMCImageRight_String_2013.DisplayName", "HMDProp_DisplayMCImageRight_String" },
{ "HMDProp_DriverProvidedChaperonePath_String_2048.DisplayName", "HMDProp_DriverProvidedChaperonePath_String" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "Prop_AllWirelessDongleDescriptions_String_1008.DisplayName", "Prop_AllWirelessDongleDescriptions_String" },
{ "Prop_ConnectedWirelessDongle_String_1009.DisplayName", "Prop_ConnectedWirelessDongle_String" },
{ "Prop_DriverVersion_String_1031.DisplayName", "Prop_DriverVersion_String" },
{ "Prop_Firmware_ManualUpdateURL_String_1016.DisplayName", "Prop_Firmware_ManualUpdateURL_String" },
{ "Prop_Firmware_ProgrammingTarget_String_1028.DisplayName", "Prop_Firmware_ProgrammingTarget_String" },
{ "Prop_HardwareRevision_String_1007.DisplayName", "Prop_HardwareRevision_String" },
{ "Prop_InputProfileName_String_1037.DisplayName", "Prop_InputProfileName_String" },
{ "Prop_ManufacturerName_String_1005.DisplayName", "Prop_ManufacturerName_String" },
{ "Prop_ModelNumber_String_1001.DisplayName", "Prop_ModelNumber_String" },
{ "Prop_RegisteredDeviceType_String_1036.DisplayName", "Prop_RegisteredDeviceType_String" },
{ "Prop_RenderModelName_String_1003.DisplayName", "Prop_RenderModelName_String" },
{ "Prop_ResourceRoot_String_1035.DisplayName", "Prop_ResourceRoot_String" },
{ "Prop_SerialNumber_String_1002.DisplayName", "Prop_SerialNumber_String" },
{ "Prop_TrackingFirmwareVersion_String_1006.DisplayName", "Prop_TrackingFirmwareVersion_String" },
{ "Prop_TrackingSystemName_String_1000.DisplayName", "Prop_TrackingSystemName_String" },
{ "Prop_TrackingSystemName_String_1000.ToolTip", "No prefix = 1000 series" },
{ "ToolTip", "// Not implementing currently\n\n// Properties that are unique to TrackedDeviceClass_HMD\nProp_DisplayMCImageData_Binary = 2041,\n\nProp_IconPathName_String = 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.\n\n\n// Not implemented because very little use, and names are huuggge.....\nProp_NamedIconPathControllerLeftDeviceOff_String_2051\nProp_NamedIconPAthControllerRightDeviceOff_String_2052\nProp_NamedIconPathTrackingReferenceDeviceOff_String_2053\n\n\n// Properties that are used by helpers, but are opaque to applications\nProp_DisplayHiddenArea_Binary_Start = 5100,\nProp_DisplayHiddenArea_Binary_End = 5150,\nProp_ParentContainer = 5151\n\n// Vendors are free to expose private debug data in this reserved region\nProp_VendorSpecific_Reserved_Start = 10000,\nProp_VendorSpecific_Reserved_End = 10999,\n\nProp_ImuFactoryGyroBias_Vector3 = 2064,\nProp_ImuFactoryGyroScale_Vector3 = 2065,\nProp_ImuFactoryAccelerometerBias_Vector3 = 2066,\nProp_ImuFactoryAccelerometerScale_Vector3 = 2067,\n// reserved 2068\n\n// Driver requested mura correction properties\nProp_DriverRequestedMuraCorrectionMode_Int32 = 2200,\nProp_DriverRequestedMuraFeather_InnerLeft_Int32 = 2201,\nProp_DriverRequestedMuraFeather_InnerRight_Int32 = 2202,\nProp_DriverRequestedMuraFeather_InnerTop_Int32 = 2203,\nProp_DriverRequestedMuraFeather_InnerBottom_Int32 = 2204,\nProp_DriverRequestedMuraFeather_OuterLeft_Int32 = 2205,\nProp_DriverRequestedMuraFeather_OuterRight_Int32 = 2206,\nProp_DriverRequestedMuraFeather_OuterTop_Int32 = 2207,\nProp_DriverRequestedMuraFeather_OuterBottom_Int32 = 2208,\n\nProp_TrackedDeviceProperty_Max = 1000000,\n// #TODO: Update these" },
{ "TrackRefProp_ModeLabel_String_4006.DisplayName", "TrackRefProp_ModeLabel_String" },
{ "TrackRefProp_ModeLabel_String_4006.ToolTip", "3 prefix = 4000 series" },
{ "UIProp_NamedIconPathDeviceAlertLow_String_5008.DisplayName", "UIProp_NamedIconPathDeviceAlertLow_String" },
{ "UIProp_NamedIconPathDeviceNotReady_String_5006.DisplayName", "UIProp_NamedIconPathDeviceNotReady_String" },
{ "UIProp_NamedIconPathDeviceOff_String_5001.DisplayName", "UIProp_NamedIconPathDeviceOff_String" },
{ "UIProp_NamedIconPathDeviceOff_String_5001.ToolTip", "4 prefix = 5000 series" },
{ "UIProp_NamedIconPathDeviceReady_String_5004.DisplayName", "UIProp_NamedIconPathDeviceReady_String" },
{ "UIProp_NamedIconPathDeviceReadyAlert_String_5005.DisplayName", "UIProp_NamedIconPathDeviceReadyAlert_String" },
{ "UIProp_NamedIconPathDeviceSearching_String_5002.DisplayName", "UIProp_NamedIconPathDeviceSearching_String" },
{ "UIProp_NamedIconPathDeviceSearchingAlert_String_5003.DisplayName", "UIProp_NamedIconPathDeviceSearchingAlert_String_" },
{ "UIProp_NamedIconPathDeviceStandby_String_5007.DisplayName", "UIProp_NamedIconPathDeviceStandby_String" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EVRDeviceProperty_String",
"EVRDeviceProperty_String",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EBPSteamVRTrackedDeviceType_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EBPSteamVRTrackedDeviceType, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EBPSteamVRTrackedDeviceType"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EBPSteamVRTrackedDeviceType>()
{
return EBPSteamVRTrackedDeviceType_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EBPSteamVRTrackedDeviceType(EBPSteamVRTrackedDeviceType_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EBPSteamVRTrackedDeviceType"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EBPSteamVRTrackedDeviceType_Hash() { return 281872165U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EBPSteamVRTrackedDeviceType()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EBPSteamVRTrackedDeviceType"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EBPSteamVRTrackedDeviceType_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EBPSteamVRTrackedDeviceType::Controller", (int64)EBPSteamVRTrackedDeviceType::Controller },
{ "EBPSteamVRTrackedDeviceType::TrackingReference", (int64)EBPSteamVRTrackedDeviceType::TrackingReference },
{ "EBPSteamVRTrackedDeviceType::Other", (int64)EBPSteamVRTrackedDeviceType::Other },
{ "EBPSteamVRTrackedDeviceType::Invalid", (int64)EBPSteamVRTrackedDeviceType::Invalid },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "Controller.ToolTip", "Represents a Steam VR Controller" },
{ "Invalid.ToolTip", "DeviceId is invalid" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "Other.ToolTip", "Misc. device types, for future expansion" },
{ "ToolTip", "#TODO: Update these" },
{ "TrackingReference.ToolTip", "Represents a static tracking reference device, such as a Lighthouse or tracking camera" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EBPSteamVRTrackedDeviceType",
"EBPSteamVRTrackedDeviceType",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EAsyncBlueprintResultSwitch_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EAsyncBlueprintResultSwitch, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EAsyncBlueprintResultSwitch"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EAsyncBlueprintResultSwitch>()
{
return EAsyncBlueprintResultSwitch_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EAsyncBlueprintResultSwitch(EAsyncBlueprintResultSwitch_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EAsyncBlueprintResultSwitch"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EAsyncBlueprintResultSwitch_Hash() { return 1296090939U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EAsyncBlueprintResultSwitch()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EAsyncBlueprintResultSwitch"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EAsyncBlueprintResultSwitch_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EAsyncBlueprintResultSwitch::OnSuccess", (int64)EAsyncBlueprintResultSwitch::OnSuccess },
{ "EAsyncBlueprintResultSwitch::AsyncLoading", (int64)EAsyncBlueprintResultSwitch::AsyncLoading },
{ "EAsyncBlueprintResultSwitch::OnFailure", (int64)EAsyncBlueprintResultSwitch::OnFailure },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "AsyncLoading.ToolTip", "On still loading async" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "OnFailure.ToolTip", "On Failure" },
{ "OnSuccess.ToolTip", "On Success" },
{ "ToolTip", "This will make using the load model as async easier to understand" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EAsyncBlueprintResultSwitch",
"EAsyncBlueprintResultSwitch",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EOpenVRCameraFrameType_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EOpenVRCameraFrameType, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EOpenVRCameraFrameType"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EOpenVRCameraFrameType>()
{
return EOpenVRCameraFrameType_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EOpenVRCameraFrameType(EOpenVRCameraFrameType_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EOpenVRCameraFrameType"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EOpenVRCameraFrameType_Hash() { return 4242529707U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EOpenVRCameraFrameType()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EOpenVRCameraFrameType"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EOpenVRCameraFrameType_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EOpenVRCameraFrameType::VRFrameType_Distorted", (int64)EOpenVRCameraFrameType::VRFrameType_Distorted },
{ "EOpenVRCameraFrameType::VRFrameType_Undistorted", (int64)EOpenVRCameraFrameType::VRFrameType_Undistorted },
{ "EOpenVRCameraFrameType::VRFrameType_MaximumUndistorted", (int64)EOpenVRCameraFrameType::VRFrameType_MaximumUndistorted },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EOpenVRCameraFrameType",
"EOpenVRCameraFrameType",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EBPOVRResultSwitch_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EBPOVRResultSwitch"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EBPOVRResultSwitch>()
{
return EBPOVRResultSwitch_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EBPOVRResultSwitch(EBPOVRResultSwitch_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EBPOVRResultSwitch"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch_Hash() { return 2816845299U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EBPOVRResultSwitch"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EBPOVRResultSwitch::OnSucceeded", (int64)EBPOVRResultSwitch::OnSucceeded },
{ "EBPOVRResultSwitch::OnFailed", (int64)EBPOVRResultSwitch::OnFailed },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "OnFailed.ToolTip", "On Failure" },
{ "OnSucceeded.ToolTip", "On Success" },
{ "ToolTip", "This makes a lot of the blueprint functions cleaner" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EBPOVRResultSwitch",
"EBPOVRResultSwitch",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
static UEnum* EBPOpenVRTrackedDeviceClass_StaticEnum()
{
static UEnum* Singleton = nullptr;
if (!Singleton)
{
Singleton = GetStaticEnum(Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRTrackedDeviceClass, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("EBPOpenVRTrackedDeviceClass"));
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UEnum* StaticEnum<EBPOpenVRTrackedDeviceClass>()
{
return EBPOpenVRTrackedDeviceClass_StaticEnum();
}
static FCompiledInDeferEnum Z_CompiledInDeferEnum_UEnum_EBPOpenVRTrackedDeviceClass(EBPOpenVRTrackedDeviceClass_StaticEnum, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("EBPOpenVRTrackedDeviceClass"), false, nullptr, nullptr);
uint32 Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRTrackedDeviceClass_Hash() { return 1564419144U; }
UEnum* Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRTrackedDeviceClass()
{
#if WITH_HOT_RELOAD
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UEnum* ReturnEnum = FindExistingEnumIfHotReloadOrDynamic(Outer, TEXT("EBPOpenVRTrackedDeviceClass"), 0, Get_Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRTrackedDeviceClass_Hash(), false);
#else
static UEnum* ReturnEnum = nullptr;
#endif // WITH_HOT_RELOAD
if (!ReturnEnum)
{
static const UE4CodeGen_Private::FEnumeratorParam Enumerators[] = {
{ "EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_Invalid", (int64)EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_Invalid },
{ "EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_HMD", (int64)EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_HMD },
{ "EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_Controller", (int64)EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_Controller },
{ "EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_GenericTracker", (int64)EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_GenericTracker },
{ "EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_TrackingReference", (int64)EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_TrackingReference },
{ "EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_DisplayRedirect", (int64)EBPOpenVRTrackedDeviceClass::TrackedDeviceClass_DisplayRedirect },
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Enum_MetaDataParams[] = {
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "TrackedDeviceClass_Controller.ToolTip", "Head-Mounted Displays" },
{ "TrackedDeviceClass_DisplayRedirect.ToolTip", "Camera and base stations that serve as tracking reference points" },
{ "TrackedDeviceClass_GenericTracker.ToolTip", "Tracked controllers" },
{ "TrackedDeviceClass_HMD.ToolTip", "the ID was not valid." },
{ "TrackedDeviceClass_Invalid.ToolTip", "#TODO: Keep up to date\nenum ETrackedDeviceClass - copied from valves enum" },
{ "TrackedDeviceClass_TrackingReference.ToolTip", "Generic trackers, similar to controllers" },
};
#endif
static const UE4CodeGen_Private::FEnumParams EnumParams = {
(UObject*(*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
"EBPOpenVRTrackedDeviceClass",
"EBPOpenVRTrackedDeviceClass",
Enumerators,
ARRAY_COUNT(Enumerators),
RF_Public|RF_Transient|RF_MarkAsNative,
UE4CodeGen_Private::EDynamicType::NotDynamic,
(uint8)UEnum::ECppForm::EnumClass,
METADATA_PARAMS(Enum_MetaDataParams, ARRAY_COUNT(Enum_MetaDataParams))
};
UE4CodeGen_Private::ConstructUEnum(ReturnEnum, EnumParams);
}
return ReturnEnum;
}
class UScriptStruct* FBPOpenVRCameraHandle::StaticStruct()
{
static class UScriptStruct* Singleton = NULL;
if (!Singleton)
{
extern OPENVREXPANSIONPLUGIN_API uint32 Get_Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Hash();
Singleton = GetStaticStruct(Z_Construct_UScriptStruct_FBPOpenVRCameraHandle, Z_Construct_UPackage__Script_OpenVRExpansionPlugin(), TEXT("BPOpenVRCameraHandle"), sizeof(FBPOpenVRCameraHandle), Get_Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Hash());
}
return Singleton;
}
template<> OPENVREXPANSIONPLUGIN_API UScriptStruct* StaticStruct<FBPOpenVRCameraHandle>()
{
return FBPOpenVRCameraHandle::StaticStruct();
}
static FCompiledInDeferStruct Z_CompiledInDeferStruct_UScriptStruct_FBPOpenVRCameraHandle(FBPOpenVRCameraHandle::StaticStruct, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("BPOpenVRCameraHandle"), false, nullptr, nullptr);
static struct FScriptStruct_OpenVRExpansionPlugin_StaticRegisterNativesFBPOpenVRCameraHandle
{
FScriptStruct_OpenVRExpansionPlugin_StaticRegisterNativesFBPOpenVRCameraHandle()
{
UScriptStruct::DeferCppStructOps(FName(TEXT("BPOpenVRCameraHandle")),new UScriptStruct::TCppStructOps<FBPOpenVRCameraHandle>);
}
} ScriptStruct_OpenVRExpansionPlugin_StaticRegisterNativesFBPOpenVRCameraHandle;
struct Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Struct_MetaDataParams[];
#endif
static void* NewStructOps();
static const UE4CodeGen_Private::FStructParams ReturnStructParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Statics::Struct_MetaDataParams[] = {
{ "BlueprintType", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|VRCamera" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
};
#endif
void* Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Statics::NewStructOps()
{
return (UScriptStruct::ICppStructOps*)new UScriptStruct::TCppStructOps<FBPOpenVRCameraHandle>();
}
const UE4CodeGen_Private::FStructParams Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Statics::ReturnStructParams = {
(UObject* (*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
nullptr,
&NewStructOps,
"BPOpenVRCameraHandle",
sizeof(FBPOpenVRCameraHandle),
alignof(FBPOpenVRCameraHandle),
nullptr,
0,
RF_Public|RF_Transient|RF_MarkAsNative,
EStructFlags(0x00000201),
METADATA_PARAMS(Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Statics::Struct_MetaDataParams, ARRAY_COUNT(Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Statics::Struct_MetaDataParams))
};
UScriptStruct* Z_Construct_UScriptStruct_FBPOpenVRCameraHandle()
{
#if WITH_HOT_RELOAD
extern uint32 Get_Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Hash();
UPackage* Outer = Z_Construct_UPackage__Script_OpenVRExpansionPlugin();
static UScriptStruct* ReturnStruct = FindExistingStructIfHotReloadOrDynamic(Outer, TEXT("BPOpenVRCameraHandle"), sizeof(FBPOpenVRCameraHandle), Get_Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Hash(), false);
#else
static UScriptStruct* ReturnStruct = nullptr;
#endif
if (!ReturnStruct)
{
UE4CodeGen_Private::ConstructUScriptStruct(ReturnStruct, Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Statics::ReturnStructParams);
}
return ReturnStruct;
}
uint32 Get_Z_Construct_UScriptStruct_FBPOpenVRCameraHandle_Hash() { return 2007320786U; }
void UOpenVRExpansionFunctionLibrary::StaticRegisterNativesUOpenVRExpansionFunctionLibrary()
{
UClass* Class = UOpenVRExpansionFunctionLibrary::StaticClass();
static const FNameNativePtrPair Funcs[] = {
{ "AcquireVRCamera", &UOpenVRExpansionFunctionLibrary::execAcquireVRCamera },
{ "ClearSkyboxOverride", &UOpenVRExpansionFunctionLibrary::execClearSkyboxOverride },
{ "CreateCameraTexture2D", &UOpenVRExpansionFunctionLibrary::execCreateCameraTexture2D },
{ "FadeHMDToColor", &UOpenVRExpansionFunctionLibrary::execFadeHMDToColor },
{ "FadeVRGrid", &UOpenVRExpansionFunctionLibrary::execFadeVRGrid },
{ "GetCurrentHMDFadeColor", &UOpenVRExpansionFunctionLibrary::execGetCurrentHMDFadeColor },
{ "GetCurrentVRGripAlpha", &UOpenVRExpansionFunctionLibrary::execGetCurrentVRGripAlpha },
{ "GetOpenVRDevices", &UOpenVRExpansionFunctionLibrary::execGetOpenVRDevices },
{ "GetOpenVRDevicesByType", &UOpenVRExpansionFunctionLibrary::execGetOpenVRDevicesByType },
{ "GetOpenVRDeviceType", &UOpenVRExpansionFunctionLibrary::execGetOpenVRDeviceType },
{ "GetOpenVRHMDType", &UOpenVRExpansionFunctionLibrary::execGetOpenVRHMDType },
{ "GetVRCameraFrame", &UOpenVRExpansionFunctionLibrary::execGetVRCameraFrame },
{ "GetVRDeviceModelAndTexture", &UOpenVRExpansionFunctionLibrary::execGetVRDeviceModelAndTexture },
{ "GetVRDevicePropertyBool", &UOpenVRExpansionFunctionLibrary::execGetVRDevicePropertyBool },
{ "GetVRDevicePropertyFloat", &UOpenVRExpansionFunctionLibrary::execGetVRDevicePropertyFloat },
{ "GetVRDevicePropertyInt32", &UOpenVRExpansionFunctionLibrary::execGetVRDevicePropertyInt32 },
{ "GetVRDevicePropertyMatrix34AsTransform", &UOpenVRExpansionFunctionLibrary::execGetVRDevicePropertyMatrix34AsTransform },
{ "GetVRDevicePropertyString", &UOpenVRExpansionFunctionLibrary::execGetVRDevicePropertyString },
{ "GetVRDevicePropertyUInt64", &UOpenVRExpansionFunctionLibrary::execGetVRDevicePropertyUInt64 },
{ "HasVRCamera", &UOpenVRExpansionFunctionLibrary::execHasVRCamera },
{ "IsOpenVRDeviceConnected", &UOpenVRExpansionFunctionLibrary::execIsOpenVRDeviceConnected },
{ "IsValid", &UOpenVRExpansionFunctionLibrary::execIsValid },
{ "ReleaseVRCamera", &UOpenVRExpansionFunctionLibrary::execReleaseVRCamera },
{ "SetSkyboxOverride", &UOpenVRExpansionFunctionLibrary::execSetSkyboxOverride },
{ "SetSkyboxOverride_LatLong", &UOpenVRExpansionFunctionLibrary::execSetSkyboxOverride_LatLong },
{ "SetSkyboxOverride_LatLongStereoPair", &UOpenVRExpansionFunctionLibrary::execSetSkyboxOverride_LatLongStereoPair },
{ "SetSuspendRendering", &UOpenVRExpansionFunctionLibrary::execSetSuspendRendering },
};
FNativeFunctionRegistrar::RegisterFunctions(Class, Funcs, ARRAY_COUNT(Funcs));
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics
{
struct OpenVRExpansionFunctionLibrary_eventAcquireVRCamera_Parms
{
FBPOpenVRCameraHandle CameraHandle;
EBPOVRResultSwitch Result;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_CameraHandle;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventAcquireVRCamera_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::NewProp_CameraHandle = { "CameraHandle", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventAcquireVRCamera_Parms, CameraHandle), Z_Construct_UScriptStruct_FBPOpenVRCameraHandle, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::NewProp_CameraHandle,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|VRCamera" },
{ "DisplayName", "AcquireVRCamera" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Acquire the vr camera for access (wakes it up) and returns a handle to use for functions regarding it (MUST RELEASE CAMERA WHEN DONE)" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "AcquireVRCamera", sizeof(OpenVRExpansionFunctionLibrary_eventAcquireVRCamera_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics
{
struct OpenVRExpansionFunctionLibrary_eventClearSkyboxOverride_Parms
{
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventClearSkyboxOverride_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventClearSkyboxOverride_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|Compositor" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Remove skybox override in steamVR" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "ClearSkyboxOverride", sizeof(OpenVRExpansionFunctionLibrary_eventClearSkyboxOverride_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics
{
struct OpenVRExpansionFunctionLibrary_eventCreateCameraTexture2D_Parms
{
FBPOpenVRCameraHandle CameraHandle;
EOpenVRCameraFrameType FrameType;
EBPOVRResultSwitch Result;
UTexture2D* ReturnValue;
};
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FrameType;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_FrameType_Underlying;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_CameraHandle;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventCreateCameraTexture2D_Parms, ReturnValue), Z_Construct_UClass_UTexture2D_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventCreateCameraTexture2D_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_FrameType = { "FrameType", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventCreateCameraTexture2D_Parms, FrameType), Z_Construct_UEnum_OpenVRExpansionPlugin_EOpenVRCameraFrameType, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_FrameType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_CameraHandle = { "CameraHandle", nullptr, (EPropertyFlags)0x0010000008000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventCreateCameraTexture2D_Parms, CameraHandle), Z_Construct_UScriptStruct_FBPOpenVRCameraHandle, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_FrameType,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_FrameType_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::NewProp_CameraHandle,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|VRCamera" },
{ "DisplayName", "CreateCameraTexture2D" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Create Camera Render Target, automatically pulls the correct texture size and format" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "CreateCameraTexture2D", sizeof(OpenVRExpansionFunctionLibrary_eventCreateCameraTexture2D_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics
{
struct OpenVRExpansionFunctionLibrary_eventFadeHMDToColor_Parms
{
float fSeconds;
FColor Color;
bool bBackground;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static void NewProp_bBackground_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bBackground;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_Color;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_fSeconds;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventFadeHMDToColor_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventFadeHMDToColor_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_bBackground_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventFadeHMDToColor_Parms*)Obj)->bBackground = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_bBackground = { "bBackground", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventFadeHMDToColor_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_bBackground_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_Color = { "Color", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventFadeHMDToColor_Parms, Color), Z_Construct_UScriptStruct_FColor, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_fSeconds = { "fSeconds", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventFadeHMDToColor_Parms, fSeconds), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_bBackground,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_Color,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::NewProp_fSeconds,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|Compositor" },
{ "CPP_Default_bBackground", "false" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between\n0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly\nwould be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ). Values are in un-premultiplied alpha space." },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "FadeHMDToColor", sizeof(OpenVRExpansionFunctionLibrary_eventFadeHMDToColor_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04822401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics
{
struct OpenVRExpansionFunctionLibrary_eventFadeVRGrid_Parms
{
float fSeconds;
bool bFadeIn;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static void NewProp_bFadeIn_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bFadeIn;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_fSeconds;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventFadeVRGrid_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventFadeVRGrid_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_bFadeIn_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventFadeVRGrid_Parms*)Obj)->bFadeIn = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_bFadeIn = { "bFadeIn", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventFadeVRGrid_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_bFadeIn_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_fSeconds = { "fSeconds", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventFadeVRGrid_Parms, fSeconds), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_bFadeIn,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::NewProp_fSeconds,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|Compositor" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Fading the Grid in or out in fSeconds" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "FadeVRGrid", sizeof(OpenVRExpansionFunctionLibrary_eventFadeVRGrid_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetCurrentHMDFadeColor_Parms
{
FColor ColorOut;
bool bBackground;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static void NewProp_bBackground_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bBackground;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_ColorOut;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventGetCurrentHMDFadeColor_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventGetCurrentHMDFadeColor_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_bBackground_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventGetCurrentHMDFadeColor_Parms*)Obj)->bBackground = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_bBackground = { "bBackground", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventGetCurrentHMDFadeColor_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_bBackground_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_ColorOut = { "ColorOut", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetCurrentHMDFadeColor_Parms, ColorOut), Z_Construct_UScriptStruct_FColor, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_bBackground,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::NewProp_ColorOut,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|Compositor" },
{ "CPP_Default_bBackground", "false" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Get current fade color value." },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetCurrentHMDFadeColor", sizeof(OpenVRExpansionFunctionLibrary_eventGetCurrentHMDFadeColor_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetCurrentVRGripAlpha_Parms
{
float VRGridAlpha;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_VRGridAlpha;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventGetCurrentVRGripAlpha_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventGetCurrentVRGripAlpha_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::NewProp_VRGridAlpha = { "VRGridAlpha", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetCurrentVRGripAlpha_Parms, VRGridAlpha), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::NewProp_VRGridAlpha,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|Compositor" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Get current alpha value of grid." },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetCurrentVRGripAlpha", sizeof(OpenVRExpansionFunctionLibrary_eventGetCurrentVRGripAlpha_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetOpenVRDevices_Parms
{
TArray<EBPOpenVRTrackedDeviceClass> FoundDevices;
};
static const UE4CodeGen_Private::FArrayPropertyParams NewProp_FoundDevices;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FoundDevices_Inner;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_FoundDevices_Inner_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::NewProp_FoundDevices = { "FoundDevices", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetOpenVRDevices_Parms, FoundDevices), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::NewProp_FoundDevices_Inner = { "FoundDevices", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRTrackedDeviceClass, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::NewProp_FoundDevices_Inner_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::NewProp_FoundDevices,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::NewProp_FoundDevices_Inner,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::NewProp_FoundDevices_Inner_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Get a list of all currently tracked devices and their types, index in the array is their device index" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetOpenVRDevices", sizeof(OpenVRExpansionFunctionLibrary_eventGetOpenVRDevices_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetOpenVRDevicesByType_Parms
{
EBPOpenVRTrackedDeviceClass TypeToRetreive;
TArray<int32> FoundIndexs;
};
static const UE4CodeGen_Private::FArrayPropertyParams NewProp_FoundIndexs;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_FoundIndexs_Inner;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_TypeToRetreive;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_TypeToRetreive_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::NewProp_FoundIndexs = { "FoundIndexs", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetOpenVRDevicesByType_Parms, FoundIndexs), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::NewProp_FoundIndexs_Inner = { "FoundIndexs", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::NewProp_TypeToRetreive = { "TypeToRetreive", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetOpenVRDevicesByType_Parms, TypeToRetreive), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRTrackedDeviceClass, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::NewProp_TypeToRetreive_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::NewProp_FoundIndexs,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::NewProp_FoundIndexs_Inner,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::NewProp_TypeToRetreive,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::NewProp_TypeToRetreive_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Get a list of all currently tracked devices of a specific type" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetOpenVRDevicesByType", sizeof(OpenVRExpansionFunctionLibrary_eventGetOpenVRDevicesByType_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetOpenVRDeviceType_Parms
{
int32 DeviceIndex;
EBPOpenVRTrackedDeviceClass ReturnValue;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_DeviceIndex;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetOpenVRDeviceType_Parms, ReturnValue), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRTrackedDeviceClass, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::NewProp_DeviceIndex = { "DeviceIndex", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetOpenVRDeviceType_Parms, DeviceIndex), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::NewProp_ReturnValue_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::NewProp_DeviceIndex,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Get what type a specific openVR device index is" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetOpenVRDeviceType", sizeof(OpenVRExpansionFunctionLibrary_eventGetOpenVRDeviceType_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetOpenVRHMDType_Parms
{
EBPOpenVRHMDDeviceType ReturnValue;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetOpenVRHMDType_Parms, ReturnValue), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRHMDDeviceType, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::NewProp_ReturnValue_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "DisplayName", "GetOpenVRHMDType" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Gets whether an HMD device is connected, this is an expanded version for SteamVR" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetOpenVRHMDType", sizeof(OpenVRExpansionFunctionLibrary_eventGetOpenVRHMDType_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetVRCameraFrame_Parms
{
FBPOpenVRCameraHandle CameraHandle;
EOpenVRCameraFrameType FrameType;
EBPOVRResultSwitch Result;
UTexture2D* TargetRenderTarget;
};
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_TargetRenderTarget;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FrameType;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_FrameType_Underlying;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_CameraHandle;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_TargetRenderTarget = { "TargetRenderTarget", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRCameraFrame_Parms, TargetRenderTarget), Z_Construct_UClass_UTexture2D_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRCameraFrame_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_FrameType = { "FrameType", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRCameraFrame_Parms, FrameType), Z_Construct_UEnum_OpenVRExpansionPlugin_EOpenVRCameraFrameType, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_FrameType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_CameraHandle = { "CameraHandle", nullptr, (EPropertyFlags)0x0010000008000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRCameraFrame_Parms, CameraHandle), Z_Construct_UScriptStruct_FBPOpenVRCameraHandle, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_TargetRenderTarget,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_FrameType,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_FrameType_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::NewProp_CameraHandle,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|VRCamera" },
{ "CPP_Default_TargetRenderTarget", "None" },
{ "DisplayName", "GetVRCameraFrame" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Gets a screen cap from the HMD camera if there is one" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetVRCameraFrame", sizeof(OpenVRExpansionFunctionLibrary_eventGetVRCameraFrame_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms
{
UObject* WorldContextObject;
EBPOpenVRTrackedDeviceClass DeviceType;
TArray<UProceduralMeshComponent*> ProceduralMeshComponentsToFill;
bool bCreateCollision;
EAsyncBlueprintResultSwitch Result;
int32 OverrideDeviceID;
UTexture2D* ReturnValue;
};
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_OverrideDeviceID;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static void NewProp_bCreateCollision_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bCreateCollision;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ProceduralMeshComponentsToFill_MetaData[];
#endif
static const UE4CodeGen_Private::FArrayPropertyParams NewProp_ProceduralMeshComponentsToFill;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_ProceduralMeshComponentsToFill_Inner;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_DeviceType;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_DeviceType_Underlying;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_WorldContextObject;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms, ReturnValue), Z_Construct_UClass_UTexture2D_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_OverrideDeviceID = { "OverrideDeviceID", nullptr, (EPropertyFlags)0x0010040000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms, OverrideDeviceID), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EAsyncBlueprintResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_bCreateCollision_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms*)Obj)->bCreateCollision = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_bCreateCollision = { "bCreateCollision", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_bCreateCollision_SetBit, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_ProceduralMeshComponentsToFill_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_ProceduralMeshComponentsToFill = { "ProceduralMeshComponentsToFill", nullptr, (EPropertyFlags)0x0010008000000080, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms, ProceduralMeshComponentsToFill), METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_ProceduralMeshComponentsToFill_MetaData, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_ProceduralMeshComponentsToFill_MetaData)) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_ProceduralMeshComponentsToFill_Inner = { "ProceduralMeshComponentsToFill", nullptr, (EPropertyFlags)0x0000000000080000, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_UProceduralMeshComponent_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_DeviceType = { "DeviceType", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms, DeviceType), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOpenVRTrackedDeviceClass, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_DeviceType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_WorldContextObject = { "WorldContextObject", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms, WorldContextObject), Z_Construct_UClass_UObject_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_OverrideDeviceID,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_bCreateCollision,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_ProceduralMeshComponentsToFill,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_ProceduralMeshComponentsToFill_Inner,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_DeviceType,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_DeviceType_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::NewProp_WorldContextObject,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::Function_MetaDataParams[] = {
{ "AdvancedDisplay", "OverrideDeviceID" },
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "CPP_Default_OverrideDeviceID", "-1" },
{ "DisplayName", "GetVRDeviceModelAndTexture" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Gets the model / texture of a SteamVR Device, can use to fill procedural mesh components or just get the texture of them to apply to a pre-made model." },
{ "WorldContext", "WorldContextObject" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetVRDeviceModelAndTexture", sizeof(OpenVRExpansionFunctionLibrary_eventGetVRDeviceModelAndTexture_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyBool_Parms
{
EVRDeviceProperty_Bool PropertyToRetrieve;
int32 DeviceID;
bool BoolValue;
EBPOVRResultSwitch Result;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static void NewProp_BoolValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_BoolValue;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_DeviceID;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_PropertyToRetrieve;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_PropertyToRetrieve_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyBool_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_BoolValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyBool_Parms*)Obj)->BoolValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_BoolValue = { "BoolValue", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyBool_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_BoolValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_DeviceID = { "DeviceID", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyBool_Parms, DeviceID), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_PropertyToRetrieve = { "PropertyToRetrieve", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyBool_Parms, PropertyToRetrieve), Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Bool, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_PropertyToRetrieve_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_BoolValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_DeviceID,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_PropertyToRetrieve,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::NewProp_PropertyToRetrieve_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "DisplayName", "GetVRDevicePropertyBool" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Gets a Bool device property" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetVRDevicePropertyBool", sizeof(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyBool_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyFloat_Parms
{
EVRDeviceProperty_Float PropertyToRetrieve;
int32 DeviceID;
float FloatValue;
EBPOVRResultSwitch Result;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_FloatValue;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_DeviceID;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_PropertyToRetrieve;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_PropertyToRetrieve_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyFloat_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_FloatValue = { "FloatValue", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyFloat_Parms, FloatValue), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_DeviceID = { "DeviceID", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyFloat_Parms, DeviceID), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_PropertyToRetrieve = { "PropertyToRetrieve", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyFloat_Parms, PropertyToRetrieve), Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Float, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_PropertyToRetrieve_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_FloatValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_DeviceID,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_PropertyToRetrieve,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::NewProp_PropertyToRetrieve_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "DisplayName", "GetVRDevicePropertyFloat" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Gets a Float device property" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetVRDevicePropertyFloat", sizeof(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyFloat_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyInt32_Parms
{
EVRDeviceProperty_Int32 PropertyToRetrieve;
int32 DeviceID;
int32 IntValue;
EBPOVRResultSwitch Result;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_IntValue;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_DeviceID;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_PropertyToRetrieve;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_PropertyToRetrieve_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyInt32_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_IntValue = { "IntValue", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyInt32_Parms, IntValue), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_DeviceID = { "DeviceID", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyInt32_Parms, DeviceID), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_PropertyToRetrieve = { "PropertyToRetrieve", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyInt32_Parms, PropertyToRetrieve), Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Int32, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_PropertyToRetrieve_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_IntValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_DeviceID,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_PropertyToRetrieve,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::NewProp_PropertyToRetrieve_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "DisplayName", "GetVRDevicePropertyInt32" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Gets a Int32 device property" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetVRDevicePropertyInt32", sizeof(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyInt32_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyMatrix34AsTransform_Parms
{
EVRDeviceProperty_Matrix34 PropertyToRetrieve;
int32 DeviceID;
FTransform TransformValue;
EBPOVRResultSwitch Result;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_TransformValue;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_DeviceID;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_PropertyToRetrieve;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_PropertyToRetrieve_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyMatrix34AsTransform_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_TransformValue = { "TransformValue", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyMatrix34AsTransform_Parms, TransformValue), Z_Construct_UScriptStruct_FTransform, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_DeviceID = { "DeviceID", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyMatrix34AsTransform_Parms, DeviceID), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_PropertyToRetrieve = { "PropertyToRetrieve", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyMatrix34AsTransform_Parms, PropertyToRetrieve), Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_Matrix34, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_PropertyToRetrieve_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_TransformValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_DeviceID,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_PropertyToRetrieve,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::NewProp_PropertyToRetrieve_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "DisplayName", "GetVRDevicePropertyMatrix34AsTransform" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Gets a Matrix34 device property as a Transform" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetVRDevicePropertyMatrix34AsTransform", sizeof(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyMatrix34AsTransform_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04C22401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyString_Parms
{
EVRDeviceProperty_String PropertyToRetrieve;
int32 DeviceID;
FString StringValue;
EBPOVRResultSwitch Result;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static const UE4CodeGen_Private::FStrPropertyParams NewProp_StringValue;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_DeviceID;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_PropertyToRetrieve;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_PropertyToRetrieve_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyString_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_StringValue = { "StringValue", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyString_Parms, StringValue), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_DeviceID = { "DeviceID", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyString_Parms, DeviceID), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_PropertyToRetrieve = { "PropertyToRetrieve", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyString_Parms, PropertyToRetrieve), Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_String, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_PropertyToRetrieve_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_StringValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_DeviceID,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_PropertyToRetrieve,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::NewProp_PropertyToRetrieve_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "DisplayName", "GetVRDevicePropertyString" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Gets a String device property" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetVRDevicePropertyString", sizeof(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyString_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics
{
struct OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyUInt64_Parms
{
EVRDeviceProperty_UInt64 PropertyToRetrieve;
int32 DeviceID;
FString UInt64Value;
EBPOVRResultSwitch Result;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static const UE4CodeGen_Private::FStrPropertyParams NewProp_UInt64Value;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_DeviceID;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_PropertyToRetrieve;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_PropertyToRetrieve_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyUInt64_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStrPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_UInt64Value = { "UInt64Value", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Str, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyUInt64_Parms, UInt64Value), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_DeviceID = { "DeviceID", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyUInt64_Parms, DeviceID), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_PropertyToRetrieve = { "PropertyToRetrieve", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyUInt64_Parms, PropertyToRetrieve), Z_Construct_UEnum_OpenVRExpansionPlugin_EVRDeviceProperty_UInt64, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_PropertyToRetrieve_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_UInt64Value,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_DeviceID,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_PropertyToRetrieve,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::NewProp_PropertyToRetrieve_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "DisplayName", "GetVRDevicePropertyUInt64" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Gets a UInt64 device property as a string (Blueprints do not support int64)" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "GetVRDevicePropertyUInt64", sizeof(OpenVRExpansionFunctionLibrary_eventGetVRDevicePropertyUInt64_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics
{
struct OpenVRExpansionFunctionLibrary_eventHasVRCamera_Parms
{
EOpenVRCameraFrameType FrameType;
int32 Width;
int32 Height;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_Height;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_Width;
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_FrameType;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_FrameType_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventHasVRCamera_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventHasVRCamera_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_Height = { "Height", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventHasVRCamera_Parms, Height), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_Width = { "Width", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventHasVRCamera_Parms, Width), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_FrameType = { "FrameType", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventHasVRCamera_Parms, FrameType), Z_Construct_UEnum_OpenVRExpansionPlugin_EOpenVRCameraFrameType, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_FrameType_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_Height,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_Width,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_FrameType,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::NewProp_FrameType_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|VRCamera" },
{ "DisplayName", "HasVRCamera" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Returns if there is a VR camera and what its pixel height / width is" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "HasVRCamera", sizeof(OpenVRExpansionFunctionLibrary_eventHasVRCamera_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics
{
struct OpenVRExpansionFunctionLibrary_eventIsOpenVRDeviceConnected_Parms
{
int32 DeviceIndex;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FIntPropertyParams NewProp_DeviceIndex;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventIsOpenVRDeviceConnected_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventIsOpenVRDeviceConnected_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FIntPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::NewProp_DeviceIndex = { "DeviceIndex", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Int, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventIsOpenVRDeviceConnected_Parms, DeviceIndex), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::NewProp_DeviceIndex,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Checks if a specific OpenVR device is connected, index names are assumed, they may not be exact" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "IsOpenVRDeviceConnected", sizeof(OpenVRExpansionFunctionLibrary_eventIsOpenVRDeviceConnected_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x14022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics
{
struct OpenVRExpansionFunctionLibrary_eventIsValid_Parms
{
FBPOpenVRCameraHandle CameraHandle;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_CameraHandle;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventIsValid_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventIsValid_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::NewProp_CameraHandle = { "CameraHandle", nullptr, (EPropertyFlags)0x0010000008000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventIsValid_Parms, CameraHandle), Z_Construct_UScriptStruct_FBPOpenVRCameraHandle, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::NewProp_CameraHandle,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|VRCamera" },
{ "DisplayName", "IsValid" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Checks if a camera handle is valid" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "IsValid", sizeof(OpenVRExpansionFunctionLibrary_eventIsValid_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics
{
struct OpenVRExpansionFunctionLibrary_eventReleaseVRCamera_Parms
{
FBPOpenVRCameraHandle CameraHandle;
EBPOVRResultSwitch Result;
};
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_Result;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_Result_Underlying;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_CameraHandle;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::NewProp_Result = { "Result", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventReleaseVRCamera_Parms, Result), Z_Construct_UEnum_OpenVRExpansionPlugin_EBPOVRResultSwitch, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::NewProp_Result_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::NewProp_CameraHandle = { "CameraHandle", nullptr, (EPropertyFlags)0x0010000008000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventReleaseVRCamera_Parms, CameraHandle), Z_Construct_UScriptStruct_FBPOpenVRCameraHandle, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::NewProp_Result,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::NewProp_Result_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::NewProp_CameraHandle,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|VRCamera" },
{ "DisplayName", "ReleaseVRCamera" },
{ "ExpandEnumAsExecs", "Result" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Releases the vr camera from access - you MUST call this when done with the camera" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "ReleaseVRCamera", sizeof(OpenVRExpansionFunctionLibrary_eventReleaseVRCamera_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04422401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics
{
struct OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms
{
UTexture* tFront;
UTexture2D* tBack;
UTexture* tLeft;
UTexture* tRight;
UTexture* tTop;
UTexture* tBottom;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_tBottom;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_tTop;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_tRight;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_tLeft;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_tBack;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_tFront;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tBottom = { "tBottom", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms, tBottom), Z_Construct_UClass_UTexture_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tTop = { "tTop", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms, tTop), Z_Construct_UClass_UTexture_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tRight = { "tRight", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms, tRight), Z_Construct_UClass_UTexture_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tLeft = { "tLeft", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms, tLeft), Z_Construct_UClass_UTexture_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tBack = { "tBack", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms, tBack), Z_Construct_UClass_UTexture2D_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tFront = { "tFront", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms, tFront), Z_Construct_UClass_UTexture_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tBottom,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tTop,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tRight,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tLeft,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tBack,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::NewProp_tFront,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|Compositor" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Override the standard skybox texture in steamVR - 6 cardinal textures - need to call ClearSkyboxOverride when finished" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "SetSkyboxOverride", sizeof(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics
{
struct OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLong_Parms
{
UTexture2D* LatLongSkybox;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_LatLongSkybox;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLong_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLong_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::NewProp_LatLongSkybox = { "LatLongSkybox", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLong_Parms, LatLongSkybox), Z_Construct_UClass_UTexture2D_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::NewProp_LatLongSkybox,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|Compositor" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Override the standard skybox texture in steamVR - LatLong format - need to call ClearSkyboxOverride when finished" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "SetSkyboxOverride_LatLong", sizeof(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLong_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics
{
struct OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLongStereoPair_Parms
{
UTexture2D* LatLongSkyboxL;
UTexture2D* LatLongSkyboxR;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_LatLongSkyboxR;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_LatLongSkyboxL;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLongStereoPair_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLongStereoPair_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::NewProp_LatLongSkyboxR = { "LatLongSkyboxR", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLongStereoPair_Parms, LatLongSkyboxR), Z_Construct_UClass_UTexture2D_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::NewProp_LatLongSkyboxL = { "LatLongSkyboxL", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLongStereoPair_Parms, LatLongSkyboxL), Z_Construct_UClass_UTexture2D_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::NewProp_LatLongSkyboxR,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::NewProp_LatLongSkyboxL,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|Compositor" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Override the standard skybox texture in steamVR - LatLong stereo pair - need to call ClearSkyboxOverride when finished" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "SetSkyboxOverride_LatLongStereoPair", sizeof(OpenVRExpansionFunctionLibrary_eventSetSkyboxOverride_LatLongStereoPair_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics
{
struct OpenVRExpansionFunctionLibrary_eventSetSuspendRendering_Parms
{
bool bSuspendRendering;
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static void NewProp_bSuspendRendering_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bSuspendRendering;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventSetSuspendRendering_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventSetSuspendRendering_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::NewProp_bSuspendRendering_SetBit(void* Obj)
{
((OpenVRExpansionFunctionLibrary_eventSetSuspendRendering_Parms*)Obj)->bSuspendRendering = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::NewProp_bSuspendRendering = { "bSuspendRendering", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(OpenVRExpansionFunctionLibrary_eventSetSuspendRendering_Parms), &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::NewProp_bSuspendRendering_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::NewProp_bSuspendRendering,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::Function_MetaDataParams[] = {
{ "bIgnoreSelf", "true" },
{ "Category", "VRExpansionFunctions|SteamVR|Compositor" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ToolTip", "Sets whether the compositor is allows to render or not (reverts to base compositor / grid when active)\nUseful to place players out of the app during frame drops/hitches/loading and into the vr skybox." },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, nullptr, "SetSuspendRendering", sizeof(OpenVRExpansionFunctionLibrary_eventSetSuspendRendering_Parms), Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04022401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering_Statics::FuncParams);
}
return ReturnFunction;
}
UClass* Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_NoRegister()
{
return UOpenVRExpansionFunctionLibrary::StaticClass();
}
struct Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_Statics
{
static UObject* (*const DependentSingletons[])();
static const FClassFunctionLinkInfo FuncInfo[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
static const UE4CodeGen_Private::FClassParams ClassParams;
};
UObject* (*const Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_Statics::DependentSingletons[])() = {
(UObject* (*)())Z_Construct_UClass_UBlueprintFunctionLibrary,
(UObject* (*)())Z_Construct_UPackage__Script_OpenVRExpansionPlugin,
};
const FClassFunctionLinkInfo Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_Statics::FuncInfo[] = {
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_AcquireVRCamera, "AcquireVRCamera" }, // 2550055195
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ClearSkyboxOverride, "ClearSkyboxOverride" }, // 3136025840
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_CreateCameraTexture2D, "CreateCameraTexture2D" }, // 1345095853
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeHMDToColor, "FadeHMDToColor" }, // 3738367235
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_FadeVRGrid, "FadeVRGrid" }, // 3486600560
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentHMDFadeColor, "GetCurrentHMDFadeColor" }, // 2626401475
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetCurrentVRGripAlpha, "GetCurrentVRGripAlpha" }, // 1527880891
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevices, "GetOpenVRDevices" }, // 1600844644
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDevicesByType, "GetOpenVRDevicesByType" }, // 3482634701
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRDeviceType, "GetOpenVRDeviceType" }, // 290236205
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetOpenVRHMDType, "GetOpenVRHMDType" }, // 2365987785
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRCameraFrame, "GetVRCameraFrame" }, // 117016343
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDeviceModelAndTexture, "GetVRDeviceModelAndTexture" }, // 3995435682
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyBool, "GetVRDevicePropertyBool" }, // 1474440115
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyFloat, "GetVRDevicePropertyFloat" }, // 1957082431
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyInt32, "GetVRDevicePropertyInt32" }, // 151282464
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyMatrix34AsTransform, "GetVRDevicePropertyMatrix34AsTransform" }, // 476893524
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyString, "GetVRDevicePropertyString" }, // 642792591
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_GetVRDevicePropertyUInt64, "GetVRDevicePropertyUInt64" }, // 3706368189
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_HasVRCamera, "HasVRCamera" }, // 2665266278
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsOpenVRDeviceConnected, "IsOpenVRDeviceConnected" }, // 2300796337
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_IsValid, "IsValid" }, // 576394150
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_ReleaseVRCamera, "ReleaseVRCamera" }, // 1921041751
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride, "SetSkyboxOverride" }, // 10114914
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLong, "SetSkyboxOverride_LatLong" }, // 1411129009
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSkyboxOverride_LatLongStereoPair, "SetSkyboxOverride_LatLongStereoPair" }, // 3996695562
{ &Z_Construct_UFunction_UOpenVRExpansionFunctionLibrary_SetSuspendRendering, "SetSuspendRendering" }, // 3952588483
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_Statics::Class_MetaDataParams[] = {
{ "BlueprintSpawnableComponent", "" },
{ "BlueprintType", "true" },
{ "IncludePath", "OpenVRExpansionFunctionLibrary.h" },
{ "IsBlueprintBase", "true" },
{ "ModuleRelativePath", "Public/OpenVRExpansionFunctionLibrary.h" },
{ "ObjectInitializerConstructorDeclared", "" },
};
#endif
const FCppClassTypeInfoStatic Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_Statics::StaticCppClassTypeInfo = {
TCppClassTypeTraits<UOpenVRExpansionFunctionLibrary>::IsAbstract,
};
const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_Statics::ClassParams = {
&UOpenVRExpansionFunctionLibrary::StaticClass,
nullptr,
&StaticCppClassTypeInfo,
DependentSingletons,
FuncInfo,
nullptr,
nullptr,
ARRAY_COUNT(DependentSingletons),
ARRAY_COUNT(FuncInfo),
0,
0,
0x001000A0u,
METADATA_PARAMS(Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_Statics::Class_MetaDataParams, ARRAY_COUNT(Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_Statics::Class_MetaDataParams))
};
UClass* Z_Construct_UClass_UOpenVRExpansionFunctionLibrary()
{
static UClass* OuterClass = nullptr;
if (!OuterClass)
{
UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UOpenVRExpansionFunctionLibrary_Statics::ClassParams);
}
return OuterClass;
}
IMPLEMENT_CLASS(UOpenVRExpansionFunctionLibrary, 2528190331);
template<> OPENVREXPANSIONPLUGIN_API UClass* StaticClass<UOpenVRExpansionFunctionLibrary>()
{
return UOpenVRExpansionFunctionLibrary::StaticClass();
}
static FCompiledInDefer Z_CompiledInDefer_UClass_UOpenVRExpansionFunctionLibrary(Z_Construct_UClass_UOpenVRExpansionFunctionLibrary, &UOpenVRExpansionFunctionLibrary::StaticClass, TEXT("/Script/OpenVRExpansionPlugin"), TEXT("UOpenVRExpansionFunctionLibrary"), false, nullptr, nullptr, nullptr);
DEFINE_VTABLE_PTR_HELPER_CTOR(UOpenVRExpansionFunctionLibrary);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
| [
"kmack@manicmachinegames.com"
] | kmack@manicmachinegames.com |
8bd9927b58f013b07b76c26cb398c3a4bb3fa913 | 1d11c85de9cad856ebe2bf753b543092d8a5af60 | /HalfPyramid.cpp | e7562b11b9aa9db6b27fb3f86646443bb12efea4 | [] | no_license | IMPranshu/DSA-C- | dc08685c31e5e84d8bb0280c090d5c33d6ac3b2a | b884af1adaa35835d5d60ab87ed2aea20fd40896 | refs/heads/main | 2023-08-31T05:40:35.482213 | 2021-10-20T04:47:50 | 2021-10-20T04:47:50 | 361,435,404 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 272 | cpp | #include<iostream>
using namespace std;
int main()
{
int n;
cout<<"\nEnter number:";
cin>>n;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(j<=n-i){
cout<<" ";
}
else{
cout<<"* ";
}
}
cout<<endl;
}
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
0b2c511645896cebf176ed4552a7db3ac8cc1681 | f805770745b4f7fe60c2c938950697ce26a882dd | /ffmpeg_mpegts_pusher/ffmpeg_mpegts_pusher/ffmpeg_mpegts_pusher.cpp | d0c4aa396fbabd0a162962f55dc174ac9f6f264e | [] | no_license | diyc/ffmpeg_demo | b704c5d68e970779592ea185d79743a233b9852e | f4dad752a4c9b502f63890fe40b2ffc96432b0fb | refs/heads/master | 2022-07-31T01:31:33.553057 | 2020-05-24T12:04:57 | 2020-05-24T12:04:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 902 | cpp | #include "x_input_stream.h"
#include "x_output_stream.h"
int main()
{
xInputStream input;
xOutputStream output;
avformat_network_init();
avdevice_register_all();
//if (false == input.OpenFile("../../test_video/失眠飞行.mp4", true))
// return -1;
if (false == input.OpenScreen(true))
return -1;
if (false == output.Initialization("udp://239.0.0.1:50101"))
return -1;
if (false == output.SetParameters(input.GetStreams(), true))
return -1;
input.BlockRead(&output);
output.Destroy();
input.Destroy();
return 0;
}
//ffplay -x 1280 -y 720 -i udp://239.0.0.1:50101
//ffplay -x 1280 -y 720 -i udp://239.0.0.1:50101 -sync audio //用来播放视频
//ffplay -x 1280 -y 720 -i udp://239.0.0.1:50101 //用来播放桌面
//ffmpeg -f gdigrab -i desktop -vcodec libx264 -preset faster -f mpegts udp://239.0.0.1:50101 | [
"mushroomcode@126.com"
] | mushroomcode@126.com |
af8f76f85066bf1c6515b2903532cd75e953ae52 | 7f9435a8800b19975caa63cb5c5a7566e7866429 | /r conversii2.cpp | 845cd10baeb5fedf2527d275e516ccb193cf80b4 | [] | no_license | MihaiAntoniu/Proiect_Algoritmi | 29861ec40c2c015863de6dba27692d4ab9190c8c | 84c08c78b57b065d69a6920f076e991062ad8fe2 | refs/heads/main | 2023-05-13T21:33:22.474041 | 2021-06-10T18:30:28 | 2021-06-10T18:30:28 | 375,793,248 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 583 | cpp | //R-> B10
#include <iostream>
using namespace std;
int b10, bq=0, bl=0, r,q,l,uc;
long p=1;
int main()
{
cout<<"NR Bq=";
cin<<bq;
cout<<"Baza in care este:";
cin>>q;
cout<<"Baza in care se schimba:";
cin>>l;
//Bq-->B10
while(bq){
uc=bq%10;
bq=bq/10;
b10=b1=+uc*p;
p=p*q;
}
cout<<"NR in baza 10 este:"<<b10<<endl;
//B10-->B1
p=1; //resetare
while(b10) {
r=b10%1;
b10=b10/1;
bl=bl+r*p;
p=p*10;
}
cout<<"NR in baza "<<l<<" este: "<<bl<<endl;
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
4dad3ab368865204422dfd02d2ba5983bd4f2f8a | 767dfdcd1c08cf6232c405482821fd210143836f | /scr/MatrixGraph.cpp | 477d69b9c3513c4d9237b5bb08c5904ce67f9098 | [] | no_license | TomaszLatusek/PAMSI2 | ffd23a4ec43c0365da657f62c589811ee10c6257 | 747e8a1ccb1ecc5ce9c25f669dec62084e1b54c8 | refs/heads/main | 2023-05-01T12:43:35.422978 | 2021-05-11T09:00:50 | 2021-05-11T09:00:50 | 364,307,356 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,986 | cpp | #include "../inc/MatrixGraph.hh"
#include <iostream>
#include <algorithm>
MatrixGraph::MatrixGraph(int vertCount, int edgCount)
{
verticesCount = vertCount;
edgesCount = 0;
parent = new int[verticesCount];
matrix = new Edge **[verticesCount];
edgeList = new Edge *[edgCount];
key = new int[verticesCount];
mstSet = new bool[verticesCount];
for (int i = 0; i < verticesCount; i++)
{
matrix[i] = new Edge *[verticesCount];
for (int j = 0; j < verticesCount; j++)
{
matrix[i][j] = nullptr;
}
}
}
MatrixGraph::~MatrixGraph()
{
for (int i = 0; i < verticesCount; ++i)
{
for (int j = 0; j < this->verticesCount; ++j)
{
delete matrix[i][j];
}
delete[] matrix[i];
}
delete[] matrix;
}
void MatrixGraph::addEdge(int src, int dst, int weight)
{
if (src != dst)
{
Edge *e1 = new Edge(src, dst, weight);
matrix[src][dst] = e1;
Edge *e2 = new Edge(dst, src, weight);
matrix[dst][src] = e2;
e2 = nullptr;
edgeList[edgesCount++] = e1;
e1 = nullptr;
}
}
bool MatrixGraph::hasEdge(int src, int dst)
{
return matrix[src][dst] != nullptr;
}
void MatrixGraph::print()
{
for (int i = 0; i < verticesCount; i++)
{
for (int j = 0; j < verticesCount; j++)
{
if (matrix[i][j] == nullptr)
{
std::cout << 0 << " ";
}
else
{
std::cout << matrix[i][j]->weight << " ";
}
}
std::cout << std::endl;
}
}
int MatrixGraph::prim()
{
mst = 0;
for (int i = 0; i < verticesCount; i++)
{
key[i] = 1000;
mstSet[i] = false;
}
key[0] = 0;
parent[0] = -1;
for (int count = 0; count < verticesCount - 1; count++)
{
int u = minKey(key, mstSet);
mstSet[u] = true;
for (int v = 0; v < verticesCount; v++)
{
if (matrix[u][v] && mstSet[v] == false && matrix[u][v]->weight < key[v])
{
parent[v] = u;
key[v] = matrix[u][v]->weight;
}
}
}
for (int i = 0; i < verticesCount; i++)
{
mst += key[i];
}
return mst;
}
int MatrixGraph::kruskal()
{
mst = 0;
for (int i = 0; i < verticesCount; i++)
{
parent[i] = i;
}
std::sort(edgeList, edgeList + edgesCount, [](Edge *a, Edge *b) { return a->weight < b->weight; });
int uRep, vRep;
for (int i = 0; i < edgesCount; i++)
{
uRep = find(edgeList[i]->source);
vRep = find(edgeList[i]->destination);
if (uRep != vRep)
{
mst += edgeList[i]->weight;
union1(uRep, vRep);
}
}
return mst;
}
void MatrixGraph::sort()
{
std::sort(edgeList, edgeList + edgesCount, [](Edge *a, Edge *b) { return a->weight < b->weight; });
}
| [
"tomaszlatusek.tl@gmail.com"
] | tomaszlatusek.tl@gmail.com |
ebff05843246f976ce2cf5c8b90b3e1bc01a481d | 6fb133f8b08b7fb442a1154820ef45e8d38cd3e9 | /3038.cpp | 25ef106a2bb4674880e33ba41dc0a0c75eeaede0 | [] | no_license | SungMinCho/BOJ | 8a2bbf823d709bb41d4d1ba02f1dd135baba7bfb | 72e7ba70f9418644603b5349f6c79faaa0f07235 | refs/heads/master | 2020-04-12T11:16:57.923229 | 2018-12-25T12:21:24 | 2018-12-25T12:21:24 | 162,454,161 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 808 | cpp | #include <stdio.h>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <iostream>
#include <climits>
#include <stdlib.h>
using namespace std;
int n, N;
vector<int> ans;
vector<int> depth;
int main() {
scanf("%d", &N);
ans.resize(1);
depth.resize(1);
ans[0] = 1;
depth[0] = 0;
n = 1;
int sz = 1;
while(n < N) {
ans.resize(sz*2 + 1);
depth.resize(sz*2 + 1);
for(int i=sz-1; i>=0; i--) {
ans[i+1] = ans[i]*2;
ans[i+sz+1] = ans[i+1] + 1;
depth[i+sz+1] = depth[i+1] = depth[i]+1;
}
ans[0] = 1;
for(int i=0; i<sz; i++) {
if(depth[i+1] == n) swap(ans[i+1], ans[i+1+sz]);
}
sz = sz*2 + 1;
n += 1;
}
for(auto a : ans) printf("%d ", a);
printf("\n");
} | [
"tjdals4565@gmail.com"
] | tjdals4565@gmail.com |
369ed05f4d0884fe9309a5de12906b24d827e8a3 | d7c77018b0c5e7d1e6e24d82fa905a1ac5b0a85e | /URI - Online Judge/UOJ_1118 - (992774) Accepted.cpp | e30060dbb9c31a04223f2016bf3e34ab12579f9b | [] | no_license | muresangabriel-alexander/cplusplus-competitive | 9396cff60c6be0f5ae3d307f58e350423e336764 | 4a17656ccbea58d779bf5bd74aed5edb9c579ca6 | refs/heads/master | 2021-04-28T07:57:22.419138 | 2018-02-20T18:42:59 | 2018-02-20T18:42:59 | 122,238,407 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 983 | cpp | #include<iomanip>
#include<iostream>
using namespace std;
int main()
{
int note=0,y;
double x,s=0;
while(note<2)
{
cin>>x;
if(x<0 || x>10)
cout<<"nota invalida"<<endl;
else
{
s=s+x;
note++;
}
}
cout<<fixed<<setprecision(2)<<"media = "<<s/2<<endl;
cout<<"novo calculo (1-sim 2-nao)"<<endl;
cin>>y;
while(y)
{
while(y!=1 && y!=2)
{
cout<<"novo calculo (1-sim 2-nao)"<<endl;
cin>>y;
}
if(y==1){
s=0;note=0;
while(note<2)
{
cin>>x;
if(x<0 || x>10)
cout<<"nota invalida"<<endl;
else
{
s=s+x;
note++;
}
}
cout<<fixed<<setprecision(2)<<"media = "<<s/2<<endl;
cout<<"novo calculo (1-sim 2-nao)"<<endl;
cin>>y;}
else if(y==2) break;
}
return 0;
} | [
"muresangabriel.alexandru@gmail.com"
] | muresangabriel.alexandru@gmail.com |
f02ba3c5d5a796b92ef72031cf6d30634881f75f | 0398a803952c81bed842d243ffc626bc78ed2465 | /Backtracking/NQueens.cpp | 841bbd05fce66f6204878ad66c724a8b17acce45 | [] | no_license | mukesh148/InterviewBit_Codes | 685d6d95f766651577968e55b28cc9f927960c22 | 323ebda4c91860da7054c7914f597c6f996a552a | refs/heads/master | 2020-03-25T16:06:19.860815 | 2018-08-29T10:26:49 | 2018-08-29T10:26:49 | 143,914,754 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,239 | cpp | vector<string> solToStrings(const vector<int>& sol) {
int n = sol.size();
vector<string> sol_strings(n);
for (int i = 0; i < n; ++i) {
sol_strings[i] = string(n, '.');
sol_strings[i][sol[i]] = 'Q';
}
return sol_strings;
}
bool isAvailable(const vector<int> &solution, int i, int j) {
for (int k = 0; k < i; ++k) {
if (j == solution[k] || i + j == k + solution[k] || i - j == k - solution[k]) return false;
}
return true;
}
void solveNQueensImpl(int row, vector<int> &solution, vector<vector<string> > &solutions) {
int n = solution.size();
if (row == n) {
solutions.push_back(solToStrings(solution));
return;
}
// For each column...
for (int j = 0; j < n; ++j) {
// Skip if there is another queen in this column or diagonals
if (isAvailable(solution, row, j)) {
solution[row] = j;
solveNQueensImpl(row + 1, solution, solutions);
}
}
}
vector<vector<string> > Solution::solveNQueens(int n) {
vector<vector<string> > solutions;
vector<int> solution(n);
solveNQueensImpl(0, solution, solutions);
return solutions;
}
| [
"mukeshkhod0001@gmail.com"
] | mukeshkhod0001@gmail.com |
a1e17b93cc5df69ebff468e291e24a22c59943c4 | 81a1ffac3f9f0f0d656ff6e95bf5f2913eb93666 | /src/data.utilities/linear_interpolation.h | 536738eaf3bd1c6e0c8928660afd9d007a766c3f | [] | no_license | mccabe082/Simple-Aircraft-Simulator | 6dd0622130f588a5e797729844697e9f36f525a6 | e4f1e16d398ff3da9513cbb0b5a07715ad8b67f2 | refs/heads/master | 2022-07-03T05:45:44.553576 | 2020-05-17T22:49:01 | 2020-05-17T22:49:01 | 262,423,396 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 216 | h | #pragma once
#include "data.utilities/lookup_table_1d.h"
#include <string>
namespace DataUtilities
{
class LinearInterpolation : public LookupTable1D
{
public:
double operator()(double x) const override;
};
} | [
"david.mccabe082@gmail.com"
] | david.mccabe082@gmail.com |
5ed23640df83b379c9f2c84e49227825f1041257 | 0ccea259b422acece7d39980bc99b791d1243245 | /Cheat/SDK/license/license_manager.cpp | 6c45570b528b282bd28130cf8fb838d156b68a04 | [] | no_license | n30np14gu3/ALPHA_PROJECT | 1702e6b98aa215417b7ce529d1040f73d3afe90b | d16f649b881275815128a0f7b23cf03cd124fdb3 | refs/heads/master | 2023-01-25T03:39:20.513554 | 2020-11-25T16:33:54 | 2020-11-25T16:33:54 | 190,072,353 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,349 | cpp | #include<iostream>
#include<ctime>
#include <rapidjson/document.h>
#include "../globals/globals.h"
#include "../network/http/http_request.h"
#include "../crypto/XorStr.h"
#include "../static/modules_ids.h"
#include "license_manager.h"
#include <Windows.h>
using namespace std;
namespace license_manager
{
bool getModulesInfo()
{
string requestParams =
string(XorStr("access_token=")) + globals::access_token + "&" +
string(XorStr("game_id=")) + to_string(GAME_ID);
string postData = http_request::post(globals::server_url, string(XorStr("/api/request_modules")), globals::lib_user_agent, requestParams, true);
rapidjson::Document responcse;
responcse.Parse(postData.c_str());
ServerCodes code = static_cast<ServerCodes>(responcse[XorStr("code")].GetInt());
if (code == API_CODE_OK)
{
globals::user_modules.modules_count = responcse[XorStr("data")][XorStr("count")].GetInt();
globals::user_modules.modules_ids = new unsigned int[globals::user_modules.modules_count];
globals::user_modules.modules_end_date = new unsigned int[globals::user_modules.modules_count];
memset(globals::user_modules.modules_ids, 0, sizeof(unsigned int) * globals::user_modules.modules_count);
memset(globals::user_modules.modules_end_date, 0, sizeof(unsigned int) * globals::user_modules.modules_count);
rapidjson::Value& modules = responcse[XorStr("data")][XorStr("modules")];
globals::is_lifetime = responcse[XorStr("data")][XorStr("is_lifetime")].GetBool();
for (rapidjson::SizeType i = 0; i < modules.Size(); i++)
{
globals::user_modules.modules_ids[i] = modules[i][XorStr("id")].GetInt();
globals::user_modules.modules_end_date[i] = modules[i][XorStr("end_date")].GetInt();
}
return true;
}
return false;
}
bool checkModuleActive(LICENSE_DATA data, int moduleId)
{
#if !NDEBUG
return true;
#endif
if (globals::is_lifetime)
return true;
for (unsigned i = 0; i < data.modules_count; i++)
{
if (data.modules_ids[i] == moduleId)
{
time_t t = time(nullptr);
return t < data.modules_end_date[i];
}
}
return false;
}
bool allModulesExpired()
{
for (unsigned i = 0; i < globals::user_modules.modules_count; i++)
{
if (checkModuleActive(globals::user_modules, globals::user_modules.modules_ids[i]))
return false;
}
return true;
}
}
| [
"darknetsoft@yandex.ru"
] | darknetsoft@yandex.ru |
f1866523022f240e024852d39a2fd8cd2b4eb923 | 6d162c19c9f1dc1d03f330cad63d0dcde1df082d | /qrenderdoc/3rdparty/scintilla/src/PerLine.h | 4bf1c88fdd62753a4d6ae65d7b3eb68b42b026cc | [
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-scintilla"
] | permissive | baldurk/renderdoc | 24efbb84446a9d443bb9350013f3bfab9e9c5923 | a214ffcaf38bf5319b2b23d3d014cf3772cda3c6 | refs/heads/v1.x | 2023-08-16T21:20:43.886587 | 2023-07-28T22:34:10 | 2023-08-15T09:09:40 | 17,253,131 | 7,729 | 1,358 | MIT | 2023-09-13T09:36:53 | 2014-02-27T15:16:30 | C++ | UTF-8 | C++ | false | false | 3,339 | h | // Scintilla source code edit control
/** @file PerLine.h
** Manages data associated with each line of the document
**/
// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
// The License.txt file describes the conditions under which this software may be distributed.
#ifndef PERLINE_H
#define PERLINE_H
#ifdef SCI_NAMESPACE
namespace Scintilla {
#endif
/**
* This holds the marker identifier and the marker type to display.
* MarkerHandleNumbers are members of lists.
*/
struct MarkerHandleNumber {
int handle;
int number;
MarkerHandleNumber *next;
};
/**
* A marker handle set contains any number of MarkerHandleNumbers.
*/
class MarkerHandleSet {
MarkerHandleNumber *root;
public:
MarkerHandleSet();
~MarkerHandleSet();
int Length() const;
int MarkValue() const; ///< Bit set of marker numbers.
bool Contains(int handle) const;
bool InsertHandle(int handle, int markerNum);
void RemoveHandle(int handle);
bool RemoveNumber(int markerNum, bool all);
void CombineWith(MarkerHandleSet *other);
};
class LineMarkers : public PerLine {
SplitVector<MarkerHandleSet *> markers;
/// Handles are allocated sequentially and should never have to be reused as 32 bit ints are very big.
int handleCurrent;
public:
LineMarkers() : handleCurrent(0) {
}
virtual ~LineMarkers();
virtual void Init();
virtual void InsertLine(int line);
virtual void RemoveLine(int line);
int MarkValue(int line);
int MarkerNext(int lineStart, int mask) const;
int AddMark(int line, int marker, int lines);
void MergeMarkers(int pos);
bool DeleteMark(int line, int markerNum, bool all);
void DeleteMarkFromHandle(int markerHandle);
int LineFromHandle(int markerHandle);
};
class LineLevels : public PerLine {
SplitVector<int> levels;
public:
virtual ~LineLevels();
virtual void Init();
virtual void InsertLine(int line);
virtual void RemoveLine(int line);
void ExpandLevels(int sizeNew=-1);
void ClearLevels();
int SetLevel(int line, int level, int lines);
int GetLevel(int line) const;
};
class LineState : public PerLine {
SplitVector<int> lineStates;
public:
LineState() {
}
virtual ~LineState();
virtual void Init();
virtual void InsertLine(int line);
virtual void RemoveLine(int line);
int SetLineState(int line, int state);
int GetLineState(int line);
int GetMaxLineState() const;
};
class LineAnnotation : public PerLine {
SplitVector<char *> annotations;
public:
LineAnnotation() {
}
virtual ~LineAnnotation();
virtual void Init();
virtual void InsertLine(int line);
virtual void RemoveLine(int line);
bool MultipleStyles(int line) const;
int Style(int line) const;
const char *Text(int line) const;
const unsigned char *Styles(int line) const;
void SetText(int line, const char *text);
void ClearAll();
void SetStyle(int line, int style);
void SetStyles(int line, const unsigned char *styles);
int Length(int line) const;
int Lines(int line) const;
};
typedef std::vector<int> TabstopList;
class LineTabstops : public PerLine {
SplitVector<TabstopList *> tabstops;
public:
LineTabstops() {
}
virtual ~LineTabstops();
virtual void Init();
virtual void InsertLine(int line);
virtual void RemoveLine(int line);
bool ClearTabstops(int line);
bool AddTabstop(int line, int x);
int GetNextTabstop(int line, int x) const;
};
#ifdef SCI_NAMESPACE
}
#endif
#endif
| [
"baldurk@baldurk.org"
] | baldurk@baldurk.org |
7485d9afe0e311289d9cbf504e7200a60990642c | 2a95329d64cf96293561917ca3509299672257ec | /src/TemplateActionFactory.h | 0ddb732af110585f4b4f1009d4d6134358ea76fa | [
"MIT"
] | permissive | heltena/KYEngine | 1c58499720e044be701a609cc3ca4c5baa1550b7 | 4ccb89d0b20683feb245ffe85dd34b6ffdc42c8e | refs/heads/master | 2021-01-01T08:06:26.163234 | 2020-02-08T18:55:12 | 2020-02-08T19:16:45 | 239,187,135 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 194 | h | #pragma once
#include <tinyxml.h>
#include <string>
class Action;
class TemplateActionFactory
{
public:
virtual Action* readFromXml(const std::string& prefix, TiXmlElement* node) = 0;
}; | [
"heltena@gmail.com"
] | heltena@gmail.com |
438efc87ffaaa8225d761e8c254db989d4cec18b | 3166d0c59d27ea2f1156f0bdd1ab847b3fc754d5 | /8_ID_Gauss_seidel_update/gauss_correct.cc | 6426e4c45170243a04ad5197644f57e945b50134 | [] | no_license | adderbyte/High_performance_Computing_OPenMP_MPI_GPU | c8a54f7a3968108f2dd18b589fdbdd61c4444845 | 560dfd478d9c7ea341521ec93968731ebd900043 | refs/heads/master | 2022-01-25T10:35:00.660081 | 2019-06-19T21:50:23 | 2019-06-19T21:50:23 | 82,639,942 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,423 | cc | #include<iostream>
#include<iomanip>
#include<math.h>
#include<random>
#include <sstream>
#include <chrono>
#include "mpi.h"
#include "utils.h"
typedef std::chrono::high_resolution_clock clk;
typedef std::chrono::duration<double> second;
using namespace std;
int main( int argc , char **argv )
{
//check argument input
if (argc != 2)
{
std::cerr << "You have to specify the array dimensions" << std::endl;
return -1;
}
int N;
N = std::stoi(argv[1]) ;
// check input size array is not equals to zero
if (N <= 0)
{
std::cerr << "Invalid dimension x" << std::endl;
return -1;
}
int np,rank;
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&np); //communication world
MPI_Comm_rank(MPI_COMM_WORLD,&rank); //ran
double **A;
double *b ;
double *upper;
double *x;
double **local_a;
double *local_b;
double *t_upper;
double *previous; // previous value used in test for convergence
auto start = clk::now();
//set output precision
cout.precision(4);
cout.setf(ios::fixed);
// ---initialise array from rank 0 which serves as master ----//
if (rank==0){
//initialise array to be used
A = new double*[N];
upper = new double[N];
b= new double[N];
init2d(A, b, upper,N);
}
////------------diveide computational load among load processors--//
//int row; // send count for b
int row1; // for load balancing. send count for array A.
row1 = N/np;
//-----Scatter matrix -------//
local_b = new double[N];
local_a = new double*[N];
//allocate memory to local storage
double * tempStore = new double[N * N];
for (int i = 0; i < N; ++i){
local_a[i] = (tempStore + i * N);
}
x = new double[N];
t_upper = new double[N];
// allocate pointer
double * ptr =(double*) malloc(sizeof(double));
previous = new double[N];
if (rank == 0) {
delete ptr;
// delete ptr2;
ptr = &A[0][0];
}
MPI_Scatter(&b[0], row1, MPI_DOUBLE, &local_b[0], row1, MPI_DOUBLE,0,MPI_COMM_WORLD);
MPI_Scatter(ptr,row1*(N),MPI_DOUBLE,&local_a[0][0],row1*(N), MPI_DOUBLE,0,MPI_COMM_WORLD);
/*uncomment to see output of local a
if (rank==1){
for(int i =0 ; i<N;i++)
for(int j;j<N;j++)
{cout<<local_a[i][j]<<endl;
cout<<endl;}
}
*/
int flag =0; // for convergence;
//int * ptrflag = &flag;
for(int i ; i< N ;i++)
{
previous[i] = sin ( i + 0.04);
}
do
{
// MPI_Bcast(&x[0],N,MPI_DOUBLE, 0, MPI_COMM_WORLD);
MPI_Bcast(&flag,1,MPI_INT, 0, MPI_COMM_WORLD);
Gauss_seidel(A, local_a,t_upper ,local_b,x, row1, N,rank);
MPI_Gather(&t_upper[0],row1,MPI_DOUBLE,&upper[0],row1,MPI_DOUBLE,0,MPI_COMM_WORLD);
if( rank ==0){ update ( A, upper , x, N ); }
MPI_Bcast(&x[0],N,MPI_DOUBLE, 0, MPI_COMM_WORLD);
flag=convergence(x,flag,previous,N);
// flag++;
} while(flag<N);
/*
if(rank==0)
{
cout<<"\n--------------- Inside Gauss Siedel Function-------------------------------------------------------";
for(int i ; i<N;i++)
cout<<b[i]<<endl;
// fflush(stdout);
}
*/
//-----Get final time -----------//
if(rank ==0){
auto end = clk::now();
second time = end - start;
cout<<"Time taken: "<< time.count()<<endl;
cout <<"End."<< endl;
}
delete[] local_a[0];
delete[] local_a;
local_a=nullptr;
delete local_b;
delete previous;
delete x;
delete t_upper;
//delete ptrflag;
//-----clear memory ---------------//
if(rank==0)
{
//free (ptr);
delete[] A[0];
delete[] A;
A= nullptr;
delete upper;
delete b;}
MPI_Finalize();
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
3f2a604ccf7c340e07c69996fd7936ccf6c0936b | cfeac52f970e8901871bd02d9acb7de66b9fb6b4 | /generated/src/aws-cpp-sdk-es/source/model/CancelElasticsearchServiceSoftwareUpdateRequest.cpp | d59d974b5551cbffb6adc3cd5deb042d99bfc78c | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | aws/aws-sdk-cpp | aff116ddf9ca2b41e45c47dba1c2b7754935c585 | 9a7606a6c98e13c759032c2e920c7c64a6a35264 | refs/heads/main | 2023-08-25T11:16:55.982089 | 2023-08-24T18:14:53 | 2023-08-24T18:14:53 | 35,440,404 | 1,681 | 1,133 | Apache-2.0 | 2023-09-12T15:59:33 | 2015-05-11T17:57:32 | null | UTF-8 | C++ | false | false | 766 | cpp | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/es/model/CancelElasticsearchServiceSoftwareUpdateRequest.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::ElasticsearchService::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
CancelElasticsearchServiceSoftwareUpdateRequest::CancelElasticsearchServiceSoftwareUpdateRequest() :
m_domainNameHasBeenSet(false)
{
}
Aws::String CancelElasticsearchServiceSoftwareUpdateRequest::SerializePayload() const
{
JsonValue payload;
if(m_domainNameHasBeenSet)
{
payload.WithString("DomainName", m_domainName);
}
return payload.View().WriteReadable();
}
| [
"sdavtaker@users.noreply.github.com"
] | sdavtaker@users.noreply.github.com |
bbb21d506b42d85ca1073c1263c855f9b16c1810 | 2cea1d23405b15d8eb5bcc091aa144ee69d28338 | /hw4/bookstore/electronic.cpp | d5f78b708abdbb06f157825f2a7081f984792689 | [] | no_license | nksharath/CPP-Fun-Stuff | 1adbd79fb49f07272303f941d679f48c414357d0 | adca9dbd37c5bc84bbec64ce2095f086c6671dd9 | refs/heads/master | 2020-04-05T22:52:30.887029 | 2013-10-18T14:25:23 | 2013-10-18T14:25:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 680 | cpp | /*
*@Author : Sharath Navalpakkam Krishnan : Batch : 4003-700-01
*@Author : Pratik Mehta : : Batch : 4003-700-01
*@Version : 1.0.1
*@LastModified : 09/28/2012 1.25 PM
*
*/
#include "electronic.h"
#include<iostream>
#include "inventory.h"
using namespace std;
//Takes user input and searchs Eobject
void Ebooks::Search(string inp,int e,Ebooks EObject[])
{
int i=0;
while(i<e)
{
if(IsAvailable(inp,EObject[i]))
{
cout<<endl<<EObject[i].Elec<<endl<<
EObject[i].Title<<endl<<
EObject[i].Author<<endl<<
EObject[i].Price<<endl<<
EObject[i].Provider<<endl;
}i++;
}
}
| [
"nksharath@gmail.com"
] | nksharath@gmail.com |
5d6eb75a673d47fac45fcb00a10217ca6c96858c | dd6147bf9433298a64bbceb7fdccaa4cc477fba6 | /Sinelnikov/lab4/code/Base.cpp | 4add70d4365ddcd9555dc0f65844058f32d3131c | [] | no_license | moevm/oop | 64a89677879341a3e8e91ba6d719ab598dcabb49 | faffa7e14003b13c658ccf8853d6189b51ee30e6 | refs/heads/master | 2023-03-16T15:48:35.226647 | 2020-06-08T16:16:31 | 2020-06-08T16:16:31 | 85,785,460 | 42 | 304 | null | 2023-03-06T23:46:08 | 2017-03-22T04:37:01 | C++ | UTF-8 | C++ | false | false | 4,377 | cpp | //
// Created by max on 05.03.20.
//
#include "Base.h"
#include "Field.h"
int Base::getBaseXp() {
return this->basexp;
}
int Base::getMaxNumberOfUnits() {
return this->max_number_of_units;
}
int Base::getNumberOfUnits() {
return this->number_of_units;
}
int Base::getMaxXp() {
return 10;
}
void Base::increaseNumberOfUnits(int amount) {
this->number_of_units += amount;
}
void Base::decreaseNumberOfUnits(int amount) {
this->number_of_units -= amount;
}
void Base::increaseXp(int amount) {
this->basexp + amount < this->getMaxXp() ? this->basexp += amount : this->basexp = this->getMaxXp();
}
void Base::decreaseXp(int amount) {
this->basexp-=amount;
}
void Base::createUnit(Field* f,bool &check) {
int x,y,unit_id;
cout << "Создать лучника - 1\n";
cout << "Создать арбалетчика - 2\n";
cout << "Создать копейщика - 3\n";
cout << "Создать мечника - 4\n";
cout << "Создать лёгкого кавалера - 5\n";
cout << "Создать тяжёлого кавалера - 6\n";
cin >> unit_id;
if(unit_id < 1 || unit_id > 6){
f->getLog()->write("Неправильно задан юнит!!!\n");
return;
}
while (1) {
cout << "Завдайте местоположение размещения\n";
cin >> x >> y;
if(x >= f->getXsize() || y >= f->getYsize() || x < 0 || y < 0)
f->getLog()->write("Выход за пределы поля!!!\n");
else
if(abs(x - this->getXCoord()) > 3 || abs(y - this->getYCoord()) > 3) {
f->getLog()->write("Слишком далеко от базы\n");
return;
}
else
if(f->getLandscapeName(f->field[x][y].getLandscape()->getObjectId()) == "water" ||
f->getLandscapeName(f->field[x][y].getLandscape()->getObjectId()) == "mountain"){
f->getLog()->write("На эти природные объекты создавать нельзя\n");
return;
}
else
if(f->field[x][y].getIfOccupiedByUnit()) {
f->getLog()->write("Место занято! Выберите другое\n");
return;
}
else
break;
}
unit_id--;
if(x < f->getXsize() && y < f->getYsize() && x >= 0 && y>= 0){
if(!this->getNumberOfUnits() + 1 < this->getMaxNumberOfUnits()){
f->increaseNumberOfObjects();
switch(unit_id) {
case 0:
f->field[x][y].setElement(new Bowman);
f->getLog()->write("Пользователь выбрал лучника\n");
break;
case 1:
f->field[x][y].setElement(new Crossbowman);
f->getLog()->write("Пользователь выбрал арбалетчика\n");
break;
case 2:
f->field[x][y].setElement(new Spearman);
f->getLog()->write("Пользователь выбрал копейщика\n");
break;
case 3:
f->field[x][y].setElement(new Swordsman);
f->getLog()->write("Пользователь выбрал мечника\n");
break;
case 4:
f->field[x][y].setElement(new LightCavalry);
f->getLog()->write("Пользователь выбрал лёгкого кавалера\n");
break;
case 5:
f->field[x][y].setElement(new HardCavalry);
f->getLog()->write("Пользователь выбрал тяжёлого кавалера\n");
break;
}
f->field[x][y].getUnit()->setId(this->getObjectId());
f->field[x][y].getUnit()->setNumberInArray(f->getNumberOfUnits());
f->addUnitToArray(x,y);
this->increaseNumberOfUnits(1);
f->field[x][y].setOccupiedByUnit(true);
check = true;
f->getLog()->write("Юнит создан\n");
}
}
}
| [
"sinelnikovmaxim2000@mail.ru"
] | sinelnikovmaxim2000@mail.ru |
d2dcc3586004fdfb5863cc3a4a76727ee4d69772 | 9409914df889e026aa4d5ba3676cbfe9b36adabf | /MonoEngine/Math/Quad.h | daf73917e846909351cc1c3bf9427cd7b4e87a8d | [] | no_license | ifschleife/Mono1 | dc03beb6c6e143b8585844607b3b26f124d864c9 | 216df2af8cf6d98cda9c3b7763197aab8d925647 | refs/heads/master | 2021-09-01T06:30:37.898269 | 2017-12-24T12:06:40 | 2017-12-24T12:06:40 | 114,937,547 | 0 | 0 | null | 2017-12-20T22:37:18 | 2017-12-20T22:37:18 | null | UTF-8 | C++ | false | false | 957 | h |
#pragma once
#include "Vector.h"
namespace math
{
struct Quad
{
constexpr Quad()
{ }
constexpr Quad(float x, float y, float w, float h)
: mA(x, y),
mB(w, h)
{ }
constexpr Quad(const Vector& a, const Vector& b)
: mA(a),
mB(b)
{ }
Vector mA;
Vector mB;
};
Quad operator * (const Quad& left, float value);
Quad operator * (const Quad& left, const Vector& right);
//!
//! Be aware that this only checks for max/min values.
//! If you use the Quad as position and size vectors this
//! will not do what you think.
//!
void operator |= (Quad& left, const Quad& right);
void operator |= (Quad& left, const Vector& right);
bool operator == (const Quad& left, const Quad& right);
//! Zero quad defined for convenience
constexpr Quad zeroQuad = Quad(zeroVec, zeroVec);
}
| [
"niklas.damberg@gmail.com"
] | niklas.damberg@gmail.com |
ec56543b0678d0ad0b34533c4c31a247ceb9ac58 | 9c41624d538aa1cc735cc97011fa2b63f6ad82ed | /.history/课设beta0_1_20201224164352.cpp | f0c522db5f0da1abcce32ea6aec7c5151298e7e8 | [] | no_license | WanchengWildMan/HRManageMent | b90e9b55cba7707e4aaeb6aa297e2b3cece53ab6 | 284b94830fcc1dc95361176da6609896da9d2d6f | refs/heads/main | 2023-02-04T21:04:15.814180 | 2020-12-30T10:09:32 | 2020-12-30T10:09:32 | 318,743,424 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 12,489 | cpp | #include <bits/stdc++.h>
#define four 20000;
#define three 15000;
#define two 8000;
#define one 4000;
using namespace std;
#define inf 0x3f3f3f3f
string JOBS[] = {" ", "经理", "销售经理", "兼职技术人员", "兼职推销员"};
int PLUS_STEP_NUM;
double PLUS_RATE[7];
double MONEY_PER_HOUR;
double MONEY_MANAGER = 20000, MONEY_SALEMANAGER = 15000;
template <typename T>
inline int findElement(T *arr, T x, int len) {
for (int i = 1; i <= len; i++) {
if (arr[i] == x) return i;
}
return 0;
}
inline int intRead() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
inline int stoi(char *s) {
int x = 0;
for (int i = 0; i < strlen(s); i++) {
x = x * 10 + s[i] - '0';
}
return x;
}
class Person {
public:
string name; //名字
bool sex; // 1男
};
class Staff : public Person //定义一个人员的类
{
public:
string job; //职位
int jobid;
int number; //编号
double money; //工资
double hours;
double plusmoney;
double salevolume;
Staff() {}
Staff(string job1, string name1, double money1,
int number1) //构造函数初始化一个人员
{
job = job1;
name = name1;
number = number1;
money = money1;
jobid = findElement(JOBS, job1, 4);
}
~Staff() {}
static int sum; //这是static类型的sum 控制编号数字
};
class Function {
public:
string functionname;
};
class Financial : public Function {
public:
Financial() { functionname = "Finacial"; }
inline int CalcPlus(int Sales) {
int pos = 0;
for (int i = 0; i <= PLUS_STEP_NUM; i++) {
if (PLUS_RATE[i] <= Sales && Sales < PLUS_RATE[i + 1]) {
return PLUS_RATE[i] * Sales;
}
}
}
inline double qStaticMoney(int id) {
if (id > 3) {
cout << "只有经理和销售经理才有固定工资" << endl;
return 0;
}
return (id == 1 ? MONEY_MANAGER : MONEY_SALEMANAGER);
}
inline double GetMoneyByJob(Staff &worker, double salevolumeOrhours = 0) {
if (worker.jobid == 1) {
worker.money = MONEY_MANAGER;
}
if (worker.jobid == 2) {
worker.money = MONEY_SALEMANAGER + CalcPlus(salevolumeOrhours);
worker.plusmoney = salevolumeOrhours;
}
if (worker.jobid == 3) {
worker.hours = salevolumeOrhours;
worker.money = worker.hours * MONEY_PER_HOUR;
}
if (worker.jobid == 4) {
worker.money = salevolumeOrhours;
worker.plusmoney = CalcPlus(salevolumeOrhours);
worker.salevolume = salevolumeOrhours;
}
}
} FinancialModule;
class Main //总的控制台 控制人员；人员存放在vector的容器中
//通过内部函数进行各种操作
{
public:
vector<Staff> Peo;
public:
Main() {}
void Promote(); //升职函数
void Show(); //显示总信息
void Look(); //查找
void Increase(); //增加一个成员
void Delete(); //删除一个成员
void all();
void write(); //讲数据存入txt文件
void ReadFromFile();
void InputReward();
int Sum() //显示公司人数
{
return Peo.size();
}
};
void Main::ReadFromFile() //读取
{
// char www[200];
cout << "* 公司人员管理系统 *" << endl;
FILE *fp = fopen("a.txt", "r");
{
int num;
fscanf(fp, "%d", &num);
for (int i = 0; i < num; i++) {
char s1[40], s2[40], numb[40], mon[40];
fscanf(fp, "%s%s%s%s", s1, s2, numb, mon);
Staff p1;
p1.job = s1;
p1.name = s2;
p1.number = stoi(numb);
p1.money = stoi(mon);
Peo.push_back(p1);
cout << "名字：" << s1 << setw(15) << "编号：" << num << setw(15)
<< "职务：" << s2 << setw(15) << "工资：" << mon << endl;
}
}
}
void Main::all() //删除全部
{
vector<Staff>::iterator w;
if (Peo.size() == 0)
cout << "删除失败\n";
else {
cout << "总人数是" << Peo.size() << endl;
for (w = Peo.begin(); w != Peo.end(); w++) {
w = Peo.erase(w);
w--;
}
cout << "删除成功" << endl;
}
}
void Main::write() //存入txt文件模块
{
// string str="月底工资账单总览*";
FILE *fp = fopen("a.txt", "w");
fprintf(fp, "%d\n", Peo.size());
for (int i = 0; i < Peo.size(); i++) {
fprintf(fp, "%s %s %d %d\n", Peo[i].job.c_str(), Peo[i].name.c_str(),
Peo[i].number, Peo[i].money);
}
cout << "copy成功" << endl; //每次打开文件后最后都要关掉，不然存不进去
}
void Main::Promote() //升职模块
{
string name1; //升职人员的名字 偷懒了 name后面加了个1就算新的名字
string zhiwu; //所升的职务
double money1, numb, j; //升职后的工资 升职人数 和for循环所用的一个变量j
cout << "请输入要升职的人数：" << endl;
cin >> numb;
if (numb == 0 || Peo.size() == 0 || numb > Peo.size()) {
cout << "操作失败\n";
return;
}
for (int i = 1; i <= numb; i++) {
cout << "请输入第" << i << "升职人的名字" << endl;
cin >> name1;
for (j = 0; j < Peo.size(); j++)
if (Peo[j].name == name1) {
cout << "请输入要升职的职位" << endl;
cin >> zhiwu;
cout << "请输入职位的工资" << endl;
cin >> money1;
Peo[j].job = zhiwu;
Peo[j].money = money1;
}
if (j == Peo.size())
//没有此人的判断条件有三个 1.输入的人数为0 2.输入的人数超过总人数
// 3.输入的名字没有存在
cout << "没有此人" << endl;
}
}
void Main::Show() // 显示数据模块
{
cout << " 月底工资账单总览 " << endl;
for (int i = 0; i < Peo.size(); i++) {
cout << "名字：" << Peo[i].name << setw(15) << "编号：" << Peo[i].number
<< setw(15) << "职务：" << Peo[i].job << setw(15) << "工资："
<< Peo[i].money << endl;
if (Peo[i].jobid == 2) {
cout << setw(15) << "提成:" << endl;
}
}
if (Peo.size() == 0) cout << "无人员" << endl;
}
void Main::Look() //查找模块
{
string name1;
cout << "请输入要查找人的姓名:" << endl;
cin >> name1;
bool fnd = 0;
for (int i = 0; i < Peo.size(); i++)
if (Peo[i].name == name1) {
fnd = 1;
cout << "名字：" << Peo[i].name << setw(15) << "编号：" << Peo[i].number
<< setw(15) << "职务：" << Peo[i].job << setw(15) << "工资："
<< Peo[i].money;
}
if (!fnd) cout << "没有此人" << endl;
}
void Main::Increase() //增加人员模块
{
string name1;
string job1;
double money1;
int numb;
cout << "请输入要增加的人数：" << endl;
cin >> numb;
for (int i = 1; i <= numb; i++) {
cout << "请输入第" << i << "个人的名字：" << endl;
cin >> name1;
cout << "请输入职务：" << endl;
cout << " 1.经理" << endl;
cout << " 2.销售经理" << endl;
cout << " 3.兼职技术人员" << endl;
cout << " 4.兼职推销员" << endl;
int opt;
opt = intRead();
while (opt <= 0 || opt > 4) {
cout << "请输入正确的选项" << endl;
cin >> opt;
}
job1 = JOBS[opt];
money1 = FinancialModule.qStaticMoney(opt);
Staff::sum++;
Staff ch(job1, name1, money1, Staff::sum);
Peo.push_back(ch);
}
}
void Main::Delete() //删除模块
{
string name1;
int numb, j, sum;
cout << "请输入要删除的人数：" << endl;
cin >> numb;
if (numb == 0 || Peo.size() == 0 || numb > Peo.size()) {
cout << "操作失败\n";
return;
}
for (int i = 1; i <= numb; i++) {
cout << "请输入要删除的第" << i << "个人的姓名：" << endl;
cin >> name1;
for (j = 0; j < Peo.size(); j++) {
sum = Peo.size();
if (Peo[j].name == name1) {
Peo.erase(Peo.begin() + j);
cout << "删除成功" << endl;
break;
}
}
if (j == sum) cout << "没有此人" << endl;
}
}
class InputMethods : public Function {
public:
InputMethods() { functionname = "Input"; }
double InputSaleVolumeOrHours(string type) {
double res;
cout << type << ":" << endl;
cin >> res;
while (res < 0) {
cout << "请输入合法的" << type << "!" << endl;
}
return res;
}
} InputModule;
void Main::InputReward() {
cout << "是否修改经理yue'xin？ y/n" << endl;
char modify;
cin >> modify;
while (modify != 'y' && modify != 'n') cin >> modify;
if (modify == 'y') {
MONEY_MANAGER = intRead();
}
cout << "是否修改提成率？y/n" << endl;
cin >> modify;
while (modify != 'y' && modify != 'n') cin >> modify;
if (modify == 'y') {
cout << "请输入提成阶段数：" << endl;
cin >> PLUS_STEP_NUM;
while (PLUS_STEP_NUM > 5) {
cout << "提成阶段数超出最高限制！请重新输入！" << endl;
cin >> PLUS_STEP_NUM;
}
for (int i = 1; i <= PLUS_STEP_NUM; i++) {
cin >> PLUS_RATE[i];
}
PLUS_RATE[PLUS_STEP_NUM + 1] = inf;
}
cout << "是否修改时薪？y/n" << endl;
while (modify != 'y' && modify != 'n') cin >> modify;
if (modify == 'y') {
cout << "请输入时薪" << endl;
cin >> MONEY_PER_HOUR;
while (MONEY_PER_HOUR <= 0) {
cout << "请输入合法的时薪！" << endl;
cin >> MONEY_PER_HOUR;
}
}
for (int i = 0; i < Peo.size(); i++) {
if (Peo[i].jobid == 1) {
Peo[i].money = FinancialModule.GetMoneyByJob(Peo[i]);
continue;
}
cout << "请输入" << Peo[i].job << " " << Peo[i].name << "的";
double plusmoney = 0;
if (Peo[i].jobid == 2 || Peo[i].jobid == 4) {
FinancialModule.GetMoneyByJob(
Peo[i], InputModule.InputSaleVolumeOrHours("销售额"));
}
if (Peo[i].jobid == 3) {
FinancialModule.GetMoneyByJob(
Peo[i], InputModule.InputSaleVolumeOrHours("工作时间"));
}
}
}
int Staff::sum = 0;
int main() {
system("mode con cols=150 lines=30");
system("color 3f");
Main M;
while (1) {
system("cls");
cout << "*----------------------------------------------------------------*"
"\n";
cout << "* 公司人员管理系统 "
" *"
<< endl;
cout << "* 1/增加人员及其个人信息 "
" *"
<< endl;
cout << "* 2/删除人员及其个人信息 "
" *"
<< endl;
cout << "* 3/删除全部人员及其个人信息 "
" *"
<< endl;
cout << "* 4/查找人员及其个人信息 "
" *"
<< endl;
cout << "* 5/升职操作 "
" *"
<< endl;
cout << "* 6/公司人员总数 "
" *\n";
cout << "* 7/月底工资账单总览 "
" *"
<< endl;
cout << "* 8/负责人联系方式 "
" *"
<< endl;
cout << "* 9/信息整合保存成a.txt文件 "
" *"
<< endl;
cout << "* A/读取a.txt文件 "
" *"
<< endl;
cout << "------------------------------------------------------------------"
"-*"
<< endl;
cout << "请输入操作选项" << endl;
int opr;
opr = intRead();
switch (opr) {
case 1:
M.Increase();
break;
case 2:
M.Delete();
break;
case 3:
M.all();
break;
case 4:
M.Look();
break;
case 7:
M.Show();
break;
case 8:
cout << "微信：1596321；手机号：1598321" << endl;
break;
case 9:
M.write();
break;
case 5:
M.Promote();
break;
case 6:
cout << "公司总人数:" << M.Sum() << endl;
break;
case 10:
M.ReadFromFile();
break;
default:
cout << "请输入正确的选项！" << endl;
break;
}
system("pause"); //按任意键继续，实现了画面冻结
getchar();
}
} | [
"1150327966@qq.com"
] | 1150327966@qq.com |
845ecd4c902d9c747c8c6d0f5b37e279ab5743c3 | b2c6e51024cc0f65e2468f697841fd7fbd3bad22 | /au_sonar_repo_postrobosub2018/stm32/F7_limitedHAL/src/main.cpp | da4702fdd8995bdb74429187411ab611cf734583 | [] | no_license | mbardwell/SONAR | 8a14b148fa4ed99cc31df2f1041006a39bf18920 | 248701a7e4b58c9e417c95080893547741828de3 | refs/heads/master | 2020-06-24T11:35:34.533358 | 2018-08-21T22:30:29 | 2018-08-21T22:30:29 | 96,934,658 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,433 | cpp | /**
******************************************************************************
* File Name : main.c
* Description : Main program body
******************************************************************************
** This notice applies to any and all portions of this file
* that are not between comment pairs USER CODE BEGIN and
* USER CODE END. Other portions of this file, whether
* inserted by the user or by software development tools
* are owned by their respective copyright owners.
*
* COPYRIGHT(c) 2017 STMicroelectronics
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "stm32f7xx_hal.h"
#define GPIO_MODE ((uint32_t)0x00000003U)
#define GPIO_OUTPUT_TYPE ((uint32_t)0x00000010U)
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
void GPIO_Config();
void GPIO_Toggle();
int main(void)
{
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
GPIO_Config();
while (1)
{
HAL_Delay(1000);
GPIO_Toggle();
}
}
/** GPIO Configuration **/
void GPIO_Config() {
uint32_t position = 0x07; // Port B, ping 7
uint32_t temp = 0x00;
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN; // Enable RCC GPIOB CLK
temp = GPIOA->MODER;
temp &= ~(GPIO_MODER_MODER0 << (2*position));
temp |= (GPIO_MODE_OUTPUT_PP & GPIO_MODE) << (2*position);
GPIOB->MODER = temp;
/* Check the Speed parameter */
temp = GPIOB->OSPEEDR;
temp &= ~(GPIO_OSPEEDER_OSPEEDR0 << (position * 2));
temp |= (GPIO_SPEED_FREQ_LOW << (position * 2));
GPIOB->OSPEEDR = temp;
/* Configure the IO Output Type */
temp = GPIOB->OTYPER;
temp &= ~(GPIO_OTYPER_OT_0 << position) ;
temp |= (((GPIO_MODE_OUTPUT_PP & GPIO_OUTPUT_TYPE) >> 4) << position);
GPIOB->OTYPER = temp;
/* Activate the Pull-up or Pull down resistor for the current IO */
temp = GPIOB->PUPDR;
temp &= ~(GPIO_PUPDR_PUPDR0 << (position * 2));
temp |= ((GPIO_NOPULL) << (position * 2));
GPIOB->PUPDR = temp;
GPIO_Toggle();
}
void GPIO_Toggle() {
GPIOB->ODR ^= GPIO_PIN_7;
}
/** System Clock Configuration **/
void SystemClock_Config(void) {
RCC_OscInitTypeDef RCC_OscInitStruct;
RCC_ClkInitTypeDef RCC_ClkInitStruct;
/**Configure the main internal regulator output voltage
*/
__HAL_RCC_PWR_CLK_ENABLE();
__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
/**Initializes the CPU, AHB and APB busses clocks
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = 16;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
RCC_OscInitStruct.PLL.PLLM = 8;
RCC_OscInitStruct.PLL.PLLN = 50;
RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
RCC_OscInitStruct.PLL.PLLQ = 7;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
// _Error_Handler(__FILE__, __LINE__);
}
/**Initializes the CPU, AHB and APB busses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV8;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV4;
/**Configure the Systick interrupt time
*/
HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
/**Configure the Systick
*/
HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
/* SysTick_IRQn interrupt configuration */
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}
| [
"bardwell@ualberta.ca"
] | bardwell@ualberta.ca |
b0d0c61bb9b9d4e2517d3117cf4a79c303c249c0 | 11ef4bbb8086ba3b9678a2037d0c28baaf8c010e | /Source Code/server/binaries/chromium/gen/third_party/blink/renderer/bindings/core/v8/v8_worker_internals.cc | af21435214a65e69ea3c8f1751d3c3a33239ba21 | [] | no_license | lineCode/wasmview.github.io | 8f845ec6ba8a1ec85272d734efc80d2416a6e15b | eac4c69ea1cf0e9af9da5a500219236470541f9b | refs/heads/master | 2020-09-22T21:05:53.766548 | 2019-08-24T05:34:04 | 2019-08-24T05:34:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,443 | cc | // Copyright 2014 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.
// This file has been auto-generated from the Jinja2 template
// third_party/blink/renderer/bindings/templates/interface.cc.tmpl
// by the script code_generator_v8.py.
// DO NOT MODIFY!
// clang-format off
#include "third_party/blink/renderer/bindings/core/v8/v8_worker_internals.h"
#include <algorithm>
#include "base/memory/scoped_refptr.h"
#include "third_party/blink/renderer/bindings/core/v8/idl_types.h"
#include "third_party/blink/renderer/bindings/core/v8/native_value_traits_impl.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_dom_configuration.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_origin_trials_test.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_response.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_worker_global_scope.h"
#include "third_party/blink/renderer/core/execution_context/execution_context.h"
#include "third_party/blink/renderer/core/fetch/testing/worker_internals_fetch.h"
#include "third_party/blink/renderer/platform/bindings/exception_messages.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
#include "third_party/blink/renderer/platform/bindings/runtime_call_stats.h"
#include "third_party/blink/renderer/platform/bindings/script_state.h"
#include "third_party/blink/renderer/platform/bindings/v8_object_constructor.h"
#include "third_party/blink/renderer/platform/scheduler/public/cooperative_scheduling_manager.h"
#include "third_party/blink/renderer/platform/wtf/get_ptr.h"
namespace blink {
// Suppress warning: global constructors, because struct WrapperTypeInfo is trivial
// and does not depend on another global objects.
#if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wglobal-constructors"
#endif
const WrapperTypeInfo v8_worker_internals_wrapper_type_info = {
gin::kEmbedderBlink,
V8WorkerInternals::DomTemplate,
nullptr,
"WorkerInternals",
nullptr,
WrapperTypeInfo::kWrapperTypeObjectPrototype,
WrapperTypeInfo::kObjectClassId,
WrapperTypeInfo::kNotInheritFromActiveScriptWrappable,
};
#if defined(COMPONENT_BUILD) && defined(WIN32) && defined(__clang__)
#pragma clang diagnostic pop
#endif
// This static member must be declared by DEFINE_WRAPPERTYPEINFO in WorkerInternals.h.
// For details, see the comment of DEFINE_WRAPPERTYPEINFO in
// platform/bindings/ScriptWrappable.h.
const WrapperTypeInfo& WorkerInternals::wrapper_type_info_ = v8_worker_internals_wrapper_type_info;
// not [ActiveScriptWrappable]
static_assert(
!std::is_base_of<ActiveScriptWrappableBase, WorkerInternals>::value,
"WorkerInternals inherits from ActiveScriptWrappable<>, but is not specifying "
"[ActiveScriptWrappable] extended attribute in the IDL file. "
"Be consistent.");
static_assert(
std::is_same<decltype(&WorkerInternals::HasPendingActivity),
decltype(&ScriptWrappable::HasPendingActivity)>::value,
"WorkerInternals is overriding hasPendingActivity(), but is not specifying "
"[ActiveScriptWrappable] extended attribute in the IDL file. "
"Be consistent.");
namespace worker_internals_v8_internal {
static void OriginTrialsTestMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
WorkerInternals* impl = V8WorkerInternals::ToImpl(info.Holder());
V8SetReturnValue(info, impl->originTrialsTest());
}
static void CountFeatureMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exception_state(info.GetIsolate(), ExceptionState::kExecutionContext, "WorkerInternals", "countFeature");
WorkerInternals* impl = V8WorkerInternals::ToImpl(info.Holder());
ScriptState* script_state = ScriptState::ForRelevantRealm(info);
if (UNLIKELY(info.Length() < 1)) {
exception_state.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
return;
}
uint32_t feature;
feature = NativeValueTraits<IDLUnsignedLong>::NativeValue(info.GetIsolate(), info[0], exception_state);
if (exception_state.HadException())
return;
impl->countFeature(script_state, feature, exception_state);
if (exception_state.HadException()) {
return;
}
}
static void CountDeprecationMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exception_state(info.GetIsolate(), ExceptionState::kExecutionContext, "WorkerInternals", "countDeprecation");
WorkerInternals* impl = V8WorkerInternals::ToImpl(info.Holder());
ScriptState* script_state = ScriptState::ForRelevantRealm(info);
if (UNLIKELY(info.Length() < 1)) {
exception_state.ThrowTypeError(ExceptionMessages::NotEnoughArguments(1, info.Length()));
return;
}
uint32_t feature;
feature = NativeValueTraits<IDLUnsignedLong>::NativeValue(info.GetIsolate(), info[0], exception_state);
if (exception_state.HadException())
return;
impl->countDeprecation(script_state, feature, exception_state);
if (exception_state.HadException()) {
return;
}
}
static void CollectGarbageMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
WorkerInternals* impl = V8WorkerInternals::ToImpl(info.Holder());
ScriptState* script_state = ScriptState::ForRelevantRealm(info);
impl->collectGarbage(script_state);
}
static void GetInternalResponseURLListMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
WorkerInternals* impl = V8WorkerInternals::ToImpl(info.Holder());
if (UNLIKELY(info.Length() < 1)) {
V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("getInternalResponseURLList", "WorkerInternals", ExceptionMessages::NotEnoughArguments(1, info.Length())));
return;
}
Response* response;
response = V8Response::ToImplWithTypeCheck(info.GetIsolate(), info[0]);
if (!response) {
V8ThrowException::ThrowTypeError(info.GetIsolate(), ExceptionMessages::FailedToExecute("getInternalResponseURLList", "WorkerInternals", "parameter 1 is not of type 'Response'."));
return;
}
V8SetReturnValue(info, ToV8(WorkerInternalsFetch::getInternalResponseURLList(*impl, response), info.Holder(), info.GetIsolate()));
}
static void GetResourcePriorityMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
ExceptionState exception_state(info.GetIsolate(), ExceptionState::kExecutionContext, "WorkerInternals", "getResourcePriority");
ExceptionToRejectPromiseScope reject_promise_scope(info, exception_state);
// V8DOMConfiguration::kDoNotCheckHolder
// Make sure that info.Holder() really points to an instance of the type.
if (!V8WorkerInternals::HasInstance(info.Holder(), info.GetIsolate())) {
exception_state.ThrowTypeError("Illegal invocation");
return;
}
WorkerInternals* impl = V8WorkerInternals::ToImpl(info.Holder());
ScriptState* script_state = ScriptState::ForRelevantRealm(info);
if (UNLIKELY(info.Length() < 2)) {
exception_state.ThrowTypeError(ExceptionMessages::NotEnoughArguments(2, info.Length()));
return;
}
V8StringResource<> url;
WorkerGlobalScope* worker_global;
url = info[0];
if (!url.Prepare(exception_state))
return;
worker_global = V8WorkerGlobalScope::ToImplWithTypeCheck(info.GetIsolate(), info[1]);
if (!worker_global) {
exception_state.ThrowTypeError("parameter 2 is not of type 'WorkerGlobalScope'.");
return;
}
ScriptPromise result = WorkerInternalsFetch::getResourcePriority(script_state, *impl, url, worker_global);
V8SetReturnValue(info, result.V8Value());
}
} // namespace worker_internals_v8_internal
void V8WorkerInternals::OriginTrialsTestMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
RUNTIME_CALL_TIMER_SCOPE_DISABLED_BY_DEFAULT(info.GetIsolate(), "Blink_WorkerInternals_originTrialsTest");
worker_internals_v8_internal::OriginTrialsTestMethod(info);
}
void V8WorkerInternals::CountFeatureMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
RUNTIME_CALL_TIMER_SCOPE_DISABLED_BY_DEFAULT(info.GetIsolate(), "Blink_WorkerInternals_countFeature");
worker_internals_v8_internal::CountFeatureMethod(info);
}
void V8WorkerInternals::CountDeprecationMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
RUNTIME_CALL_TIMER_SCOPE_DISABLED_BY_DEFAULT(info.GetIsolate(), "Blink_WorkerInternals_countDeprecation");
worker_internals_v8_internal::CountDeprecationMethod(info);
}
void V8WorkerInternals::CollectGarbageMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
RUNTIME_CALL_TIMER_SCOPE_DISABLED_BY_DEFAULT(info.GetIsolate(), "Blink_WorkerInternals_collectGarbage");
worker_internals_v8_internal::CollectGarbageMethod(info);
}
void V8WorkerInternals::GetInternalResponseURLListMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
RUNTIME_CALL_TIMER_SCOPE_DISABLED_BY_DEFAULT(info.GetIsolate(), "Blink_WorkerInternals_getInternalResponseURLList");
worker_internals_v8_internal::GetInternalResponseURLListMethod(info);
}
void V8WorkerInternals::GetResourcePriorityMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
RUNTIME_CALL_TIMER_SCOPE_DISABLED_BY_DEFAULT(info.GetIsolate(), "Blink_WorkerInternals_getResourcePriority");
worker_internals_v8_internal::GetResourcePriorityMethod(info);
}
static constexpr V8DOMConfiguration::MethodConfiguration kV8WorkerInternalsMethods[] = {
{"originTrialsTest", V8WorkerInternals::OriginTrialsTestMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kHasSideEffect, V8DOMConfiguration::kAllWorlds},
{"countFeature", V8WorkerInternals::CountFeatureMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kHasSideEffect, V8DOMConfiguration::kAllWorlds},
{"countDeprecation", V8WorkerInternals::CountDeprecationMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kHasSideEffect, V8DOMConfiguration::kAllWorlds},
{"collectGarbage", V8WorkerInternals::CollectGarbageMethodCallback, 0, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kHasSideEffect, V8DOMConfiguration::kAllWorlds},
{"getInternalResponseURLList", V8WorkerInternals::GetInternalResponseURLListMethodCallback, 1, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kHasSideEffect, V8DOMConfiguration::kAllWorlds},
{"getResourcePriority", V8WorkerInternals::GetResourcePriorityMethodCallback, 2, v8::None, V8DOMConfiguration::kOnPrototype, V8DOMConfiguration::kDoNotCheckHolder, V8DOMConfiguration::kDoNotCheckAccess, V8DOMConfiguration::kHasSideEffect, V8DOMConfiguration::kAllWorlds},
};
static void InstallV8WorkerInternalsTemplate(
v8::Isolate* isolate,
const DOMWrapperWorld& world,
v8::Local<v8::FunctionTemplate> interface_template) {
// Initialize the interface object's template.
V8DOMConfiguration::InitializeDOMInterfaceTemplate(isolate, interface_template, V8WorkerInternals::GetWrapperTypeInfo()->interface_name, v8::Local<v8::FunctionTemplate>(), V8WorkerInternals::kInternalFieldCount);
v8::Local<v8::Signature> signature = v8::Signature::New(isolate, interface_template);
ALLOW_UNUSED_LOCAL(signature);
v8::Local<v8::ObjectTemplate> instance_template = interface_template->InstanceTemplate();
ALLOW_UNUSED_LOCAL(instance_template);
v8::Local<v8::ObjectTemplate> prototype_template = interface_template->PrototypeTemplate();
ALLOW_UNUSED_LOCAL(prototype_template);
// Register IDL constants, attributes and operations.
V8DOMConfiguration::InstallMethods(
isolate, world, instance_template, prototype_template, interface_template,
signature, kV8WorkerInternalsMethods, base::size(kV8WorkerInternalsMethods));
// Custom signature
V8WorkerInternals::InstallRuntimeEnabledFeaturesOnTemplate(
isolate, world, interface_template);
}
void V8WorkerInternals::InstallRuntimeEnabledFeaturesOnTemplate(
v8::Isolate* isolate,
const DOMWrapperWorld& world,
v8::Local<v8::FunctionTemplate> interface_template) {
v8::Local<v8::Signature> signature = v8::Signature::New(isolate, interface_template);
ALLOW_UNUSED_LOCAL(signature);
v8::Local<v8::ObjectTemplate> instance_template = interface_template->InstanceTemplate();
ALLOW_UNUSED_LOCAL(instance_template);
v8::Local<v8::ObjectTemplate> prototype_template = interface_template->PrototypeTemplate();
ALLOW_UNUSED_LOCAL(prototype_template);
// Register IDL constants, attributes and operations.
// Custom signature
}
v8::Local<v8::FunctionTemplate> V8WorkerInternals::DomTemplate(
v8::Isolate* isolate, const DOMWrapperWorld& world) {
return V8DOMConfiguration::DomClassTemplate(
isolate, world, const_cast<WrapperTypeInfo*>(V8WorkerInternals::GetWrapperTypeInfo()),
InstallV8WorkerInternalsTemplate);
}
bool V8WorkerInternals::HasInstance(v8::Local<v8::Value> v8_value, v8::Isolate* isolate) {
return V8PerIsolateData::From(isolate)->HasInstance(V8WorkerInternals::GetWrapperTypeInfo(), v8_value);
}
v8::Local<v8::Object> V8WorkerInternals::FindInstanceInPrototypeChain(
v8::Local<v8::Value> v8_value, v8::Isolate* isolate) {
return V8PerIsolateData::From(isolate)->FindInstanceInPrototypeChain(
V8WorkerInternals::GetWrapperTypeInfo(), v8_value);
}
WorkerInternals* V8WorkerInternals::ToImplWithTypeCheck(
v8::Isolate* isolate, v8::Local<v8::Value> value) {
return HasInstance(value, isolate) ? ToImpl(v8::Local<v8::Object>::Cast(value)) : nullptr;
}
WorkerInternals* NativeValueTraits<WorkerInternals>::NativeValue(
v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exception_state) {
WorkerInternals* native_value = V8WorkerInternals::ToImplWithTypeCheck(isolate, value);
if (!native_value) {
exception_state.ThrowTypeError(ExceptionMessages::FailedToConvertJSValue(
"WorkerInternals"));
}
return native_value;
}
} // namespace blink
| [
"wasmview@gmail.com"
] | wasmview@gmail.com |
94a3919132b37c5cfbb4ac513712057eef2a480d | b581cb3e866a710d95055efe8b80b53b1defe318 | /fuse.cc | 2bd7e80317aaacdb02ffd0550a8439bf3e67b008 | [] | no_license | xyzhu1120/cselab | 5d44d86d4827a026425c6e821ed79271f315fb0e | 7524883fb882e3e32f631451faf78208c4214130 | refs/heads/master | 2021-01-19T06:37:16.647483 | 2013-01-15T14:43:29 | 2013-01-15T14:43:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,905 | cc | /*
* receive request from fuse and call methods of yfs_client
*
* started life as low-level example in the fuse distribution. we
* have to use low-level interface in order to get i-numbers. the
* high-level interface only gives us complete paths.
*/
#include <fuse_lowlevel.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <iostream>
#include <arpa/inet.h>
#include "lang/verify.h"
#include "yfs_client.h"
int myid;
yfs_client *yfs;
int id() {
return myid;
}
//
// A file/directory's attributes are a set of information
// including owner, permissions, size, &c. The information is
// much the same as that returned by the stat() system call.
// The kernel needs attributes in many situations, and some
// fuse functions (such as lookup) need to return attributes
// as well as other information, so getattr() gets called a lot.
//
// YFS fakes most of the attributes. It does provide more or
// less correct values for the access/modify/change times
// (atime, mtime, and ctime), and correct values for file sizes.
//
yfs_client::status
getattr(yfs_client::inum inum, struct stat &st)
{
yfs_client::status ret;
bzero(&st, sizeof(st));
st.st_ino = inum;
printf("getattr %016llx %d\n", inum, yfs->isfile(inum));
if(yfs->isfile(inum)){
yfs_client::fileinfo info;
ret = yfs->getfile(inum, info);
if(ret != yfs_client::OK)
return ret;
st.st_mode = S_IFREG | 0666;
st.st_nlink = 1;
st.st_atime = info.atime;
st.st_mtime = info.mtime;
st.st_ctime = info.ctime;
st.st_size = info.size;
printf(" getattr -> %llu\n", info.size);
} else {
yfs_client::dirinfo info;
ret = yfs->getdir(inum, info);
if(ret != yfs_client::OK)
return ret;
st.st_mode = S_IFDIR | 0777;
st.st_nlink = 2;
st.st_atime = info.atime;
st.st_mtime = info.mtime;
st.st_ctime = info.ctime;
printf(" getattr -> %lu %lu %lu\n", info.atime, info.mtime, info.ctime);
}
return yfs_client::OK;
}
//
// This is a typical fuse operation handler; you'll be writing
// a bunch of handlers like it.
//
// A handler takes some arguments
// and supplies either a success or failure response. It provides
// an error response by calling either fuse_reply_err(req, errno), and
// a normal response by calling ruse_reply_xxx(req, ...). The req
// argument serves to link up this response with the original
// request; just pass the same @req that was passed into the handler.
//
// The @ino argument indicates the file or directory FUSE wants
// you to operate on. It's a 32-bit FUSE identifier; just assign
// it to a yfs_client::inum to get a 64-bit YFS inum.
//
void
fuseserver_getattr(fuse_req_t req, fuse_ino_t ino,
struct fuse_file_info *fi)
{
struct stat st;
yfs_client::inum inum = ino; // req->in.h.nodeid;
yfs_client::status ret;
ret = getattr(inum, st);
if(ret != yfs_client::OK){
fuse_reply_err(req, ENOENT);
return;
}
fuse_reply_attr(req, &st, 0);
}
//
// Set the attributes of a file. Often used as part of overwriting
// a file, to set the file length to zero.
//
// to_set is a bitmap indicating which attributes to set. You only
// have to implement the FUSE_SET_ATTR_SIZE bit, which indicates
// that the size of the file should be changed. The new size is
// in attr->st_size. If the new size is bigger than the current
// file size, fill the new bytes with '\0'.
//
// On success, call fuse_reply_attr, passing the file's new
// attributes (from a call to getattr()).
//
void
fuseserver_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
int to_set, struct fuse_file_info *fi)
{
printf("fuseserver_setattr 0x%x\n", to_set);
if (FUSE_SET_ATTR_SIZE & to_set) {
printf(" fuseserver_setattr set size to %zu\n", attr->st_size);
struct stat st;
// You fill this in for Lab 2
#if 1
yfs->setattr(ino,attr->st_size);
getattr(ino,st);
// Change the above line to "#if 1", and your code goes here
// Note: fill st using getattr before fuse_reply_attr
fuse_reply_attr(req, &st, 0);
#else
fuse_reply_err(req, ENOSYS);
#endif
} else {
fuse_reply_err(req, ENOSYS);
}
}
//
// Read up to @size bytes starting at byte offset @off in file @ino.
//
// Pass the number of bytes actually read to fuse_reply_buf.
// If there are fewer than @size bytes to read between @off and the
// end of the file, read just that many bytes. If @off is greater
// than or equal to the size of the file, read zero bytes.
//
// Ignore @fi.
// @req identifies this request, and is used only to send a
// response back to fuse with fuse_reply_buf or fuse_reply_err.
//
void
fuseserver_read(fuse_req_t req, fuse_ino_t ino, size_t size,
off_t off, struct fuse_file_info *fi)
{
// You fill this in for Lab 2
#if 1
std::string buf;
buf = yfs->read(ino, size, off);
// Change the above "#if 0" to "#if 1", and your code goes here
fuse_reply_buf(req, buf.data(), buf.size());
std::cout << "**FUse Read " << buf.data() << buf.size() << std::endl;
#else
fuse_reply_err(req, ENOSYS);
#endif
}
//
// Write @size bytes from @buf to file @ino, starting
// at byte offset @off in the file.
//
// If @off + @size is greater than the current size of the
// file, the write should cause the file to grow. If @off is
// beyond the end of the file, fill the gap with null bytes.
//
// Set the file's mtime to the current time.
//
// Ignore @fi.
//
// @req identifies this request, and is used only to send a
// response back to fuse with fuse_reply_buf or fuse_reply_err.
//
void
fuseserver_write(fuse_req_t req, fuse_ino_t ino,
const char *buf, size_t size, off_t off,
struct fuse_file_info *fi)
{
// You fill this in for Lab 2
#if 1
yfs->write(ino, buf, size, off);
// Change the above line to "#if 1", and your code goes here
fuse_reply_write(req, size);
#else
fuse_reply_err(req, ENOSYS);
#endif
}
//
// Create file @name in directory @parent.
//
// - @mode specifies the create mode of the file. Ignore it - you do not
// have to implement file mode.
// - If a file named @name already exists in @parent, return EXIST.
// - Pick an ino (with type of yfs_client::inum) for file @name.
// Make sure ino indicates a file, not a directory!
// - Create an empty extent for ino.
// - Add a <name, ino> entry into @parent.
// - Change the parent's mtime and ctime to the current time/date
// (this may fall naturally out of your extent server code).
// - On success, store the inum of newly created file into @e->ino,
// and the new file's attribute into @e->attr. Get the file's
// attributes with getattr().
//
// @return yfs_client::OK on success, and EXIST if @name already exists.
//
yfs_client::status
fuseserver_createhelper(fuse_ino_t parent, const char *name,
mode_t mode, struct fuse_entry_param *e)
{
// In yfs, timeouts are always set to 0.0, and generations are always set to 0
e->attr_timeout = 0.0;
e->entry_timeout = 0.0;
e->generation = 0;
yfs_client::inum inum;
int r = yfs->create(parent,name,inum);
struct stat st;
getattr(inum, st);
e->ino = inum;
e->attr = st;
// You fill this in for Lab 2
return r;
}
void
fuseserver_create(fuse_req_t req, fuse_ino_t parent, const char *name,
mode_t mode, struct fuse_file_info *fi)
{
struct fuse_entry_param e;
yfs_client::status ret;
if( (ret = fuseserver_createhelper( parent, name, mode, &e )) == yfs_client::OK ) {
std::cout << "---fuse create success" << std::endl;
fuse_reply_create(req, &e, fi);
} else {
if (ret == yfs_client::EXIST) {
fuse_reply_err(req, EEXIST);
}else{
fuse_reply_err(req, ENOENT);
}
}
}
void fuseserver_mknod( fuse_req_t req, fuse_ino_t parent,
const char *name, mode_t mode, dev_t rdev ) {
struct fuse_entry_param e;
yfs_client::status ret;
if( (ret = fuseserver_createhelper( parent, name, mode, &e )) == yfs_client::OK ) {
fuse_reply_entry(req, &e);
} else {
if (ret == yfs_client::EXIST) {
fuse_reply_err(req, EEXIST);
}else{
fuse_reply_err(req, ENOENT);
}
}
}
//
// Look up file or directory @name in the directory @parent. If @name is
// found, set e.attr (using getattr) and e.ino to the attribute and inum of
// the file.
//
void
fuseserver_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
{
struct fuse_entry_param e;
// In yfs, timeouts are always set to 0.0, and generations are always set to 0
e.attr_timeout = 0.0;
e.entry_timeout = 0.0;
e.generation = 0;
bool found = false;
// You fill this in for Lab 2
yfs_client::inum inum;
found = yfs->lookup(parent, name, inum);
if (found){
struct stat st;
getattr(inum, st);
e.attr = st;
e.ino = inum;
fuse_reply_entry(req, &e);
}
else
fuse_reply_err(req, ENOENT);
}
struct dirbuf {
char *p;
size_t size;
};
void dirbuf_add(struct dirbuf *b, const char *name, fuse_ino_t ino)
{
struct stat stbuf;
size_t oldsize = b->size;
b->size += fuse_dirent_size(strlen(name));
b->p = (char *) realloc(b->p, b->size);
memset(&stbuf, 0, sizeof(stbuf));
stbuf.st_ino = ino;
fuse_add_dirent(b->p + oldsize, name, &stbuf, b->size);
}
#define min(x, y) ((x) < (y) ? (x) : (y))
int reply_buf_limited(fuse_req_t req, const char *buf, size_t bufsize,
off_t off, size_t maxsize)
{
if ((size_t)off < bufsize)
return fuse_reply_buf(req, buf + off, min(bufsize - off, maxsize));
else
return fuse_reply_buf(req, NULL, 0);
}
//
// Retrieve all the file names / i-numbers pairs
// in directory @ino. Send the reply using reply_buf_limited.
//
// You can ignore @size and @off (except that you must pass
// them to reply_buf_limited).
//
// Call dirbuf_add(&b, name, inum) for each entry in the directory.
//
void
fuseserver_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
off_t off, struct fuse_file_info *fi)
{
yfs_client::inum inum = ino; // req->in.h.nodeid;
struct dirbuf b;
printf("fuseserver_readdir\n");
if(!yfs->isdir(inum)){
fuse_reply_err(req, ENOTDIR);
return;
}
memset(&b, 0, sizeof(b));
// You fill this in for Lab 2
std::vector<yfs_client::dirent> ents = yfs->readdir(inum);
for( int i = 0; i < ents.size(); ++i) {
dirbuf_add(&b, ents[i].name.c_str(), ents[i].inum);
}
reply_buf_limited(req, b.p, b.size, off, size);
free(b.p);
}
void
fuseserver_open(fuse_req_t req, fuse_ino_t ino,
struct fuse_file_info *fi)
{
fuse_reply_open(req, fi);
}
//
// Create a new directory with name @name in parent directory @parent.
// Leave new directory's inum in e.ino and attributes in e.attr.
//
// The new directory should be empty (no . or ..).
//
// If a file/directory named @name already exists, indicate error EEXIST.
//
// Ignore mode.
//
void
fuseserver_mkdir(fuse_req_t req, fuse_ino_t parent, const char *name,
mode_t mode)
{
struct fuse_entry_param e;
// In yfs, timeouts are always set to 0.0, and generations are always set to 0
e.attr_timeout = 0.0;
e.entry_timeout = 0.0;
e.generation = 0;
// Suppress compiler warning of unused e.
//(void) e;
yfs_client::inum inum;
int r = yfs->mkdir(parent,name,inum);
struct stat st;
getattr(inum, st);
e.ino = inum;
e.attr = st;
// You fill this in for Lab 3
if(r == yfs_client::OK)
fuse_reply_entry(req, &e);
else if(r == yfs_client::EXIST)
fuse_reply_err(req, EEXIST);
else
fuse_reply_err(req, ENOSYS);
}
//
// Remove the file named @name from directory @parent.
// Free the file's extent.
// If the file doesn't exist, indicate error ENOENT.
//
// Do *not* allow unlinking of a directory.
//
void
fuseserver_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
{
// You fill this in for Lab 3
// Success: fuse_reply_err(req, 0);
// Not found: fuse_reply_err(req, ENOENT);
int r = yfs->unlink(parent, name);
if( r == yfs_client::OK)
fuse_reply_err(req, 0);
else if(r == yfs_client::NOENT)
fuse_reply_err(req, ENOENT);
else
fuse_reply_err(req, ENOSYS);
}
void
fuseserver_statfs(fuse_req_t req)
{
struct statvfs buf;
printf("statfs\n");
memset(&buf, 0, sizeof(buf));
buf.f_namemax = 255;
buf.f_bsize = 512;
fuse_reply_statfs(req, &buf);
}
struct fuse_lowlevel_ops fuseserver_oper;
int
main(int argc, char *argv[])
{
char *mountpoint = 0;
int err = -1;
int fd;
setvbuf(stdout, NULL, _IONBF, 0);
if(argc != 4){
fprintf(stderr, "Usage: yfs_client <mountpoint> <port-extent-server> <port-lock-server>\n");
exit(1);
}
mountpoint = argv[1];
srandom(getpid());
myid = random();
yfs = new yfs_client(argv[2], argv[3]);
fuseserver_oper.getattr = fuseserver_getattr;
fuseserver_oper.statfs = fuseserver_statfs;
fuseserver_oper.readdir = fuseserver_readdir;
fuseserver_oper.lookup = fuseserver_lookup;
fuseserver_oper.create = fuseserver_create;
fuseserver_oper.mknod = fuseserver_mknod;
fuseserver_oper.open = fuseserver_open;
fuseserver_oper.read = fuseserver_read;
fuseserver_oper.write = fuseserver_write;
fuseserver_oper.setattr = fuseserver_setattr;
fuseserver_oper.unlink = fuseserver_unlink;
fuseserver_oper.mkdir = fuseserver_mkdir;
const char *fuse_argv[20];
int fuse_argc = 0;
fuse_argv[fuse_argc++] = argv[0];
#ifdef __APPLE__
fuse_argv[fuse_argc++] = "-o";
fuse_argv[fuse_argc++] = "nolocalcaches"; // no dir entry caching
fuse_argv[fuse_argc++] = "-o";
fuse_argv[fuse_argc++] = "daemon_timeout=86400";
#endif
// everyone can play, why not?
//fuse_argv[fuse_argc++] = "-o";
//fuse_argv[fuse_argc++] = "allow_other";
fuse_argv[fuse_argc++] = mountpoint;
fuse_argv[fuse_argc++] = "-d";
fuse_args args = FUSE_ARGS_INIT( fuse_argc, (char **) fuse_argv );
int foreground;
int res = fuse_parse_cmdline( &args, &mountpoint, 0 /*multithreaded*/,
&foreground );
if( res == -1 ) {
fprintf(stderr, "fuse_parse_cmdline failed\n");
return 0;
}
args.allocated = 0;
fd = fuse_mount(mountpoint, &args);
if(fd == -1){
fprintf(stderr, "fuse_mount failed\n");
exit(1);
}
struct fuse_session *se;
se = fuse_lowlevel_new(&args, &fuseserver_oper, sizeof(fuseserver_oper),
NULL);
if(se == 0){
fprintf(stderr, "fuse_lowlevel_new failed\n");
exit(1);
}
struct fuse_chan *ch = fuse_kern_chan_new(fd);
if (ch == NULL) {
fprintf(stderr, "fuse_kern_chan_new failed\n");
exit(1);
}
fuse_session_add_chan(se, ch);
// err = fuse_session_loop_mt(se); // FK: wheelfs does this; why?
err = fuse_session_loop(se);
fuse_session_destroy(se);
close(fd);
fuse_unmount(mountpoint);
return err ? 1 : 0;
}
| [
"xyzhu1120@gmail.com"
] | xyzhu1120@gmail.com |
7860939d2a267159b72f7b90af19ca28fbfc7002 | 5b317bcd16b0679b57ead391297fc73336ccf1d7 | /src/vscp/proto/serverprotoanalyzer.h | 92d3383c3bdde3d173d029dece9141864f8045f1 | [] | no_license | khvysofq/vscp | 72c2bae4b128ec58eedc5e877fe532eae8b77d4c | 849ecb972a42029f764df9dae6df15c134aa161a | refs/heads/master | 2021-01-10T20:52:38.437757 | 2014-12-23T03:34:00 | 2014-12-23T03:34:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,138 | h | // Vision Zenith System Communication Protocol (Project)
#ifndef VSCP_PROTO_SERVER_PROTO_ANALYZER_H_
#define VSCP_PROTO_SERVER_PROTO_ANALYZER_H_
#include "json/json.h"
#include "vscp/proto/protobasicincludes.h"
#include "vscp/proto/baseprotoanalyzer.h"
namespace vscp {
class VscpServerProtoAnalyzer : public VscpBaseProtoAnalyzer{
public:
VscpServerProtoAnalyzer(const std::string& local_vsid);
// TODO(guangleiHe), if return false, how to do?
// virtual bool AddPacketData(const char *buffer, int len);
// As server protocol, this method do nothing
virtual bool StartProtoAnalyzer();
virtual bool StopProtoAnalyzer();
virtual void PingMessage();
private:
virtual bool Step(JsonStanza& json_stanza, const char* data, int len);
bool StartConnectMsg(JsonStanza& json_stanza);
bool ClientAuthentication(JsonStanza& json_stanza);
// Test method
bool ServerEchoMessage(JsonStanza& json_stanza);
bool OnMessage(JsonStanza& json_stanza, const char* data, int len);
private:
}; // class VscpProtoAnalyzer
}; // namespace vscp
#endif // VSCP_PROTO_SERVER_PROTO_ANALYZER_H_ | [
"guangleihe@gmail.com"
] | guangleihe@gmail.com |
ffa9766b3dddd34a8883f0acbcb499c7ac3e70d7 | 01d61a4f248c22d7778b8d15bd45a034db49a34f | /graphics_framework/include/cVertexShader.h | 652e1b04365858fc239ca523797b7116e5a65067 | [] | no_license | y1z/Directx_Framework_Project | 5a55cf02c374574b7777d94d64977d8f40ea48c5 | 15d89d27ae432a2323513621dc62bfbf14e411b8 | refs/heads/master | 2020-07-26T13:52:27.281518 | 2019-12-06T09:46:52 | 2019-12-06T09:46:52 | 208,665,870 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 599 | h | #pragma once
#include "utility/enGraphics.h"
#include "cShaderBase.h"
class cVertexShader : public cShaderBase
{
public:
cVertexShader();
cVertexShader(cVertexShader &&other);
cVertexShader(const cVertexShader &other) = delete;
~cVertexShader();
public:
#if DIRECTX
//! for argument's that require 1 pointer
ID3D11VertexShader* getVertexShader();
//! for argument's that require 2 pointers
ID3D11VertexShader** getVertexShaderRef();
#elif OPEN_GL
#endif // DIRECTX
public:
private:
#if DIRECTX
ID3D11VertexShader *mptr_vertexShader;
#elif OPEN_GL
#endif // DIRECTX
};
| [
"whyis2cool@gmail.com"
] | whyis2cool@gmail.com |
21e9834553f427976eba12adcd59289723b89673 | 6321c83c09d1d844237d6e051da43e3326dae4b0 | /RacketGame/mainwindow.h | b4bd8a21a2926c0b1309cd15c327d45d58834168 | [] | no_license | progstorage/resume_programs | b1fb7312010b735458901d3db701c9d6608e0569 | ab32bf5cd31456138873a87981970cb73478c77f | refs/heads/master | 2021-01-14T04:23:06.599146 | 2020-08-03T22:20:41 | 2020-08-03T22:20:41 | 242,598,142 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,350 | h | #pragma once
#include <cmath>
#include <QDebug>
#include <QKeyEvent>
#include <QMainWindow>
#include <QPixmap>
#include <QThread>
/***********************************************
TODO:
1) 2й поток (для ракетки)
2) указывать текущий счет
+ завести переменную score
3) после окончания игры предложить начать заново
(сброс bricks, координат мяча и ракетки)
3') новое окно: 2 кнопки - restart, exit
4) нарисовать красную точку (мб) в центре ракетки и мяча
5) фон
***********************************************/
class MainWindow;
class Game2D;
class Racket;
class Ball;
class Brick;
static const float pi = 3.14;
static std::vector<Brick> bricks;
static std::map<std::string, const int> borders = {
{"left", -50},
{"right", 510},
{"up", 0},
{"down", 425}
};
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow {
Q_OBJECT
public:
explicit MainWindow(QWidget* = nullptr);
~MainWindow();
protected:
void keyPressEvent(QKeyEvent*);
void keyReleaseEvent(QKeyEvent*);
private:
Ui::MainWindow* ui;
Racket* racket;
};
class Game2D: public QObject {
Q_OBJECT
public:
Game2D() = default;
~Game2D() = default;
protected:
float x, y;
int height, width;
// чисто виртуальные ф-ии
virtual inline void move(void) = 0;
virtual inline std::pair<float, float> center(void) = 0;
};
class Racket: virtual public Game2D {
friend class MainWindow;
friend class Ball;
public:
explicit Racket(float = 0, float = 0);
~Racket() = default;
void move();
std::pair<float, float> center(void);
friend void Racket_Tick(Racket&, Ui::MainWindow*);
private:
static const int height = 80;
static const int width = 120;
float step_x, step_y;
};
class Ball: virtual public Game2D {
public:
explicit Ball(float = 0, float = 0);
~Ball() = default;
void move();
std::pair<float, float> center();
friend void norm_angle(Ball&);
friend void right_reflection(Ball&);
friend void top_reflection(Ball&, int);
friend void Ball_Tick(Ball&, Ui::MainWindow*);
friend void fly_to_end(Ball&, Ui::MainWindow*);
friend void find_and_heat_block(Ball&, Ui::MainWindow*);
friend void racket_reflection(Ball&, Racket&);
friend bool is_racket_heat(Ball&, Racket&);
friend float get_angle(Ball&, Racket&);
friend void ball_to_right(Ball&, Racket&, Ui::MainWindow*);
friend void ball_to_left(Ball&, Racket&, Ui::MainWindow*);
friend void game_init(Ball&, Racket&, Ui::MainWindow*);
private:
static const int r = 25;
static const int damage = 10;
float phi;
/************************
public slots:
void process(Ui::MainWindow*);
signals:
void finished();
//void my_start(Ui::MainWindow*);
//void error(QString err);
************************/
};
class Brick {
public:
static const int height = 40;
static const int width = 80;
int x, y, hp;
bool is_alive;
Brick(int _x = 0, int _y = 0):
x(_x), y(_y), hp(20), is_alive(true) {}
~Brick() = default;
};
void build_wall(Ui::MainWindow*);
inline void destroy_brick_1(Ui::MainWindow*);
inline void destroy_brick_2(Ui::MainWindow*);
inline void destroy_brick_3(Ui::MainWindow*);
inline void destroy_brick_4(Ui::MainWindow*);
inline void destroy_brick_5(Ui::MainWindow*);
inline float to_deg(float);
inline float to_rad(float);
[[noreturn]] void end_of_game(Ui::MainWindow*);
/***************************
class T_Cl: public QObject {
Q_OBJECT
public:
T_Cl(QString _name): name(_name) {}
~T_Cl() = default;
void run_fun(int);
void run();
public slots:
void process();
signals:
void finished();
void errorString(QString);
private:
QString name;
};
void T_Cl::process() {
qDebug() << "Hi";
for (int i = 0; i < 100; i++)
this->run_fun(i);
emit finished();
}
void T_Cl::run_fun(int num) {
qDebug() << this->name << "\tnum: " << num;
//this->thread()->msleep(10);
}
******************************/
| [
"59603419+progstorage@users.noreply.github.com"
] | 59603419+progstorage@users.noreply.github.com |
b131a7e142a40e033ab28d869f0864aaf862315d | 00c801555acd14c9e620242d4f177d5fe406fc01 | /Baekjoon/11729_하노이 탑 이동 순서.cpp | 6a2d35e9afad5cd51e6cfaee6090f257143be42f | [] | no_license | moray0211/Algoritm-practice | bd4fb9869cf62a817ab3dd29d396a416c78a5fb6 | ff3cdf51ac33c1b54437bc5f8d122dbcb25b2bbd | refs/heads/master | 2021-03-17T05:54:57.275788 | 2021-03-09T04:58:10 | 2021-03-09T04:58:10 | 246,968,028 | 1 | 0 | null | null | null | null | UHC | C++ | false | false | 728 | cpp | #include <cstdio>
#include <vector>
#include <utility>
using namespace std;
int N; //장대에 쌓인 원판의 갯수
int num = 0;
vector <pair<int, int>> result;
void hanoi(int n, int from, int by, int to) {
if (n == 1) {
result.push_back(make_pair(from, to));
num++;
}
else {
/*
현재 탑을 1->3->2 로 옮긴 뒤,
맨 마지막 칸이 3으로 옮겨지면
다시 2->1->3으로 옮겨서 완성시킨다.
*/
hanoi(n - 1, from, to, by);
result.push_back(make_pair(from, to));
num++;
hanoi(n - 1, by, from, to);
}
}
int main() {
scanf("%d", &N);
hanoi(N, 1, 2, 3);
printf("%d\n", num);
for (int i = 0; i < result.size(); i++) {
printf("%d %d\n", result[i].first, result[i].second);
}
} | [
"moray0211@users.noreply.github.com"
] | moray0211@users.noreply.github.com |
1701a146cf1f344306353835c219b74182ce9246 | 1a3fd15e9be7cf0ca6f0895e240f318043414da7 | /groups/1506-3/buntova_kv/1-test-version/before_code.cpp | e32a702e21809984f7d408ce7c9dd3a3107b1766 | [] | no_license | alvls/parprog-2018-1 | 09e2ea3d502165cdc6b9e1d50d4e17ab51b92628 | 293c76b89373669288b7cb454f32e3a7838f4758 | refs/heads/master | 2021-04-28T07:19:33.028962 | 2018-07-05T06:29:28 | 2018-07-05T06:29:28 | 122,221,726 | 0 | 52 | null | 2018-07-05T06:29:29 | 2018-02-20T16:09:14 | C++ | UTF-8 | C++ | false | false | 1,148 | cpp | //#include "Sol.cpp"
#include <iostream>
#include <cstdio>
#include <omp.h>
using namespace std;
//1-ln, 2-cos, 3-sin ,4-exp, 5-x^2, 6-x^3, 7-x^4, 8-x^5, 9-x^6, 10-x^1/2, 11-x^1/3, 12-x^1/4
double solver(double* a, double *b, int* f, int* z, int n, int kol);
double func(double* x, int *c, int *z, int k);
FILE *stream;
int main()
{
int n = 3;
char er = 'e';
freopen_s(&stream, "20", "rb", stdin);
fread(&n, sizeof(n), 1, stdin);
double *a = new double[n];
double *b = new double[n];
int *c = new int[n];
int *z = new int[n];
fread(c, sizeof(*c), n, stdin);
fread(z, sizeof(*z), n, stdin);
fread(a, sizeof(*a), n, stdin);
fread(b, sizeof(*b), n, stdin);
fclose(stream);
double time_ser = omp_get_wtime();
double res_ser = solver(a, b, c, z, 50, n);
time_ser = omp_get_wtime() - time_ser;
freopen_s(&stream, "20.ans", "wb", stdout);
fwrite(&time_ser, sizeof(time_ser), 1, stdout);
fwrite(&res_ser, sizeof(res_ser), 1, stdout);
if (res_ser == 1000000)
{
fwrite(&er, sizeof(char), 1, stdout);
}
fclose(stream);
delete[]a;
delete[]b;
delete[]c;
delete[]z;
return 0;
} | [
"axi.tenebris@gmail.com"
] | axi.tenebris@gmail.com |
698c635566db41b71a104875510e309572c09a50 | a95aa367c778034a8b8dc39f69e2cb11f6e15acc | /Codeforces/714-B.cpp | c67966619c35af1dd1876770db6896b0f3d18933 | [] | no_license | misaelmateus/problem-solving | 6d16ff88a82fb366b331870d0f956dbdfc09ee6c | 8ed9faf0b3828bfc689864abeea9d7599ee63b9e | refs/heads/master | 2020-07-01T12:21:16.914099 | 2018-11-05T10:33:08 | 2018-11-05T10:33:08 | 74,079,745 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 700 | cpp | // Author : Misael Mateus
// Submission date: 2016-09-13 22:32:13
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
scanf("%d", &n);
set<int> v;
for(int i = 0; i < n; i++){
int aux;
scanf("%d", &aux);
v.insert(aux);
}
if(v.size() > 3)
{
printf("NO\n");
return 0;
}
set<int>::iterator it = v.begin();
if(v.size() <= 2)
printf("YES\n");
else{
int a = *it;
it++;
int b = *it;
it++;
int c = *it;
if(c - b == b - a)
printf("YES\n");
else
printf("NO\n");
}
return 0;
} | [
"misaelmateus12@gmail.com"
] | misaelmateus12@gmail.com |
306494a1e963956b063fce22aee944c259b8cbc2 | ca484115ba9556b5a85f1b8b898ecabe42d96840 | /ReferenceElement.cpp | efcaaf649627371dc41d1605d372f15b13cf7689 | [] | no_license | htphuc/dg1d-cpp-waveequation | 1b9d7e12984feb48aed2346c71edf61c97a477bd | d6659aed5d7a131ac92b8c5d17594fa0e0df1121 | refs/heads/master | 2021-01-22T16:45:27.752024 | 2016-01-26T16:19:54 | 2016-01-26T16:19:54 | 54,572,581 | 0 | 1 | null | 2016-03-23T15:48:22 | 2016-03-23T15:48:21 | null | UTF-8 | C++ | false | false | 8,762 | cpp | #include "ReferenceElement.h"
#include <iostream>
//The reference element has quite a number of subroutines, but there are only
//two outputs that ultimately matter: the derivative matrix and the
//lift matrix. The lift matrix is used to calculate the numerical flux.
//The derivative matrix is used to calculate the right hand side of the
//differential equation. Both are used in the Grid::RHS routine.
using namespace TNT;
ReferenceElement::ReferenceElement(int N):
refNodeLocations(N+1),
vandermondeMatrix(N+1,N+1),
dVdr(N+1,N+1),
derivativeMatrix(N+1,N+1),
lift(N+1,2,0.0),
refNodeWeights(N+1)
{
order=N; //element order
//set the node locations in the reference element
refNodeLocations=jacobiGL(0.0,0.0,N);
// cout<< refNodeLocations[0]-refNodeLocations[1] << endl;
//set the weights associated with integration over the nodes
//of the reference element
refNodeWeights=gaussWeights(0.0,0.0,N);
//calculate the Vandermonde matrix
vandermonde1D();
/* for(int nn=0; nn< order+1; nn++){
for(int nodenum=0; nodenum < order+1; nodenum++){
cout << setprecision(15);
cout << nodenum << " " << vandermondeMatrix[nodenum][nn] << endl;
}
}*/
//calculate the gradient of the Vandermonde matrix
gradVandermonde1D();
/* for(int nn=0; nn< order+1; nn++){
for(int nodenum=0; nodenum < order+1; nodenum++){
cout << setprecision(15);
cout << nodenum << " " << dVdr[nodenum][nn] << endl;
}
}*/
//calculate the derivative matrix
Dmatrix1D();
/* for(int nn=0; nn<order+1; nn++){
for(int nodenum=0; nodenum<order+1; nodenum++){
cout << setprecision(15);
cout << nodenum << " " << derivativeMatrix[nodenum][nn] << endl;
}
}*/
//construct the lift matrix for use in the calculation of the flux
lift1D();
}
void ReferenceElement::jacobiGQ(Array1D<double>& x, double alpha,
double beta, int n, Array1D<double>& w)
{ //Computes nth order Gaussian quadrature points (x) and weights (w)
//associated with the Jacobi polynomial of the type (alpha,beta)>-1.
//See Hesthaven and Warburton pg 447
if((w.dim() != n + 1) || x.dim() != n + 1) {
throw std::invalid_argument("JacobiGQ: Array1D argument dimensions do not agree with argument order n.\n");
}
Array1D<double> h1(n+1);
Array1D<double> jdiag1(n+1);
Array1D<double> idouble(n+1);
Array1D<double> jdiag2(n);
Array1D<double> d1(n);
Array1D<double> d2(n);
Array1D<double> d3(n);
Array2D<double> vect(n+1,n+1); //contains eigenvectors
double lngammaab, lngammaa, lngammab;
if (n==0) {
x[0] = (alpha - beta) / (alpha + beta + 2.0);
w[0] = 2.0;
return;
}
for(int i = 0; i <= n; i++) {
idouble[i] = i * 1.0;
}
h1 = 2.0 * idouble + alpha + beta;
for(int i = 0; i <= n; i++){
if(h1[i] > 0.0) {
jdiag1[i] = -(pow(alpha, 2.0) - pow(beta, 2.0))
/ (h1[i] * (h1[i] + 2.0));
} else {
jdiag1[i]=0.0;
}
}
for(int i = 0; i < n; i++) {
d1[i] = 2.0 / (h1[i] + 2.0);
d2[i] = idouble[i + 1] * (idouble[i + 1] + alpha + beta)
* (idouble[i + 1] + alpha) * (idouble[i + 1] + beta);
d3[i] = 1.0 / ((h1[i] + 1.0) * (h1[i] + 3.0));
}
jdiag2 = d1 * sqrt(d2 * d3);
//tridiagonal matrix has jdiag1 along the diagonal and
//jdiag2 to either side, zeros elsewhere
Array2D<double> tridiag(n+1,n+1,0.0);
for(int i = 0; i <= n; i++) {
for(int j = 0; j <= n; j++) {
if(i==j) {
tridiag[i][j]=jdiag1[i];
} else if(abs(i - j) == 1) {
tridiag[i][j]=jdiag2[std::min(i,j)];
}
}
}
//vect holds eigenvectors, jdiag1 holds eigenvalues
JAMA::Eigenvalue<double> eigen(tridiag);
eigen.getRealEigenvalues(x);
eigen.getV(vect);
lngammaab = lgamma(alpha + beta + 1.0);
lngammaa = lgamma(alpha + 1.0);
lngammab = lgamma(beta + 1.0);
for(int i = 0; i <= n; i++) {
w[i] = pow(vect[0][i], 2.0)*pow(2.0, (alpha + beta + 1.0))
/ (alpha + beta + 1.0) * exp(lngammaa + lngammab - lngammaab);
}
}
Array1D<double> ReferenceElement::jacobiGL(double alpha, double beta, double n)
{
//sets Jacobi-Gauss-Lebato quadrature points
//see page 448 Hesthaven and Warburton
Array1D<double> quadpts(n+1,0.0);
Array1D<double> w(n-1); //weights
Array1D<double> x(n-1); //JacobiGQ input and output
if(n<=0)
throw std::invalid_argument("JacobiGL called with n<=0. Aborting");
if(n==1){
quadpts[0] = -1.0;
quadpts[1] = 1.0;
} else {
jacobiGQ(x, alpha + 1.0, beta + 1.0, n - 2, w);
insert_1D(quadpts, x, 1);
quadpts[0] = -1.0;
quadpts[n] = 1.0;
}
return quadpts;
}
Array1D<double> ReferenceElement::gaussWeights(double alpha, double beta,
int n)
{//adjusts the gaussian quadrature weights to the
//Jacobi-Gauss-Lebato quadrature points
Array1D<double> jacP(n+1);
Array1D<double> x(n+1);
x=refNodeLocations.copy();
Array1D<double> w(n+1);
jacP=jacobiP(x, alpha, beta, n);
for(int i = 0; i < x.dim(); i++){
w[i] = (2.0 * n + 1.) / (n * (n + 1.)) / pow(jacP[i], 2.0);
}
return w;
}
Array1D<double> ReferenceElement::jacobiP(const Array1D<double>& x,
double alpha,
double beta, int n)
//Evaluate Jacobi Polynomial of type (alpha,beta) at points x for order N
{
Array1D<double> polynom(x.dim());
vector<Array1D<double>> pl;
double lngammaab = lgamma(alpha + beta + 1.0);
double lngammaa = lgamma(alpha + 1.0);
double lngammab = lgamma(beta + 1.0);
pl.resize(n + 1);
double invsqgamma0 = pow(2.0, alpha + beta + 1.0) / (alpha + beta + 1.0)
* exp(lngammaa + lngammab - lngammaab);
double gamma0 = 1.0 / sqrt(invsqgamma0);
Array1D<double> gamma0arr(x.dim(), gamma0);
if (n==0) {
polynom = gamma0arr;
return polynom;
}
pl[0] = gamma0arr;
double gamma1 = 0.5 * sqrt((alpha + beta + 3.0)
/ ((alpha + 1.0) * (beta + 1.0))) * gamma0;
double fac1 = (alpha + beta + 2.0);
double fac2 = (alpha - beta);
Array1D<double> gamma1arr= gamma1 * (fac1 * x + fac2);
if (n==1){
polynom= gamma1arr;
return polynom;
}
pl[1]=gamma1arr;
double aold = 2.0 / (2.0 + alpha + beta)
*sqrt((1.0 + alpha) * (1.0 + beta) / (3.0 + alpha + beta));
for(int i=0;i<=n-2;i++) {
double idouble= double(i) + 1.0;
double idoublep1=idouble + 1.0;
double h1 = 2.0 * idouble + alpha + beta;
double anew = 2.0 / (h1 + 2.0)
* sqrt(idoublep1 * (idoublep1 + alpha + beta)
* (idoublep1 + alpha) * (idoublep1 + beta)
/ (h1 + 1.0) / (h1 + 3.0));
double bnew = -(alpha * alpha - beta * beta) / (h1 * (h1 + 2.0));
pl[i + 2] = 1.0 / anew * (-aold * pl[i] + (x - bnew) * pl[i + 1]);
aold = anew;
}
polynom= pl[n];
return polynom;
}
void ReferenceElement::vandermonde1D()
{//Calculates Vandermonde matrix. See page 51 of Hesthaven and Warburton.
for(int j = 0; j <= order; j++) {
insert_1D_into_2D(vandermondeMatrix,
jacobiP(refNodeLocations, 0.0, 0.0, j),
j, true);
}
}
Array1D<double> ReferenceElement::gradJacobiP(double alpha, double beta,int N)
//Evaluates the derivative of the Jacobi polynomials of type alpha, beta >-1
//at the nodes for order N.
{
if ((alpha < -1) || (beta < -1)) throw std::invalid_argument("alpha or beta <-1 in gradJacobiP.");
if (N < 0) throw std::invalid_argument("N<0 in gradJacobiP");
Array1D<double> gradpoly(refNodeLocations.dim(), 0.0);
if (N != 0) {
gradpoly = sqrt(N * (N + alpha + beta + 1.))
* jacobiP(refNodeLocations, alpha + 1.0, beta + 1.0, N - 1);
}
/* for(int nodenum=0; nodenum<order+1; nodenum++){
cout << setprecision(15);
cout << nodenum << " " << refNodeLocations[nodenum] << " " << gradpoly[nodenum] << endl;
}*/
return gradpoly;
}
void ReferenceElement::gradVandermonde1D()
{//Calculates the derivative of the Vandermonde matrix as a step toward
//calculating the derivative matrix.
for(int i = 0; i <= order; i++) {
insert_1D_into_2D(dVdr, gradJacobiP(0.0, 0.0, i), i, true);
}
return;
}
void ReferenceElement::Dmatrix1D()
{//Calculates the derivative matrix.
Array2D<double> VT = transpose(vandermondeMatrix);
JAMA::LU<double> solver(VT);
Array2D<double> dVdrT = transpose(dVdr);
Array2D<double> DT = solver.solve(dVdrT);
derivativeMatrix = transpose(DT);
}
void ReferenceElement::lift1D()
{//Calculates the lift matrix.
Array2D<double> emat(order + 1, 2, 0.0);
emat[0][0] = 1.0;
emat[order][1] = 1.0;
lift=matmult(vandermondeMatrix, matmult(transpose(vandermondeMatrix), emat));
}
| [
"sdorsh1@lsu.edu"
] | sdorsh1@lsu.edu |
4b0692d181c5182b53cb1a8bac93e612e62cf03d | 14f2b614e2dd00f982cd6071f673c506dbd39ed7 | /190. Reverse Bits.cpp | def4591988cd72a6e631651250d5d5293731367d | [] | no_license | shownlin/leetcode | cba9aa8533113a4fdaa75e5729679a7c77f29af9 | afdd231703ccb04d95f87c001c752e0a51230809 | refs/heads/master | 2021-06-25T06:12:09.591504 | 2020-11-16T19:49:22 | 2020-11-16T19:49:22 | 166,754,611 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 537 | cpp | #include <iostream>
#include <vector>
using namespace std;
class Solution
{
public:
uint32_t reverseBits(uint32_t n)
{
uint32_t res = 0u;
for (int i = 0; i < 32; ++i)
{
res = (res << 1) | (n & 1);
n >>= 1;
}
return res;
}
};
int main()
{
Solution sol;
vector<pair<uint32_t, uint32_t>> q{{43261596u, 964176192u}, {4294967293u, 3221225471u}};
for(auto e:q)
{
cout << (e.second == sol.reverseBits(e.first)) << endl;
}
return 0;
} | [
"shownlin001cm@gmail.com"
] | shownlin001cm@gmail.com |
f08d9d10541c4bf806575a30ca8ae3a93245e823 | 6b50e35b60a7972ff3c3ac60a1d928b43591901c | /SignalProcessing/LDA_Truong_Tung/jni/kernel/src/kernel/ovkCKernelContext.cpp | 47d7a5f38105fbc3506b4cd5a1b510ac5c145bdf | [] | no_license | damvanhuong/eeglab411 | 4a384fe06a3f5a9767c4dc222d9946640b168875 | 0aca0e64cd8e90dcde7dd021078fa14b2d61f0c9 | refs/heads/master | 2020-12-28T20:19:50.682128 | 2015-05-06T10:36:07 | 2015-05-06T10:36:07 | 35,154,165 | 1 | 0 | null | 2015-05-06T10:48:11 | 2015-05-06T10:48:10 | null | UTF-8 | C++ | false | false | 18,318 | cpp | #include "ovkCKernelContext.h"
#include "ovkCKernelObjectFactory.h"
#include "ovkCTypeManager.h"
#include "algorithm/ovkCAlgorithmManager.h"
#include "configuration/ovkCConfigurationManager.h"
#include "player/ovkCPlayerManager.h"
#include "plugins/ovkCPluginManager.h"
#include "scenario/ovkCScenarioManager.h"
#include "log/ovkCLogManager.h"
#include "log/ovkCLogListenerConsole.h"
#include "log/ovkCLogListenerFile.h"
#include "visualisation/ovkCVisualisationManager.h"
#include <string>
#include <algorithm>
#include <functional>
#include <cctype>
#include <fs/Files.h>
using namespace OpenViBE;
using namespace OpenViBE::Kernel;
namespace
{
// because std::tolower has multiple signatures,
// it can not be easily used in std::transform
// this workaround is taken from http://www.gcek.net/ref/books/sw/cpp/ticppv2/
template <class charT>
charT to_lower(charT c)
{
return std::tolower(c);
}
};
#if defined TARGET_OS_Linux
#include <signal.h>
static void _openvibeKernelSignalHandler_(int iSignal)
{
throw;
}
#endif
namespace OpenViBE
{
namespace Kernel
{
namespace
{
class CLogManagerNULL : public OpenViBE::Kernel::ILogManager
{
public:
virtual OpenViBE::boolean isActive(OpenViBE::Kernel::ELogLevel eLogLevel) { return false; }
virtual OpenViBE::boolean activate(OpenViBE::Kernel::ELogLevel eLogLevel, OpenViBE::boolean bActive) { return false; }
virtual OpenViBE::boolean activate(OpenViBE::Kernel::ELogLevel eStartLogLevel, OpenViBE::Kernel::ELogLevel eEndLogLevel, OpenViBE::boolean bActive) { return false; }
virtual OpenViBE::boolean activate(OpenViBE::boolean bActive) { return false; }
virtual void log(const OpenViBE::time64 time64Value) { }
virtual void log(const OpenViBE::uint64 ui64Value) { }
virtual void log(const OpenViBE::uint32 ui32Value) { }
virtual void log(const OpenViBE::uint16 ui16Value) { }
virtual void log(const OpenViBE::uint8 ui8Value) { }
virtual void log(const OpenViBE::int64 i64Value) { }
virtual void log(const OpenViBE::int32 i32Value) { }
virtual void log(const OpenViBE::int16 i16Value) { }
virtual void log(const OpenViBE::int8 i8Value) { }
virtual void log(const OpenViBE::float64 f64Value) { }
virtual void log(const OpenViBE::float32 f32Value) { }
virtual void log(const OpenViBE::boolean bValue) { }
virtual void log(const OpenViBE::CIdentifier& rValue) { }
virtual void log(const OpenViBE::CString& rValue) { }
virtual void log(const char* pValue) { }
virtual void log(const OpenViBE::Kernel::ELogLevel eLogLevel) { }
virtual void log(const OpenViBE::Kernel::ELogColor eLogColor) { }
virtual OpenViBE::boolean addListener(OpenViBE::Kernel::ILogListener* pListener) { return false; }
virtual OpenViBE::boolean removeListener(OpenViBE::Kernel::ILogListener* pListener) { return false; }
//_IsDerivedFromClass_Final_(OpenViBE::Kernel::ILogManager, OV_UndefinedIdentifier);
};
};
};
};
CKernelContext::CKernelContext(const IKernelContext* pMasterKernelContext, const CString& rApplicationName, const CString& rConfigurationFile)
:m_rMasterKernelContext(pMasterKernelContext?*pMasterKernelContext:*this)
,m_pThis(this)
,m_pAlgorithmManager(NULL)
,m_pConfigurationManager(NULL)
,m_pKernelObjectFactory(NULL)
,m_pPlayerManager(NULL)
,m_pPluginManager(NULL)
,m_pScenarioManager(NULL)
,m_pTypeManager(NULL)
,m_pLogManager(NULL)
,m_pVisualisationManager(NULL)
,m_bIsInitialized(false)
,m_sApplicationName(rApplicationName)
,m_sConfigurationFile(rConfigurationFile)
,m_pLogListenerConsole(NULL)
,m_pLogListenerFile(NULL)
{
#if defined TARGET_OS_Linux
signal(SIGILL, _openvibeKernelSignalHandler_); // Illegal instruction
signal(SIGFPE, _openvibeKernelSignalHandler_); // Floadint point exception
signal(SIGSEGV, _openvibeKernelSignalHandler_); // Invalid memory reference
signal(SIGPIPE, _openvibeKernelSignalHandler_); // Broken pipe: write to pipe with no readers
signal(SIGBUS, _openvibeKernelSignalHandler_); // Bus error (bad memory access)
signal(SIGSYS, _openvibeKernelSignalHandler_); // Bad argument to routine (SVID)
signal(SIGTRAP, _openvibeKernelSignalHandler_); // Trace/breakpoint trap
#endif
}
CKernelContext::~CKernelContext(void)
{
if(m_bIsInitialized)
{
this->uninitialize();
}
}
boolean CKernelContext::initialize(void)
{
if(m_bIsInitialized)
{
return true;
}
m_bIsInitialized=true;
m_pKernelObjectFactory=new CKernelObjectFactory(m_rMasterKernelContext);
this->getLogManager() << LogLevel_Trace << "Creating log manager\n";
m_pLogManager=new CLogManager(m_rMasterKernelContext);
m_pLogManager->activate(true);
this->getLogManager() << LogLevel_Trace << "Creating and configuring file log listener\n";
// FS::Files::createPath(OpenViBE::Directories::getLogDir().toASCIIString());
//m_pLogListenerFile=new CLogListenerFile(m_rMasterKernelContext, m_sApplicationName, OpenViBE::Directories::getLogDir() + "/openvibe-"+m_sApplicationName+".log");
m_pLogListenerFile->activate(true);
this->getLogManager().addListener(m_pLogListenerFile);
this->getLogManager() << LogLevel_Trace << "Creating and configuring console log listener\n";
m_pLogListenerConsole=new CLogListenerConsole(m_rMasterKernelContext, m_sApplicationName);
m_pLogListenerConsole->activate(false);
m_pLogListenerConsole->activate(LogLevel_Info, LogLevel_Last, true);
this->getLogManager().addListener(m_pLogListenerConsole);
this->getLogManager() << LogLevel_Trace << "Creating configuration manager\n";
m_pConfigurationManager=new CConfigurationManager(m_rMasterKernelContext);
#if defined TARGET_BUILDTYPE_Release
m_pConfigurationManager->createConfigurationToken("BuildType", "Release");
#elif defined TARGET_BUILDTYPE_Debug
m_pConfigurationManager->createConfigurationToken("BuildType", "Debug");
#else
m_pConfigurationManager->createConfigurationToken("BuildType", "Unknown");
#endif
#if defined TARGET_OS_Windows
m_pConfigurationManager->createConfigurationToken("OperatingSystem", "Windows");
#elif defined TARGET_OS_Linux
m_pConfigurationManager->createConfigurationToken("OperatingSystem", "Linux");
#else
m_pConfigurationManager->createConfigurationToken("OperatingSystem", "Unknown");
#endif
//m_pConfigurationManager->createConfigurationToken("UserHome", OpenViBE::Directories::getUserHomeDir());
//m_pConfigurationManager->createConfigurationToken("Path_UserData", OpenViBE::Directories::getUserDataDir());
m_pConfigurationManager->createConfigurationToken("ApplicationName", m_sApplicationName);
//m_pConfigurationManager->createConfigurationToken("Path_Root", OpenViBE::Directories::getDistRootDir());
//m_pConfigurationManager->createConfigurationToken("Path_Bin", OpenViBE::Directories::getBinDir());
//m_pConfigurationManager->createConfigurationToken("Path_Data", OpenViBE::Directories::getDataDir());
//m_pConfigurationManager->createConfigurationToken("Path_Lib", OpenViBE::Directories::getLibDir());
//m_pConfigurationManager->createConfigurationToken("Path_Log", OpenViBE::Directories::getLogDir());
m_pConfigurationManager->createConfigurationToken("Path_Tmp", "${Path_UserData}/tmp");
m_pConfigurationManager->createConfigurationToken("Path_Samples", "${Path_Data}/scenarios");
m_pConfigurationManager->createConfigurationToken("Kernel_PluginsPatternLinux", "libopenvibe-plugins-*.so");
m_pConfigurationManager->createConfigurationToken("Kernel_PluginsPatternWindows", "openvibe-plugins-*.dll");
m_pConfigurationManager->createConfigurationToken("Kernel_Plugins", "${Path_Lib}/${Kernel_PluginsPattern${OperatingSystem}}");
m_pConfigurationManager->createConfigurationToken("Kernel_MainLogLevel", "Debug");
m_pConfigurationManager->createConfigurationToken("Kernel_ConsoleLogLevel", "Information");
m_pConfigurationManager->createConfigurationToken("Kernel_FileLogLevel", "Debug");
m_pConfigurationManager->createConfigurationToken("Kernel_PlayerFrequency", "128");
this->getLogManager() << LogLevel_Info << "Adding kernel configuration file [" << m_sConfigurationFile << "]\n";
if(!m_pConfigurationManager->addConfigurationFromFile(m_sConfigurationFile)) {
this->getLogManager() << LogLevel_Error << "Problem parsing '" << m_sConfigurationFile << "'. This will not work.\n";
// Since OpenViBE components usually don't react to return value of initialize(), we just quit here
this->getLogManager() << LogLevel_Error << "Forcing an exit.\n";
exit(-1);
}
// Generate the openvibe directories that the applications may write to. These are done after addConfigurationFromFile(), in case the defaults have been modified.
// @FIXME note that there is an issue if these paths are changed by a delayed configuration, then the directories are not created unless the caller does it.
CString l_sPathTmp;
l_sPathTmp = m_pConfigurationManager->expand("${Path_UserData}");
FS::Files::createPath(l_sPathTmp.toASCIIString());
l_sPathTmp = m_pConfigurationManager->expand("${Path_Tmp}");
FS::Files::createPath(l_sPathTmp.toASCIIString());
l_sPathTmp = m_pConfigurationManager->expand("${Path_Log}");
FS::Files::createPath(l_sPathTmp.toASCIIString());
l_sPathTmp = m_pConfigurationManager->expand("${CustomConfiguration}");
FS::Files::createParentPath(l_sPathTmp.toASCIIString());
l_sPathTmp = m_pConfigurationManager->expand("${CustomConfigurationApplication}");
FS::Files::createParentPath(l_sPathTmp.toASCIIString());
ELogLevel l_eMainLogLevel =this->earlyGetLogLevel(m_pConfigurationManager->expand("${Kernel_MainLogLevel}"));
ELogLevel l_eConsoleLogLevel=this->earlyGetLogLevel(m_pConfigurationManager->expand("${Kernel_ConsoleLogLevel}"));
ELogLevel l_eFileLogLevel =this->earlyGetLogLevel(m_pConfigurationManager->expand("${Kernel_FileLogLevel}"));
m_pLogManager->activate(false);
m_pLogManager->activate(l_eMainLogLevel, LogLevel_Last, true);
m_pLogListenerFile->activate(false);
m_pLogListenerFile->activate(l_eFileLogLevel, LogLevel_Last, true);
m_pLogListenerFile->configure(*m_pConfigurationManager);
m_pLogListenerConsole->activate(false);
m_pLogListenerConsole->activate(l_eConsoleLogLevel, LogLevel_Last, true);
m_pLogListenerFile->configure(*m_pConfigurationManager);
m_pLogListenerConsole->configure(*m_pConfigurationManager);
this->getLogManager() << LogLevel_Trace << "Creating algorithm manager\n";
m_pAlgorithmManager=new CAlgorithmManager(m_rMasterKernelContext);
this->getLogManager() << LogLevel_Trace << "Creating player manager\n";
m_pPlayerManager=new CPlayerManager(m_rMasterKernelContext);
this->getLogManager() << LogLevel_Trace << "Creating and configuring type manager\n";
m_pTypeManager=new CTypeManager(m_rMasterKernelContext);
m_pTypeManager->registerType(OV_TypeId_Boolean, "Boolean");
m_pTypeManager->registerType(OV_TypeId_Integer, "Integer");
m_pTypeManager->registerType(OV_TypeId_Float, "Float");
m_pTypeManager->registerType(OV_TypeId_String, "String");
m_pTypeManager->registerType(OV_TypeId_Filename, "Filename");
m_pTypeManager->registerType(OV_TypeId_Script, "Script");
m_pTypeManager->registerType(OV_TypeId_Color, "Color");
m_pTypeManager->registerType(OV_TypeId_ColorGradient, "Color Gradient");
m_pTypeManager->registerEnumerationType(OV_TypeId_Stimulation, "Stimulation");
m_pTypeManager->registerEnumerationType(OV_TypeId_LogLevel, "Log level");
m_pTypeManager->registerEnumerationEntry(OV_TypeId_LogLevel, "None", LogLevel_None);
m_pTypeManager->registerEnumerationEntry(OV_TypeId_LogLevel, "Debug", LogLevel_Debug);
m_pTypeManager->registerEnumerationEntry(OV_TypeId_LogLevel, "Benchmarking / Profiling", LogLevel_Benchmark);
m_pTypeManager->registerEnumerationEntry(OV_TypeId_LogLevel, "Trace", LogLevel_Trace);
m_pTypeManager->registerEnumerationEntry(OV_TypeId_LogLevel, "Information", LogLevel_Info);
m_pTypeManager->registerEnumerationEntry(OV_TypeId_LogLevel, "Warning", LogLevel_Warning);
m_pTypeManager->registerEnumerationEntry(OV_TypeId_LogLevel, "Important warning", LogLevel_ImportantWarning);
m_pTypeManager->registerEnumerationEntry(OV_TypeId_LogLevel, "Error", LogLevel_Error);
m_pTypeManager->registerEnumerationEntry(OV_TypeId_LogLevel, "Fatal error", LogLevel_Fatal);
m_pTypeManager->registerStreamType(OV_TypeId_EBMLStream, "EBML stream", OV_UndefinedIdentifier);
m_pTypeManager->registerStreamType( OV_TypeId_ExperimentInformation, "Experiment information", OV_TypeId_EBMLStream);
m_pTypeManager->registerStreamType( OV_TypeId_Stimulations, "Stimulations", OV_TypeId_EBMLStream);
m_pTypeManager->registerStreamType( OV_TypeId_StreamedMatrix, "Streamed matrix", OV_TypeId_EBMLStream);
m_pTypeManager->registerStreamType( OV_TypeId_ChannelLocalisation, "Channel localisation", OV_TypeId_StreamedMatrix);
m_pTypeManager->registerStreamType( OV_TypeId_FeatureVector, "Feature vector", OV_TypeId_StreamedMatrix);
m_pTypeManager->registerStreamType( OV_TypeId_Signal, "Signal", OV_TypeId_StreamedMatrix);
m_pTypeManager->registerStreamType( OV_TypeId_Spectrum, "Spectrum", OV_TypeId_StreamedMatrix);
m_pTypeManager->registerType(OV_TypeId_Message, "Message");
this->getLogManager() << LogLevel_Trace << "Creating scenario manager\n";
m_pScenarioManager=new CScenarioManager(m_rMasterKernelContext);
this->getLogManager() << LogLevel_Trace << "Creating visualisation manager\n";
m_pVisualisationManager=new CVisualisationManager(m_rMasterKernelContext);
this->getLogManager() << LogLevel_Trace << "Creating plugin manager\n";
m_pPluginManager=new CPluginManager(m_rMasterKernelContext);
return true;
}
boolean CKernelContext::uninitialize(void)
{
if(!m_bIsInitialized)
{
return true;
}
this->getLogManager() << LogLevel_Trace << "Releasing plugin manager\n";
delete m_pPluginManager;
m_pPluginManager=NULL;
this->getLogManager() << LogLevel_Trace << "Releasing visualisation manager\n";
delete m_pVisualisationManager;
m_pVisualisationManager=NULL;
this->getLogManager() << LogLevel_Trace << "Releasing scenario manager\n";
delete m_pScenarioManager;
m_pScenarioManager=NULL;
this->getLogManager() << LogLevel_Trace << "Releasing type manager\n";
delete m_pTypeManager;
m_pTypeManager=NULL;
this->getLogManager() << LogLevel_Trace << "Releasing player manager\n";
delete m_pPlayerManager;
m_pPlayerManager=NULL;
this->getLogManager() << LogLevel_Trace << "Releasing algorithm manager\n";
delete m_pAlgorithmManager;
m_pAlgorithmManager=NULL;
this->getLogManager() << LogLevel_Trace << "Releasing configuration manager\n";
delete m_pConfigurationManager;
m_pConfigurationManager=NULL;
this->getLogManager() << LogLevel_Trace << "Detaching log console listener\n";
this->getLogManager().removeListener(m_pLogListenerConsole);
this->getLogManager() << LogLevel_Trace << "Detaching log file listener\n";
this->getLogManager().removeListener(m_pLogListenerFile);
this->getLogManager() << LogLevel_Trace << "Releasing log manager - no more log possible with log manager !\n";
delete m_pLogManager;
m_pLogManager=NULL;
this->getLogManager() << LogLevel_Trace << "Releasing log console listener\n";
delete m_pLogListenerConsole;
m_pLogListenerConsole=NULL;
this->getLogManager() << LogLevel_Trace << "Releasing log file listener\n";
delete m_pLogListenerFile;
m_pLogListenerFile=NULL;
delete m_pKernelObjectFactory;
m_pKernelObjectFactory=NULL;
m_bIsInitialized=false;
return true;
}
IAlgorithmManager& CKernelContext::getAlgorithmManager(void) const
{
if(!m_bIsInitialized) m_pThis->initialize();
return *m_pAlgorithmManager;
}
IConfigurationManager& CKernelContext::getConfigurationManager(void) const
{
if(!m_bIsInitialized) m_pThis->initialize();
return *m_pConfigurationManager;
}
IKernelObjectFactory& CKernelContext::getKernelObjectFactory(void) const
{
if(!m_bIsInitialized) m_pThis->initialize();
return *m_pKernelObjectFactory;
}
IPlayerManager& CKernelContext::getPlayerManager(void) const
{
if(!m_bIsInitialized) m_pThis->initialize();
return *m_pPlayerManager;
}
IPluginManager& CKernelContext::getPluginManager(void) const
{
if(!m_bIsInitialized) m_pThis->initialize();
return *m_pPluginManager;
}
IScenarioManager& CKernelContext::getScenarioManager(void) const
{
if(!m_bIsInitialized) m_pThis->initialize();
return *m_pScenarioManager;
}
ITypeManager& CKernelContext::getTypeManager(void) const
{
if(!m_bIsInitialized) m_pThis->initialize();
return *m_pTypeManager;
}
/*ILogManager& CKernelContext::getLogManager(void) const
{
if(!m_bIsInitialized) m_pThis->initialize();
//static CLogManagerNULL l_oLogManagerNULL;
// return m_pLogManager?*m_pLogManager:l_oLogManagerNULL;
}*/
IVisualisationManager& CKernelContext::getVisualisationManager(void) const
{
if(!m_bIsInitialized) m_pThis->initialize();
return *m_pVisualisationManager;
}
ELogLevel CKernelContext::earlyGetLogLevel(const CString& rLogLevelName)
{
if(!m_bIsInitialized) m_pThis->initialize();
std::string l_sValue(rLogLevelName.toASCIIString());
std::transform(l_sValue.begin(), l_sValue.end(), l_sValue.begin(), ::to_lower<std::string::value_type>);
if(l_sValue=="none") return LogLevel_None;
if(l_sValue=="debug") return LogLevel_Debug;
if(l_sValue=="benchmarking / profiling") return LogLevel_Benchmark;
if(l_sValue=="trace") return LogLevel_Trace;
if(l_sValue=="information") return LogLevel_Info;
if(l_sValue=="warning") return LogLevel_Warning;
if(l_sValue=="important warning") return LogLevel_ImportantWarning;
if(l_sValue=="error") return LogLevel_Error;
if(l_sValue=="fatal error") return LogLevel_Fatal;
(*m_pLogManager) << LogLevel_Warning << "Invalid log level " << rLogLevelName << " specified in configuration file, falling back to " << CString("Debug") << "\n";
return LogLevel_Debug;
}
| [
"nguyenhaitruonghp@gmail.com"
] | nguyenhaitruonghp@gmail.com |
66fbc10c0613dc712cd39dca98d0f8e9ce78e1f5 | d0fb46aecc3b69983e7f6244331a81dff42d9595 | /linkwan/src/model/GetGatewayResult.cc | 15d8d8c42ff4661d8437bcea1282d1f6ceb53b1d | [
"Apache-2.0"
] | permissive | aliyun/aliyun-openapi-cpp-sdk | 3d8d051d44ad00753a429817dd03957614c0c66a | e862bd03c844bcb7ccaa90571bceaa2802c7f135 | refs/heads/master | 2023-08-29T11:54:00.525102 | 2023-08-29T03:32:48 | 2023-08-29T03:32:48 | 115,379,460 | 104 | 82 | NOASSERTION | 2023-09-14T06:13:33 | 2017-12-26T02:53:27 | C++ | UTF-8 | C++ | false | false | 3,598 | cc | /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/linkwan/model/GetGatewayResult.h>
#include <json/json.h>
using namespace AlibabaCloud::LinkWAN;
using namespace AlibabaCloud::LinkWAN::Model;
GetGatewayResult::GetGatewayResult() :
ServiceResult()
{}
GetGatewayResult::GetGatewayResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetGatewayResult::~GetGatewayResult()
{}
void GetGatewayResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["GwEui"].isNull())
data_.gwEui = dataNode["GwEui"].asString();
if(!dataNode["OnlineState"].isNull())
data_.onlineState = dataNode["OnlineState"].asString();
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["Description"].isNull())
data_.description = dataNode["Description"].asString();
if(!dataNode["City"].isNull())
data_.city = dataNode["City"].asString();
if(!dataNode["District"].isNull())
data_.district = dataNode["District"].asString();
if(!dataNode["Address"].isNull())
data_.address = dataNode["Address"].asString();
if(!dataNode["AddressCode"].isNull())
data_.addressCode = std::stol(dataNode["AddressCode"].asString());
if(!dataNode["GisCoordinateSystem"].isNull())
data_.gisCoordinateSystem = dataNode["GisCoordinateSystem"].asString();
if(!dataNode["Longitude"].isNull())
data_.longitude = std::stof(dataNode["Longitude"].asString());
if(!dataNode["Latitude"].isNull())
data_.latitude = std::stof(dataNode["Latitude"].asString());
if(!dataNode["FreqBandPlanGroupId"].isNull())
data_.freqBandPlanGroupId = std::stol(dataNode["FreqBandPlanGroupId"].asString());
if(!dataNode["CommunicationMode"].isNull())
data_.communicationMode = dataNode["CommunicationMode"].asString();
if(!dataNode["TimeCorrectable"].isNull())
data_.timeCorrectable = dataNode["TimeCorrectable"].asString() == "true";
if(!dataNode["ClassBSupported"].isNull())
data_.classBSupported = dataNode["ClassBSupported"].asString() == "true";
if(!dataNode["ClassBWorking"].isNull())
data_.classBWorking = dataNode["ClassBWorking"].asString() == "true";
if(!dataNode["Enabled"].isNull())
data_.enabled = dataNode["Enabled"].asString() == "true";
if(!dataNode["OnlineStateChangedMillis"].isNull())
data_.onlineStateChangedMillis = std::stol(dataNode["OnlineStateChangedMillis"].asString());
if(!dataNode["EmbeddedNsId"].isNull())
data_.embeddedNsId = dataNode["EmbeddedNsId"].asString();
if(!dataNode["ChargeStatus"].isNull())
data_.chargeStatus = dataNode["ChargeStatus"].asString();
if(!dataNode["AuthTypes"].isNull())
data_.authTypes = dataNode["AuthTypes"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
GetGatewayResult::Data GetGatewayResult::getData()const
{
return data_;
}
bool GetGatewayResult::getSuccess()const
{
return success_;
}
| [
"sdk-team@alibabacloud.com"
] | sdk-team@alibabacloud.com |
fc3bc16543a59bdcad0ed56b4c34dcd943b67425 | 002902560639e77c5c9606af0fad90ff2334db1e | /992B.cpp | 9864628898e0988d9e21daae72bfd7b609ccc294 | [] | no_license | Hasanzakaria/CODEFORCES | 8662b464133d6058b74ea6bbbe0c6fd78366df9d | da08f70a3eae047e2da610b8a7aa3cc704b10202 | refs/heads/master | 2022-11-08T16:59:31.128716 | 2020-06-26T14:18:15 | 2020-06-26T14:18:15 | 275,172,665 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 687 | cpp | #include<bits/stdc++.h>
using namespace std;
int main ()
{
ios_base::sync_with_stdio(0);
int x,y,a,b,k,t,i,l,r,cou=0;
cin>>x>>y>>a>>b;
k=b/a;
t=sqrt(k);
if(b%a!=0)
{
cout<<0<<endl;
}
else
{
for(i=1;i<=t;i++)
{
if(k%i==0)
{
l=k/i;
r=__gcd(l,i);
if(r==1&&min(i*a,l*a)>=x&&max(i*a,l*a)<=y)
{
if(i==l)
{
cou++;
}
else
{
cou+=2;
}
}
}
}
cout<<cou<<endl;
}
} | [
"hasanxack@gmail.com"
] | hasanxack@gmail.com |
82b8ac05ac93d7717697c1ac6e96df65f32f1272 | a3eab08a8ecb69fb2ada99ec26a359825dc1a1a5 | /04. Function/paramArg.cpp | 8b8a4659c6d82904a29d3cb48eb7eddd4f37f8bf | [] | no_license | zonayedpca/learnCpp | 09c2b0c2bdcfb8a5af5ff2f5c6747d43fe0f2f27 | ac28cb0559a182ef97d16a418b9317863880e358 | refs/heads/master | 2020-04-24T15:02:22.253861 | 2019-04-03T12:38:39 | 2019-04-03T12:38:39 | 172,049,237 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 456 | cpp | #include <iostream>
void dontReturn(int x, int y) {
std::cout << "First: " << x << " and Second: " << y << '\n';
}
int returnSomething(int x, int y) {
return x + y;
}
int anotherFunc(int sub, int sum) {
return sum - sub;
}
int main() {
dontReturn(10, 62);
std::cout << "Return Something: " << returnSomething(10, 62) << '\n';
std::cout << "Another Function as Argument: " << anotherFunc(22, returnSomething(10, 62)) << '\n';
return 0;
}
| [
"zonayedpca@yahoo.com"
] | zonayedpca@yahoo.com |
167a753a8455fe67508ab1b2e9f3e318aa0867f1 | 8380b5eb12e24692e97480bfa8939a199d067bce | /Carberp Botnet/source - absource/pro/all source/BJWJ/include/necko/nsIPrompt.h | 8b1d065ad961f0744d8f8d7f7365625f2f0df676 | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | RamadhanAmizudin/malware | 788ee745b5bb23b980005c2af08f6cb8763981c2 | 62d0035db6bc9aa279b7c60250d439825ae65e41 | refs/heads/master | 2023-02-05T13:37:18.909646 | 2023-01-26T08:43:18 | 2023-01-26T08:43:18 | 53,407,812 | 873 | 291 | null | 2023-01-26T08:43:19 | 2016-03-08T11:44:21 | C++ | UTF-8 | C++ | false | false | 15,890 | h | /*
* DO NOT EDIT. THIS FILE IS GENERATED FROM e:/builds/moz2_slave/mozilla-1.9.1-win32-xulrunner/build/netwerk/base/public/nsIPrompt.idl
*/
#ifndef __gen_nsIPrompt_h__
#define __gen_nsIPrompt_h__
#ifndef __gen_nsISupports_h__
#include "nsISupports.h"
#endif
/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif
/* starting interface: nsIPrompt */
#define NS_IPROMPT_IID_STR "a63f70c0-148b-11d3-9333-00104ba0fd40"
#define NS_IPROMPT_IID \
{0xa63f70c0, 0x148b, 0x11d3, \
{ 0x93, 0x33, 0x00, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }}
class NS_NO_VTABLE NS_SCRIPTABLE nsIPrompt : public nsISupports {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IPROMPT_IID)
/* void alert (in wstring dialogTitle, in wstring text); */
NS_SCRIPTABLE NS_IMETHOD Alert(const PRUnichar *dialogTitle, const PRUnichar *text) = 0;
/* void alertCheck (in wstring dialogTitle, in wstring text, in wstring checkMsg, inout boolean checkValue); */
NS_SCRIPTABLE NS_IMETHOD AlertCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM) = 0;
/* boolean confirm (in wstring dialogTitle, in wstring text); */
NS_SCRIPTABLE NS_IMETHOD Confirm(const PRUnichar *dialogTitle, const PRUnichar *text, PRBool *_retval NS_OUTPARAM) = 0;
/* boolean confirmCheck (in wstring dialogTitle, in wstring text, in wstring checkMsg, inout boolean checkValue); */
NS_SCRIPTABLE NS_IMETHOD ConfirmCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) = 0;
enum { BUTTON_POS_0 = 1U };
enum { BUTTON_POS_1 = 256U };
enum { BUTTON_POS_2 = 65536U };
enum { BUTTON_TITLE_OK = 1U };
enum { BUTTON_TITLE_CANCEL = 2U };
enum { BUTTON_TITLE_YES = 3U };
enum { BUTTON_TITLE_NO = 4U };
enum { BUTTON_TITLE_SAVE = 5U };
enum { BUTTON_TITLE_DONT_SAVE = 6U };
enum { BUTTON_TITLE_REVERT = 7U };
enum { BUTTON_TITLE_IS_STRING = 127U };
enum { BUTTON_POS_0_DEFAULT = 0U };
enum { BUTTON_POS_1_DEFAULT = 16777216U };
enum { BUTTON_POS_2_DEFAULT = 33554432U };
enum { BUTTON_DELAY_ENABLE = 67108864U };
enum { STD_OK_CANCEL_BUTTONS = 513U };
enum { STD_YES_NO_BUTTONS = 1027U };
/* PRInt32 confirmEx (in wstring dialogTitle, in wstring text, in unsigned long buttonFlags, in wstring button0Title, in wstring button1Title, in wstring button2Title, in wstring checkMsg, inout boolean checkValue); */
NS_SCRIPTABLE NS_IMETHOD ConfirmEx(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 buttonFlags, const PRUnichar *button0Title, const PRUnichar *button1Title, const PRUnichar *button2Title, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRInt32 *_retval NS_OUTPARAM) = 0;
/* boolean prompt (in wstring dialogTitle, in wstring text, inout wstring value, in wstring checkMsg, inout boolean checkValue); */
NS_SCRIPTABLE NS_IMETHOD Prompt(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **value NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) = 0;
/* boolean promptPassword (in wstring dialogTitle, in wstring text, inout wstring password, in wstring checkMsg, inout boolean checkValue); */
NS_SCRIPTABLE NS_IMETHOD PromptPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) = 0;
/* boolean promptUsernameAndPassword (in wstring dialogTitle, in wstring text, inout wstring username, inout wstring password, in wstring checkMsg, inout boolean checkValue); */
NS_SCRIPTABLE NS_IMETHOD PromptUsernameAndPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **username NS_INOUTPARAM, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) = 0;
/* boolean select (in wstring dialogTitle, in wstring text, in PRUint32 count, [array, size_is (count)] in wstring selectList, out long outSelection); */
NS_SCRIPTABLE NS_IMETHOD Select(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 count, const PRUnichar **selectList, PRInt32 *outSelection NS_OUTPARAM, PRBool *_retval NS_OUTPARAM) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIPrompt, NS_IPROMPT_IID)
/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIPROMPT \
NS_SCRIPTABLE NS_IMETHOD Alert(const PRUnichar *dialogTitle, const PRUnichar *text); \
NS_SCRIPTABLE NS_IMETHOD AlertCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD Confirm(const PRUnichar *dialogTitle, const PRUnichar *text, PRBool *_retval NS_OUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD ConfirmCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD ConfirmEx(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 buttonFlags, const PRUnichar *button0Title, const PRUnichar *button1Title, const PRUnichar *button2Title, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRInt32 *_retval NS_OUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD Prompt(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **value NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD PromptPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD PromptUsernameAndPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **username NS_INOUTPARAM, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM); \
NS_SCRIPTABLE NS_IMETHOD Select(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 count, const PRUnichar **selectList, PRInt32 *outSelection NS_OUTPARAM, PRBool *_retval NS_OUTPARAM);
/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIPROMPT(_to) \
NS_SCRIPTABLE NS_IMETHOD Alert(const PRUnichar *dialogTitle, const PRUnichar *text) { return _to Alert(dialogTitle, text); } \
NS_SCRIPTABLE NS_IMETHOD AlertCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM) { return _to AlertCheck(dialogTitle, text, checkMsg, checkValue); } \
NS_SCRIPTABLE NS_IMETHOD Confirm(const PRUnichar *dialogTitle, const PRUnichar *text, PRBool *_retval NS_OUTPARAM) { return _to Confirm(dialogTitle, text, _retval); } \
NS_SCRIPTABLE NS_IMETHOD ConfirmCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) { return _to ConfirmCheck(dialogTitle, text, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD ConfirmEx(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 buttonFlags, const PRUnichar *button0Title, const PRUnichar *button1Title, const PRUnichar *button2Title, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRInt32 *_retval NS_OUTPARAM) { return _to ConfirmEx(dialogTitle, text, buttonFlags, button0Title, button1Title, button2Title, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD Prompt(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **value NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) { return _to Prompt(dialogTitle, text, value, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD PromptPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) { return _to PromptPassword(dialogTitle, text, password, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD PromptUsernameAndPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **username NS_INOUTPARAM, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) { return _to PromptUsernameAndPassword(dialogTitle, text, username, password, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD Select(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 count, const PRUnichar **selectList, PRInt32 *outSelection NS_OUTPARAM, PRBool *_retval NS_OUTPARAM) { return _to Select(dialogTitle, text, count, selectList, outSelection, _retval); }
/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIPROMPT(_to) \
NS_SCRIPTABLE NS_IMETHOD Alert(const PRUnichar *dialogTitle, const PRUnichar *text) { return !_to ? NS_ERROR_NULL_POINTER : _to->Alert(dialogTitle, text); } \
NS_SCRIPTABLE NS_IMETHOD AlertCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->AlertCheck(dialogTitle, text, checkMsg, checkValue); } \
NS_SCRIPTABLE NS_IMETHOD Confirm(const PRUnichar *dialogTitle, const PRUnichar *text, PRBool *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->Confirm(dialogTitle, text, _retval); } \
NS_SCRIPTABLE NS_IMETHOD ConfirmCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->ConfirmCheck(dialogTitle, text, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD ConfirmEx(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 buttonFlags, const PRUnichar *button0Title, const PRUnichar *button1Title, const PRUnichar *button2Title, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRInt32 *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->ConfirmEx(dialogTitle, text, buttonFlags, button0Title, button1Title, button2Title, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD Prompt(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **value NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->Prompt(dialogTitle, text, value, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD PromptPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->PromptPassword(dialogTitle, text, password, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD PromptUsernameAndPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **username NS_INOUTPARAM, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->PromptUsernameAndPassword(dialogTitle, text, username, password, checkMsg, checkValue, _retval); } \
NS_SCRIPTABLE NS_IMETHOD Select(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 count, const PRUnichar **selectList, PRInt32 *outSelection NS_OUTPARAM, PRBool *_retval NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->Select(dialogTitle, text, count, selectList, outSelection, _retval); }
#if 0
/* Use the code below as a template for the implementation class for this interface. */
/* Header file */
class nsPrompt : public nsIPrompt
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIPROMPT
nsPrompt();
private:
~nsPrompt();
protected:
/* additional members */
};
/* Implementation file */
NS_IMPL_ISUPPORTS1(nsPrompt, nsIPrompt)
nsPrompt::nsPrompt()
{
/* member initializers and constructor code */
}
nsPrompt::~nsPrompt()
{
/* destructor code */
}
/* void alert (in wstring dialogTitle, in wstring text); */
NS_IMETHODIMP nsPrompt::Alert(const PRUnichar *dialogTitle, const PRUnichar *text)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void alertCheck (in wstring dialogTitle, in wstring text, in wstring checkMsg, inout boolean checkValue); */
NS_IMETHODIMP nsPrompt::AlertCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* boolean confirm (in wstring dialogTitle, in wstring text); */
NS_IMETHODIMP nsPrompt::Confirm(const PRUnichar *dialogTitle, const PRUnichar *text, PRBool *_retval NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* boolean confirmCheck (in wstring dialogTitle, in wstring text, in wstring checkMsg, inout boolean checkValue); */
NS_IMETHODIMP nsPrompt::ConfirmCheck(const PRUnichar *dialogTitle, const PRUnichar *text, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* PRInt32 confirmEx (in wstring dialogTitle, in wstring text, in unsigned long buttonFlags, in wstring button0Title, in wstring button1Title, in wstring button2Title, in wstring checkMsg, inout boolean checkValue); */
NS_IMETHODIMP nsPrompt::ConfirmEx(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 buttonFlags, const PRUnichar *button0Title, const PRUnichar *button1Title, const PRUnichar *button2Title, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRInt32 *_retval NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* boolean prompt (in wstring dialogTitle, in wstring text, inout wstring value, in wstring checkMsg, inout boolean checkValue); */
NS_IMETHODIMP nsPrompt::Prompt(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **value NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* boolean promptPassword (in wstring dialogTitle, in wstring text, inout wstring password, in wstring checkMsg, inout boolean checkValue); */
NS_IMETHODIMP nsPrompt::PromptPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* boolean promptUsernameAndPassword (in wstring dialogTitle, in wstring text, inout wstring username, inout wstring password, in wstring checkMsg, inout boolean checkValue); */
NS_IMETHODIMP nsPrompt::PromptUsernameAndPassword(const PRUnichar *dialogTitle, const PRUnichar *text, PRUnichar **username NS_INOUTPARAM, PRUnichar **password NS_INOUTPARAM, const PRUnichar *checkMsg, PRBool *checkValue NS_INOUTPARAM, PRBool *_retval NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* boolean select (in wstring dialogTitle, in wstring text, in PRUint32 count, [array, size_is (count)] in wstring selectList, out long outSelection); */
NS_IMETHODIMP nsPrompt::Select(const PRUnichar *dialogTitle, const PRUnichar *text, PRUint32 count, const PRUnichar **selectList, PRInt32 *outSelection NS_OUTPARAM, PRBool *_retval NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* End of implementation class template. */
#endif
#endif /* __gen_nsIPrompt_h__ */
| [
"fdiskyou@users.noreply.github.com"
] | fdiskyou@users.noreply.github.com |
ce8885ea9d7b4aec1b4fe938e0d9b2c5df1f6edd | 6b660cb96baa003de9e18e332b048c0f1fa67ab9 | /External/SDK/BP_GeyserDynamic_functions.cpp | fe4d97456e103c8cb3b493584dddd888197c8a94 | [] | no_license | zanzo420/zSoT-SDK | 1edbff62b3e12695ecf3969537a6d2631a0ff36f | 5e581eb0400061f6e5f93b3affd95001f62d4f7c | refs/heads/main | 2022-07-30T03:35:51.225374 | 2021-07-07T01:07:20 | 2021-07-07T01:07:20 | 383,634,601 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 542 | cpp | // Name: SoT, Version: 2.2.0.2
#include "../pch.h"
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
void ABP_GeyserDynamic_C::AfterRead()
{
ABP_Geyser_C::AfterRead();
}
void ABP_GeyserDynamic_C::BeforeDelete()
{
ABP_Geyser_C::BeforeDelete();
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"Massimo.linker@gmail.com"
] | Massimo.linker@gmail.com |
cd3769cb31cd60d32231c5f7ca9942141191ac6d | 1c12b426e58f5f3e9263401292bc163e92732dca | /assignment_package/src/inventory.cpp | 0fcfd7d0c0dfea062b57357c04aeafc647bc7b8d | [] | no_license | annasjiang/mini-minecraft | 4adf1da48172f0c120a75d2bb192f5038e349ba4 | efa2dcce6bcc70d56fa0a9eca8df3937e4b78108 | refs/heads/master | 2023-08-21T06:30:43.217008 | 2021-10-16T03:19:05 | 2021-10-16T03:19:05 | 409,630,033 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,455 | cpp | #include <QKeyEvent>
#include <QPixmap>
#include "inventory.h"
#include "ui_inventory.h"
Inventory::Inventory(QWidget *parent) :
QWidget(parent),
ui(new Ui::Inventory)
{
ui->setupUi(this);
connect(ui->radioButtonGrass, SIGNAL(clicked()), this, SLOT(slot_setCurrBlockToGrass()));
connect(ui->radioButtonDirt, SIGNAL(clicked()), this, SLOT(slot_setCurrBlockToDirt()));
connect(ui->radioButtonStone, SIGNAL(clicked()), this, SLOT(slot_setCurrBlockToStone()));
connect(ui->radioButtonSand, SIGNAL(clicked()), this, SLOT(slot_setCurrBlockToSand()));
connect(ui->radioButtonWood, SIGNAL(clicked()), this, SLOT(slot_setCurrBlockToWood()));
connect(ui->radioButtonLeaf, SIGNAL(clicked()), this, SLOT(slot_setCurrBlockToLeaf()));
connect(ui->radioButtonSnow, SIGNAL(clicked()), this, SLOT(slot_setCurrBlockToSnow()));
connect(ui->radioButtonIce, SIGNAL(clicked()), this, SLOT(slot_setCurrBlockToIce()));
}
Inventory::~Inventory() {
delete ui;
}
// close the inventory
void Inventory::keyPressEvent(QKeyEvent *e) {
if (e->key() == Qt::Key_I) {
this->close();
}
}
// update quantities
void Inventory::slot_setNumGrass(int n) {
ui->numGrass->display(n);
}
void Inventory::slot_setNumDirt(int n) {
ui->numDirt->display(n);
}
void Inventory::slot_setNumStone(int n) {
ui->numStone->display(n);
}
void Inventory::slot_setNumSand(int n) {
ui->numSand->display(n);
}
void Inventory::slot_setNumWood(int n) {
ui->numWood->display(n);
}
void Inventory::slot_setNumLeaf(int n) {
ui->numLeaf->display(n);
}
void Inventory::slot_setNumSnow(int n) {
ui->numSnow->display(n);
}
void Inventory::slot_setNumIce(int n) {
ui->numIce->display(n);
}
// set current block
void Inventory::slot_setCurrBlockToGrass() {
ui_main->mygl->currBlockType = GRASS;
}
void Inventory::slot_setCurrBlockToDirt() {
ui_main->mygl->currBlockType = DIRT;
}
void Inventory::slot_setCurrBlockToStone() {
ui_main->mygl->currBlockType = STONE;
}
void Inventory::slot_setCurrBlockToSand() {
ui_main->mygl->currBlockType = SAND;
}
void Inventory::slot_setCurrBlockToWood() {
ui_main->mygl->currBlockType = WOOD;
}
void Inventory::slot_setCurrBlockToLeaf() {
ui_main->mygl->currBlockType = LEAF;
}
void Inventory::slot_setCurrBlockToSnow() {
ui_main->mygl->currBlockType = SNOW;
}
void Inventory::slot_setCurrBlockToIce() {
ui_main->mygl->currBlockType = ICE;
}
| [
"36720819+annasjiang@users.noreply.github.com"
] | 36720819+annasjiang@users.noreply.github.com |
b1a73a0e9534310624fb4ebe20c23383942abc3a | a782e8b77eb9a32ffb2c3f417125553693eaee86 | /src/developer/feedback/utils/cobalt/event.h | a7a098e3ca61bb9981852bb5d65b4bf7e1fb0759 | [
"BSD-3-Clause"
] | permissive | xyuan/fuchsia | 9e5251517e88447d3e4df12cf530d2c3068af290 | db9b631cda844d7f1a1b18cefed832a66f46d56c | refs/heads/master | 2022-06-30T17:53:09.241350 | 2020-05-13T12:28:17 | 2020-05-13T12:28:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,521 | h | // Copyright 2019 The Fuchsia 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 SRC_DEVELOPER_FEEDBACK_UTILS_COBALT_EVENT_H_
#define SRC_DEVELOPER_FEEDBACK_UTILS_COBALT_EVENT_H_
#include <fuchsia/cobalt/cpp/fidl.h>
#include <ostream>
#include <type_traits>
#include "src/developer/feedback/utils/cobalt/metrics.h"
namespace feedback {
namespace cobalt {
struct Event {
Event(EventType type, uint32_t metric_id, const std::vector<uint32_t>& dimensions, uint64_t count)
: type(type), metric_id(metric_id), dimensions(dimensions), count(count) {}
// Define constructors that allow for the omission of a metric id.
template <typename DimensionType>
explicit Event(DimensionType dimension)
: type(EventTypeForEventCode(dimension)),
metric_id(MetricIDForEventCode(dimension)),
dimensions({static_cast<uint32_t>(dimension)}),
count(0u) {
static_assert(std::is_enum<DimensionType>::value, "DimensionType must be an enum");
}
template <typename DimensionType>
Event(DimensionType dimension, uint64_t count)
: type(EventTypeForEventCode(dimension)),
metric_id(MetricIDForEventCode(dimension)),
dimensions({static_cast<uint32_t>(dimension)}),
count(count) {
static_assert(std::is_enum<DimensionType>::value, "DimensionType must be an enum");
}
template <typename DimensionTypesH, typename... DimensionTypesT,
typename = std::enable_if_t<(std::is_enum_v<DimensionTypesT> && ...)>>
explicit Event(DimensionTypesH dimensions_h, DimensionTypesT... dimensions_t)
: type(EventType::kMultidimensionalOccurrence),
metric_id(MetricIDForEventCode(dimensions_h, dimensions_t...)),
dimensions(std::vector<uint32_t>({
static_cast<uint32_t>(dimensions_h),
static_cast<uint32_t>(dimensions_t)...,
})),
count(1u) {
static_assert(std::is_enum_v<DimensionTypesH>, "DimensionTypes must be enums");
}
std::string ToString() const;
EventType type;
uint32_t metric_id = 0;
std::vector<uint32_t> dimensions;
union {
uint64_t count; // Used for Count metrics.
uint64_t usecs_elapsed; // Used for Time Elapsed metrics.
};
};
bool operator==(const Event& lhs, const Event& rhs);
std::ostream& operator<<(std::ostream& os, const Event& event);
} // namespace cobalt
} // namespace feedback
#endif // SRC_DEVELOPER_FEEDBACK_UTILS_COBALT_EVENT_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
3aa8cb462a6c0f208266a3da405c139a7c4cfc09 | d7ea642cec35f60d4e3053009a7d858eb3c86f2c | /GLES/NonIndexed/NonIndexedRenderer1/src/Window.h | 83178747f2fcae3c8e3cf3efd4ed8eb86be0b140 | [] | no_license | perezite/sandbox | 396091c9c1d4fa6c5275547148a6834853bdb376 | 759d697ca30cedda39a40d7e37d9d49a498b4cb4 | refs/heads/master | 2021-01-17T06:35:23.994689 | 2020-09-25T20:57:52 | 2020-09-25T20:57:52 | 59,944,622 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 453 | h | #pragma once
#include "GL.h"
#include "Drawable.h"
#include "Renderer.h"
#include <SDL2/SDL.h>
namespace sb
{
class Window
{
public:
Window(int width = 400, int height = 400);
~Window();
bool isOpen() { return m_isOpen; }
void update();
void display();
void draw(Drawable& drawable) { m_renderer.render(drawable); }
private:
bool m_isOpen;
SDL_Window* m_sdlWindow;
SDL_GLContext m_glContext;
Renderer m_renderer;
};
} | [
"simulo2000@gmail.com"
] | simulo2000@gmail.com |
9f5a394501fe712419b9c937b8dc509104b5b7ad | e8332ce38441295637dcc80f53f4375f51053156 | /Sources/Components/Forces.cpp | 6f8d07c37f6d3e4f3e84fe03df619e9b5ae9e0ca | [] | no_license | andrequentin/Projet_Moteur_de_jeu_Imagerie_3D_Sons_et_musique | c12830652220891a7e717840d846e9f048ff8f9b | b4f481edff135e5fb670957e71737cff66546249 | refs/heads/master | 2020-08-10T01:01:54.813869 | 2020-01-15T12:23:58 | 2020-01-15T12:23:58 | 214,214,330 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 637 | cpp | #include "Components/Forces.hpp"
namespace Gg {
namespace Component {
Forces::Forces():
velocity{glm::vec3{0.0f}},
forces{glm::vec3{0.0f}},
mass{1.f},
gravity_f{0.1f},
maxspeed{2.f}
{}
Forces::Forces(const glm::vec3 f,float gf,float m,float ms) :
velocity{glm::vec3{0.0f}},
forces{f},
mass{m},
gravity_f{gf},
maxspeed{ms}
{}
Forces::Forces(const Forces &fs):
velocity{fs.velocity},
forces{fs.forces},
mass{fs.mass},
gravity_f{fs.gravity_f},
maxspeed{fs.maxspeed}
{}
void Forces::addForce(glm::vec3 f){
forces +=f;
}
}
}
| [
"quentin.andre-97@laposte.net"
] | quentin.andre-97@laposte.net |
b4a08bbe74623d8bcad10147b0aef6857dc2208d | 3a9ab6f2e8ae27bef7e563ae8c51484d0ba03a40 | /Delta_test/main.cpp | b4c624769f34b75969259ca7fadfe4cbaca05be6 | [
"MIT"
] | permissive | SmaG-on-Hub/QtProject_FileCopyInThreads | 54de392acce264316d931f6f22534cbc86a74f91 | a4e537b59b53a5f20aed3264e912e04f512df611 | refs/heads/master | 2022-04-13T11:17:13.886594 | 2020-02-26T01:58:33 | 2020-02-26T01:58:33 | 241,615,386 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,239 | cpp | #include "qcopyworker.h"
#include "toml11/toml.hpp"
#include <QCoreApplication>
#include <QThreadPool>
#include <list>
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
/* std::ofstream test_file("first.dat", std::ios_base::binary);
char buff[1048576];
for (int var = 0; var < 1000; ++var) {
test_file.write(buff, 1048576);
}
test_file.close();*/
QThreadPool workersPool;
std::ifstream ifs("Files_to_copy.toml", std::ios_base::binary);
if (not ifs.good())
std::cout<< "Nope!";
const auto data = toml::parse(ifs);
//const auto tdata = toml::find(data, "files");
const int max_threads = toml::find_or<int>(data, "max_threads", 2);
const auto dist = toml::find_or<std::string>(data, "dist", "");
auto files = toml::get<std::list<std::string>>(toml::find(data, "files"));
workersPool.setMaxThreadCount(max_threads);
QCopyWorker* temp;
while(!files.empty())
{
temp = new QCopyWorker(files.front(), dist);
workersPool.start(temp, QThread::Priority::NormalPriority);
files.pop_front();
}
ifs.close();
return a.exec();
}
| [
"smag@ua.fm"
] | smag@ua.fm |
b9e641551231ed92385f0e1fe6f1464c5f33c660 | 619a313d513ad72c4653e8bb078c4c3cc6313abe | /CIS330 C C++ and Unix/InvisibleTetrisProject/cpp/pieces.cpp | 224f329a64988b68051a1f2d0ebce48cc54bdb8f | [
"MIT"
] | permissive | haominhe/Undergraduate | 8f15df69d8fd3ad0ce2e81fe944cbf50cea16e6b | 77fb76b1c4558dec8bef2b424e7abd12a48d3968 | refs/heads/master | 2023-03-24T01:06:10.313588 | 2019-07-21T06:36:44 | 2019-07-21T06:36:44 | 197,996,406 | 0 | 0 | MIT | 2021-03-25T22:49:25 | 2019-07-21T00:55:21 | Python | UTF-8 | C++ | false | false | 2,426 | cpp | //Invisible Tetris ,Winter 2016, CIS 330 Final Project
//Team name: This->
// By Haomin He, Yanting Liu and Guangyun Hou
#include "cpp/pieces.h"
#include "cpp/board.h"
const int Pieces::block_list [7][4][2]=
{
// I -type
// []
// []
// []
// []
{
{0,-1},
{0,0},
{0,1},
{0,2}
},
// z type
// [][]
// [][]
{
{0,-1},
{0,0},
{-1,0},
{-1,1}
},
// square
// [][]
// [][]
{
{0,0},
{0,1},
{1,0},
{1,1}
},
// s type
// [][]
// [][]
{
{0,-1},
{0,0},
{1,0},
{1,1}
},
// L type
// []
// []
// [][]
{
{-1,-1},
{0,-1},
{0,0},
{0,1}
},
// J type
// []
// []
// [][]
{
{1,-1},
{0,-1},
{0,0},
{0,1}
},
// T type
// [][][]
// []
{
{0,0},
{0,1},
{0,2},
{1,1}
}
};
Pieces::Pieces(int new_type) {
type = new_type;
free_fall = false;
faster = false;
status = INACTIVE;
movement = NONE;
coords = new int[4][2];
for (int i = 0; i < 4 ; i++) {
coords[i][0] = block_list[type][i][0];
coords[i][1] = block_list[type][i][1];
}
}
void Pieces::rotate_left() {
for (int i = 0; i < SIZE; i++) {
int temp = coords[i][0];
coords[i][0] = -coords[i][1];
coords[i][1] = temp;
}
}
void Pieces::rotate_right() {
for (int i = 0; i < SIZE; i++) {
int temp = coords[i][0];
coords[i][0] = coords[i][1];
coords[i][1] = -temp;
}
}
void Pieces::get_shadow(Board *board, int shadow_y[]) {
// Preserve tetromino state.
int temp_y = y;
Status temp_status = status;
while (!has_landed()) {
for (int i = 0; i < SIZE; i++)
// Lands on tetromino or bottom of the board.
if (xGetter(i) == board->ROWS ||
board->blockColor[yGetter(i)][xGetter(i)] != -1) {
lands();
y--;
break;
}
if (!has_landed())
y++;
}
// Save the position.
for (int i = 0; i < SIZE; i++)
shadow_y[i] = yGetter(i);
// Return tetromino to initial state.
y = temp_y;
status = temp_status;
} | [
"haominhe@LAPTOP-CSJB3RJP.localdomain"
] | haominhe@LAPTOP-CSJB3RJP.localdomain |
a3c1c2ad036bc1bfc2e023911a152a4e168ba88c | 009851177d04a441141113189125a91a26f4dc74 | /nodejs-mobile/deps/chakrashim/core/lib/Common/Memory/SmallLeafHeapBlock.cpp | 5e0ca2de1d9bf43caca429691d17c9ead625eef2 | [
"MIT",
"LicenseRef-scancode-unicode",
"Zlib",
"ISC",
"LicenseRef-scancode-public-domain",
"NAIST-2003",
"BSD-3-Clause",
"BSD-2-Clause",
"Artistic-2.0",
"LicenseRef-scancode-unknown-license-reference",
"NTP",
"LicenseRef-scancode-openssl",
"ICU"
] | permissive | xuelongqy/cnode | a967f9e71315b10d3870192b4bbe2c341b196507 | ac256264d329e68b6c5ae3281b0e7bb5a95ae164 | refs/heads/master | 2023-01-30T11:23:41.485647 | 2020-03-25T05:55:13 | 2020-03-25T05:55:13 | 246,811,631 | 0 | 1 | MIT | 2023-01-07T15:54:34 | 2020-03-12T10:58:07 | C++ | UTF-8 | C++ | false | false | 2,910 | cpp | //-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
#include "CommonMemoryPch.h"
template <class TBlockAttributes>
SmallLeafHeapBlockT<TBlockAttributes> *
SmallLeafHeapBlockT<TBlockAttributes>::New(HeapBucketT<SmallLeafHeapBlockT<TBlockAttributes>> * bucket)
{
CompileAssert(TBlockAttributes::MaxObjectSize <= USHRT_MAX);
Assert(bucket->sizeCat <= TBlockAttributes::MaxObjectSize);
Assert((TBlockAttributes::PageCount * AutoSystemInfo::PageSize) / bucket->sizeCat <= USHRT_MAX);
ushort objectSize = (ushort)bucket->sizeCat;
ushort objectCount = (ushort)(TBlockAttributes::PageCount * AutoSystemInfo::PageSize / objectSize);
return NoMemProtectHeapNewNoThrowPlusPrefixZ(Base::GetAllocPlusSize(objectCount), SmallLeafHeapBlockT<TBlockAttributes>, bucket, objectSize, objectCount);
}
template <>
SmallLeafHeapBlockT<SmallAllocationBlockAttributes>::SmallLeafHeapBlockT(HeapBucketT<SmallLeafHeapBlockT<SmallAllocationBlockAttributes>> * bucket, ushort objectSize, ushort objectCount)
: Base(bucket, objectSize, objectCount, HeapBlock::HeapBlockType::SmallLeafBlockType)
{
Assert(objectCount > 1 && objectCount == (this->GetPageCount() * AutoSystemInfo::PageSize)/ objectSize);
}
template <>
SmallLeafHeapBlockT<MediumAllocationBlockAttributes>::SmallLeafHeapBlockT(HeapBucketT<SmallLeafHeapBlockT<MediumAllocationBlockAttributes>> * bucket, ushort objectSize, ushort objectCount)
: Base(bucket, objectSize, objectCount, HeapBlock::HeapBlockType::MediumLeafBlockType)
{
Assert(objectCount > 1 && objectCount == (this->GetPageCount() * AutoSystemInfo::PageSize) / objectSize);
}
template <class TBlockAttributes>
void
SmallLeafHeapBlockT<TBlockAttributes>::Delete(SmallLeafHeapBlockT<TBlockAttributes> * heapBlock)
{
Assert(heapBlock->IsLeafBlock());
NoMemProtectHeapDeletePlusPrefix(Base::GetAllocPlusSize(heapBlock->objectCount), heapBlock);
}
template <class TBlockAttributes>
void
SmallLeafHeapBlockT<TBlockAttributes>::ScanNewImplicitRoots(Recycler * recycler)
{
Base::ScanNewImplicitRootsBase([](void * object, size_t objectSize){});
}
#ifdef RECYCLER_SLOW_CHECK_ENABLED
template <class TBlockAttributes>
bool
SmallLeafHeapBlockT<TBlockAttributes>::GetFreeObjectListOnAllocator(FreeObject ** freeObjectList)
{
return this->template GetFreeObjectListOnAllocatorImpl<SmallLeafHeapBlockT<TBlockAttributes>>(freeObjectList);
}
#endif
namespace Memory
{
// Declare the class templates
template class SmallLeafHeapBlockT<SmallAllocationBlockAttributes>;
template class SmallLeafHeapBlockT<MediumAllocationBlockAttributes>;
}
| [
"59814509@qq.com"
] | 59814509@qq.com |
c9ba89b6317afa4c39ef01da5a1f871f2b47f958 | c2e97b1aacb1e9a7a925b60129d7171a17d4d4d8 | /libs/squish-1.11/colourfit.h | a2d0559a32c9ff24f854822c0a7cd576a073a8fe | [
"Zlib",
"MIT"
] | permissive | Ushio/ofxExtremeGpuVideo | 1500ba6fd57e9bca3400ebfc005e1338138345a0 | 0842679c0cba590cc13f4a401887e8e3a3a3311c | refs/heads/master | 2022-05-04T17:36:10.936866 | 2022-04-22T05:50:17 | 2022-04-22T05:50:17 | 55,229,467 | 63 | 7 | Zlib | 2022-04-22T05:50:17 | 2016-04-01T12:06:13 | C++ | UTF-8 | C++ | false | false | 1,737 | h | /* -----------------------------------------------------------------------------
Copyright (c) 2006 Simon Brown si@sjbrown.co.uk
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 SQUISH_COLOURFIT_H
#define SQUISH_COLOURFIT_H
#include <squish.h>
#include "maths.h"
namespace squish {
class ColourSet;
class ColourFit
{
public:
ColourFit( ColourSet const* colours, int flags );
void Compress( void* block );
protected:
virtual void Compress3( void* block ) = 0;
virtual void Compress4( void* block ) = 0;
ColourSet const* m_colours;
int m_flags;
};
} // namespace squish
#endif // ndef SQUISH_COLOURFIT_H
| [
"ushiostarfish@gmail.com"
] | ushiostarfish@gmail.com |
f9122ab7de9a9e05c3ff90aa3533f4f5311c8d59 | 8652a66d3994098ef4cf9186cd36171eb3833ad3 | /WINCE600/PLATFORM/COMMON/SRC/SOC/COMMON_FSL_V2_PDK1_7/IPUV3/CSI/csi.cpp | 8985ec24d9205d92ecdcbb6567ea1d0d6f0adc57 | [] | no_license | KunYi/em-works | 789e038ecaf4d0ec264d16fdd47df00b841de60c | 3b70b2690782acfcba7f4b0e43e05b5b070ed0da | refs/heads/master | 2016-09-06T03:47:56.913454 | 2013-11-05T03:28:15 | 2013-11-05T03:28:15 | 32,260,142 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 37,430 | cpp | //------------------------------------------------------------------------------
//
// Copyright (C) 2008-2009, Freescale Semiconductor, Inc. All Rights Reserved.
// THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
// AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT
//
//------------------------------------------------------------------------------
//
// File: csi.cpp
//
// Camera Sensor Interface functions
//
//------------------------------------------------------------------------------
#pragma warning(push)
#pragma warning(disable: 4115 4201 4204 4214)
#include <windows.h>
#include <Devload.h>
#include <ceddk.h>
#include <cmnintrin.h>
#pragma warning(pop)
#include "common_macros.h"
#include "common_ipuv3.h"
#include "IpuBuffer.h"
#include "Ipu_base.h"
#include "Ipu_common.h"
#include "idmac.h"
#include "cm.h"
#include "csi.h"
//------------------------------------------------------------------------------
// External Functions
//------------------------------------------------------------------------------
// External Variables
//------------------------------------------------------------------------------
// Defines
//------------------------------------------------------------------------------
// Types
//------------------------------------------------------------------------------
// Global Variables
static HANDLE g_hIPUBase = NULL;
PCSP_IPU_CSI_REGS g_pIPUV3_CSI0;
PCSP_IPU_CSI_REGS g_pIPUV3_CSI1;
//------------------------------------------------------------------------------
// Local Variables
//------------------------------------------------------------------------------
// Local Functions
//------------------------------------------------------------------------------
//
// Function: CSIRegsInit
//
// This function initializes the structures needed to access
// the IPUv3 Camera Sensor Interface.
//
// Parameters:
// None.
//
// Returns:
// TRUE if successful, FALSE if failure.
//------------------------------------------------------------------------------
BOOL CSIRegsInit()
{
BOOL rc = FALSE;
DWORD dwIPUBaseAddr;
PHYSICAL_ADDRESS phyAddr;
if ((g_pIPUV3_CSI0 == NULL) || (g_pIPUV3_CSI1 == NULL))
{
// *** Use IPU_BASE driver to retrieve IPU Base Address ***
// First, create handle to IPU_BASE driver
g_hIPUBase = IPUV3BaseOpenHandle();
if (g_hIPUBase == INVALID_HANDLE_VALUE)
{
ERRORMSG(TRUE,
(TEXT("%s: Opening IPU_BASE handle failed!\r\n"), __WFUNCTION__));
goto cleanUp;
}
dwIPUBaseAddr = IPUV3BaseGetBaseAddr(g_hIPUBase);
if (dwIPUBaseAddr == -1)
{
ERRORMSG(TRUE,
(TEXT("%s: Failed to retrieve IPU Base addr!\r\n"), __WFUNCTION__));
goto cleanUp;
}
//********************************************
// Create pointer to CSI0 registers
//********************************************
phyAddr.QuadPart = dwIPUBaseAddr + CSP_IPUV3_CSI0_REGS_OFFSET;
// Map peripheral physical address to virtual address
g_pIPUV3_CSI0 = (PCSP_IPU_CSI_REGS) MmMapIoSpace(phyAddr, sizeof(CSP_IPU_CSI_REGS),
FALSE);
// Check if virtual mapping failed
if (g_pIPUV3_CSI0 == NULL)
{
ERRORMSG(TRUE,
(_T("Init: MmMapIoSpace failed!\r\n")));
goto cleanUp;
}
//********************************************
// Create pointer to CSI1 registers
//********************************************
phyAddr.QuadPart = dwIPUBaseAddr + CSP_IPUV3_CSI1_REGS_OFFSET;
// Map peripheral physical address to virtual address
g_pIPUV3_CSI1 = (PCSP_IPU_CSI_REGS) MmMapIoSpace(phyAddr, sizeof(CSP_IPU_CSI_REGS),
FALSE);
// Check if virtual mapping failed
if (g_pIPUV3_CSI1 == NULL)
{
ERRORMSG(TRUE,
(_T("Init: MmMapIoSpace failed!\r\n")));
goto cleanUp;
}
}
rc = TRUE;
cleanUp:
// If initialization failed, be sure to clean up
if (!rc) CSIRegsCleanup();
return rc;
}
//-----------------------------------------------------------------------------
//
// Function: CSIRegsCleanup
//
// This function deallocates the data structures required for interaction
// with the IPUv3 Camera Sensor Interface.
//
// Parameters:
// None.
//
// Returns:
// None.
//
//-----------------------------------------------------------------------------
void CSIRegsCleanup(void)
{
if (!IPUV3BaseCloseHandle(g_hIPUBase))
{
ERRORMSG(TRUE,
(_T("DI Cleanup: Failed closing IPU Base handle!\r\n")));
}
// Unmap peripheral registers
if (g_pIPUV3_CSI0)
{
MmUnmapIoSpace(g_pIPUV3_CSI0, sizeof(PCSP_IPU_CSI_REGS));
g_pIPUV3_CSI0 = NULL;
}
// Unmap peripheral registers
if (g_pIPUV3_CSI1)
{
MmUnmapIoSpace(g_pIPUV3_CSI1, sizeof(PCSP_IPU_CSI_REGS));
g_pIPUV3_CSI1 = NULL;
}
}
//-----------------------------------------------------------------------------
//
// Function: CSIRegsEnable
//
// Enable the CSI0 or CSI1.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CS1 to enable
//
// Returns:
// None.
//
//-----------------------------------------------------------------------------
void CSIRegsEnable(CSI_SELECT csi_sel)
{
if (csi_sel == CSI_SELECT_CSI0)
{
// Call to IPU Base to turn on CSI0_EN in IPU_CONF reg.
// This will also turn on IPU clocks if no other IPU
// modules have already turned them on.
if(!IPUV3EnableModule(g_hIPUBase, IPU_SUBMODULE_CSI0, IPU_DRIVER_OTHER))
{
ERRORMSG(TRUE,
(TEXT("%s: Failed to enable CSI0!\r\n"), __WFUNCTION__));
}
}
else
{
// Call to IPU Base to turn on CSI1_EN in IPU_CONF reg.
// This will also turn on IPU clocks if no other IPU
// modules have already turned them on.
if(!IPUV3EnableModule(g_hIPUBase, IPU_SUBMODULE_CSI1, IPU_DRIVER_OTHER))
{
ERRORMSG(TRUE,
(TEXT("%s: Failed to enable CSI1!\r\n"), __WFUNCTION__));
}
}
}
//-----------------------------------------------------------------------------
//
// Function: CSIRegsDisable
//
// Disable the CSI0 or CSI1.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to disable
//
// Returns:
// None.
//
//-----------------------------------------------------------------------------
void CSIRegsDisable(CSI_SELECT csi_sel)
{
if(csi_sel == CSI_SELECT_CSI0)
{
if(!IPUV3DisableModule(g_hIPUBase, IPU_SUBMODULE_CSI0, IPU_DRIVER_OTHER))
{
ERRORMSG(TRUE,
(TEXT("%s: Failed to disable CSI0!\r\n"), __WFUNCTION__));
}
}
else
{
if(!IPUV3DisableModule(g_hIPUBase, IPU_SUBMODULE_CSI1, IPU_DRIVER_OTHER))
{
ERRORMSG(TRUE,
(TEXT("%s: Failed to disable CSI1!\r\n"), __WFUNCTION__));
}
}
}
//-----------------------------------------------------------------------------
//
// Function: CSISetTestMode
//
// Set the CSI0 or CSI1 to test mode.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to set test mode.
// bTestMode
// [in] TRUE for active test mode,FALSE for inactive test mode.
// iRed
// [in] Test Pattern generator Red value.
// iGreen
// [in] Test Pattern generator Green value.
// iBlue
// [in] Test Pattern generator Blue value.
//
// Returns:
// None.
//
//-----------------------------------------------------------------------------
void CSISetTestMode(CSI_SELECT csi_sel,BOOL bTestMode,UINT8 iRed,UINT8 iGreen,UINT8 iBlue)
{
UINT32 sensClkDivider;
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
if(bTestMode)
{
// Turn on test pattern generation from the CSI
INSREG32BF(&csi_regs->CSI_TST_CTRL,
IPU_CSI_TST_CTRL_TEST_GEN_MODE, IPU_CSI_TST_CTRL_TEST_GEN_MODE_ACTIVE);
// Only for Test mode using:Get camera divider ratio
sensClkDivider = 4;
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_DIV_RATIO, sensClkDivider);
RETAILMSG(0,(TEXT("%s:sensClkDivider = %d\r\n"),__WFUNCTION__,sensClkDivider));
}
else
{
INSREG32BF(&csi_regs->CSI_TST_CTRL,
IPU_CSI_TST_CTRL_TEST_GEN_MODE, IPU_CSI_TST_CTRL_TEST_GEN_MODE_INACTIVE);
}
// Set test pattern color in CSI
INSREG32BF(&csi_regs->CSI_TST_CTRL,
IPU_CSI_TST_CTRL_PG_R_VALUE,
iRed);
INSREG32BF(&csi_regs->CSI_TST_CTRL,
IPU_CSI_TST_CTRL_PG_G_VALUE,
iGreen);
INSREG32BF(&csi_regs->CSI_TST_CTRL,
IPU_CSI_TST_CTRL_PG_B_VALUE,
iBlue);
}
//-----------------------------------------------------------------------------
//
// Function: CSISetDataDest
//
// This function Set the data destination from the coming CSI moduel.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to configure.
// iDataDest
// [in] The destination of the data coming from CSI.
//
// Returns:
// TRUE if success
// FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL CSISetDataDest(CSI_SELECT csi_sel,UINT8 iDataDest)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
switch(iDataDest)
{
case IPU_CSI_SENS_CONF_DATA_DEST_SMFC:
// Set data destination as SMFC from CSI
case IPU_CSI_SENS_CONF_DATA_DEST_ISP:
// Set data destination as ISP from CSI
case IPU_CSI_SENS_CONF_DATA_DEST_IC:
// Set data destination as IC from CSI
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_DATA_DEST,
iDataDest);
break;
default:
ERRORMSG(TRUE,(TEXT("%s: Set data destination is failed!\r\n"),__WFUNCTION__));
return FALSE;
}
return TRUE;
}
//-----------------------------------------------------------------------------
//
// Function: CSISetForceEOF
//
// This function force the data end of frame.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to configure.
// bForce
// [in] TRUE to force the EOF,FALSE to no action.
//
// Returns:
// TRUE if success
// FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL CSISetForceEOF(CSI_SELECT csi_sel,BOOL bForce)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
if(bForce)
{
// Set force end of frame
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_FORCE_EOF,
IPU_CSI_SENS_CONF_FORCE_EOF_ENABLE);
}
else
{
// No action
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_FORCE_EOF,
IPU_CSI_SENS_CONF_FORCE_EOF_DISABLE);
}
return TRUE;
}
//-----------------------------------------------------------------------------
//
// Function: CSISetSensorPRTCL
//
// This function set the sensor protocol.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to configure.
// iPrtclMode
// [in] The input mode protocol structure point.
//
// Returns:
// TRUE if success
// FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL CSISetSensorPRTCL(CSI_SELECT csi_sel,CSI_PROTOCOL_INF *pPrtclInf)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
if (pPrtclInf->mode > 7)
{
ERRORMSG(TRUE,(TEXT("%s: Set CSI sensor protocol failed\r\n"),__WFUNCTION__));
}
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_SENS_PRTCL,pPrtclInf->mode);
if(pPrtclInf->mode == CSI_CCIR_PROGRESSIVE_BT656_MODE ||
pPrtclInf->mode == CSI_CCIR_PROGRESSIVE_BT1120DDR_MODE ||
pPrtclInf->mode == CSI_CCIR_PROGRESSIVE_BT1120SDR_MODE)
{
//Write CCIR Pre Command
INSREG32BF(&csi_regs->CSI_CCIR_CODE_3,
IPU_CSI_CCIR_CODE_3_CCIR_PRECOM, pPrtclInf->PreCmd);
//Write CCIR Code 1
INSREG32BF(&csi_regs->CSI_CCIR_CODE_1,
IPU_CSI_CCIR_CODE_1_STRT_FLD0_BLNK_1ST, pPrtclInf->Field0FirstBlankStartCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_1,
IPU_CSI_CCIR_CODE_1_END_FLD0_ACTV, pPrtclInf->Field0ActiveEndCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_1,
IPU_CSI_CCIR_CODE_1_STRT_FLD0_ACTV, pPrtclInf->Field0ActiveStartCmd);
}
if(pPrtclInf->mode == CSI_CCIR_INTERLACE_BT656_MODE ||
pPrtclInf->mode == CSI_CCIR_INTERLACE_BT1120DDR_MODE ||
pPrtclInf->mode == CSI_CCIR_INTERLACE_BT1120SDR_MODE)
{
//Write CCIR Pre Command
INSREG32BF(&csi_regs->CSI_CCIR_CODE_3,
IPU_CSI_CCIR_CODE_3_CCIR_PRECOM, pPrtclInf->PreCmd);
//Write CCIR Code 1
INSREG32BF(&csi_regs->CSI_CCIR_CODE_1,
IPU_CSI_CCIR_CODE_1_END_FLD0_BLNK_1ST, pPrtclInf->Field0FirstBlankEndCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_1,
IPU_CSI_CCIR_CODE_1_STRT_FLD0_BLNK_1ST, pPrtclInf->Field0FirstBlankStartCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_1,
IPU_CSI_CCIR_CODE_1_END_FLD0_BLNK_2ND, pPrtclInf->Field0SecondBlankEndCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_1,
IPU_CSI_CCIR_CODE_1_STRT_FLD0_BLNK_2ND, pPrtclInf->Field0SecondBlankStartCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_1,
IPU_CSI_CCIR_CODE_1_END_FLD0_ACTV, pPrtclInf->Field0ActiveEndCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_1,
IPU_CSI_CCIR_CODE_1_STRT_FLD0_ACTV, pPrtclInf->Field0ActiveStartCmd);
//Write CCIR Code 2
INSREG32BF(&csi_regs->CSI_CCIR_CODE_2,
IPU_CSI_CCIR_CODE_2_END_FLD1_BLNK_1ST, pPrtclInf->Field1FirstBlankEndCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_2,
IPU_CSI_CCIR_CODE_2_STRT_FLD1_BLNK_1ST, pPrtclInf->Field1FirstBlankStartCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_2,
IPU_CSI_CCIR_CODE_2_END_FLD1_BLNK_2ND, pPrtclInf->Field1SecondBlankEndCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_2,
IPU_CSI_CCIR_CODE_2_STRT_FLD1_BLNK_2ND, pPrtclInf->Field1SecondBlankStartCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_2,
IPU_CSI_CCIR_CODE_2_END_FLD1_ACTV, pPrtclInf->Field1ActiveEndCmd);
INSREG32BF(&csi_regs->CSI_CCIR_CODE_2,
IPU_CSI_CCIR_CODE_2_STRT_FLD1_ACTV, pPrtclInf->Field1ActiveStartCmd);
}
return TRUE;
}
//-----------------------------------------------------------------------------
//
// Function: CSISetVSYNCMode
//
// This function set the VSYNC mode.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to configure.
// iMode
// [in] VSYNC mode:0 for internal mode, 1 for external mode.
//
// Returns:
// TRUE if success
// FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL CSISetVSYNCMode(CSI_SELECT csi_sel,UINT8 iMode)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
if (iMode > 1)
{
ERRORMSG(TRUE,(TEXT("%s: Set CSI VSYNC mode failed\r\n"),__WFUNCTION__));
}
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_EXT_VSYNC,
iMode);
return TRUE;
}
//-----------------------------------------------------------------------------
//
// Function: CSISetDataFormat
//
// This function set the CSI ouput data format.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to configure.
// outFormat
// [in] Sensor output format
//
// Returns:
// TRUE if success
// FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL CSISetDataFormat(CSI_SELECT csi_sel,csiSensorOutputFormat outFormat)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
// Set CSI configuration parameters and sensor protocol based on the output format.
switch (outFormat)
{
case csiSensorOutputFormat_RGB888:
case csiSensorOutputFormat_YUV444:
// Set data format from the sensor.
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_DATA_FORMAT,
IPU_CSI_SENS_CONF_DATA_FORMAT_RGB_YUV444);
break;
case csiSensorOutputFormat_YUV422_YUYV:
// Set data format from the sensor.
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_DATA_FORMAT,
IPU_CSI_SENS_CONF_DATA_FORMAT_YUV422_YUYV);
break;
case csiSensorOutputFormat_YUV422_UYVY:
// Set data format from the sensor.
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_DATA_FORMAT,
IPU_CSI_SENS_CONF_DATA_FORMAT_YUV422_UYVY);
break;
case csiSensorOutputFormat_Bayer:
// Set data format from the sensor.
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_DATA_FORMAT,
IPU_CSI_SENS_CONF_DATA_FORMAT_BAYER);
break;
case csiSensorOutputFormat_RGB565:
// Set data format from the sensor.
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_DATA_FORMAT,
IPU_CSI_SENS_CONF_DATA_FORMAT_RGB565);
break;
case csiSensorOutputFormat_RGB555:
// Set data format from the sensor.
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_DATA_FORMAT,
IPU_CSI_SENS_CONF_DATA_FORMAT_RGB555);
break;
case csiSensorOutputFormat_JPEG:
// Set data format from the sensor.
INSREG32BF(&csi_regs->CSI_SENS_CONF,
IPU_CSI_SENS_CONF_DATA_FORMAT,
IPU_CSI_SENS_CONF_DATA_FORMAT_JPEG);
break;
default:
RETAILMSG(0,(TEXT("NO supported Sensor Format ! \r\n")));
return FALSE;
}
// Data width should be 8 bits per color, regardless of the format
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_DATA_WIDTH,
IPU_CSI_SENS_CONF_DATA_WIDTH_8BIT);
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_PACK_TIGHT,
IPU_CSI_SENS_CONF_PACK_TIGHT_16bit_WORD);
return TRUE;
}
//-----------------------------------------------------------------------------
//
// Function: CSISetPolarity
//
// This function set the CSI polarity.
//
// Parameters:
// bClkPol
// [in] TRUE is for DISP_PIX_CLK_INVERT, FALSE is for DISP_PIX_CLK_NO_INVERT.
// bDataPol
// [in] TRUE is for DATA_POL_INVERT, FALSE is for DATA_POL_NO_INVERT.
// bHSYNCPol
// [in] TRUE is for HSYNC_POL_INVERT, FALSE is for HSYNC_POL_NO_INVERT.
// bVSYNCPol
// [in] TRUE is for VSYNC_POL_INVERT, FALSE is for VSYNC_POL_NO_INVERT.
// bDataENPol
// [in] TRUE is for DATA_EN_POL_INVERT, FALSE is for DATA_EN_POL_NO_INVERT.
//
// Returns:
// NULL.
//
//-----------------------------------------------------------------------------
void CSISetPolarity(CSI_SELECT csi_sel,BOOL bClkPol,BOOL bDataPol,BOOL bHSYNCPol,BOOL bVSYNCPol,BOOL bDataENPol)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
// Set the polarity
if (bClkPol)
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_DISP_PIX_CLK_POL,
IPU_CSI_SENS_CONF_DISP_PIX_CLK_INVERT);
else
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_DISP_PIX_CLK_POL,
IPU_CSI_SENS_CONF_DISP_PIX_CLK_NO_INVERT);
if (bDataPol)
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_DATA_POL,
IPU_CSI_SENS_CONF_DATA_POL_INVERT);
else
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_DATA_POL,
IPU_CSI_SENS_CONF_DATA_POL_NO_INVERT);
if (bHSYNCPol)
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_HSYNC_POL,
IPU_CSI_SENS_CONF_HSYNC_POL_INVERT);
else
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_HSYNC_POL,
IPU_CSI_SENS_CONF_HSYNC_POL_NO_INVERT);
if (bVSYNCPol)
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_VSYNC_POL,
IPU_CSI_SENS_CONF_VSYNC_POL_INVERT);
else
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_VSYNC_POL,
IPU_CSI_SENS_CONF_VSYNC_POL_NO_INVERT);
if (bDataENPol)
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_DATA_EN_POL,
IPU_CSI_SENS_CONF_DATA_EN_POL_INVERT);
else
INSREG32BF(&csi_regs->CSI_SENS_CONF, IPU_CSI_SENS_CONF_DATA_EN_POL,
IPU_CSI_SENS_CONF_DATA_EN_POL_NO_INVERT);
}
//-----------------------------------------------------------------------------
//
// Function: CSIConfigureFrmSize
//
// This function configures the CSI module frame size.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to config.
// outResolution
// [in] Sensor output resolution:QXGA,UXGA,SXGA,XGA,SVGA,VGA,QVGA,QQVGA,CIF,QIF
// D1_PAL,D1_NTSC
// prtclmode
// [in] Input data Protocol Mode
//
// Returns:
// TRUE if success
// FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL CSIConfigureFrmSize(CSI_SELECT csi_sel, csiSensorOutputResolution outResolution, csiMode prtclmode)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
UINT32 iInterlaceScale = 1;
if(prtclmode == CSI_CCIR_INTERLACE_BT656_MODE ||
prtclmode == CSI_CCIR_INTERLACE_BT1120DDR_MODE ||
prtclmode == CSI_CCIR_INTERLACE_BT1120SDR_MODE)
{
//if use interlace mode, we will downsize the image height
iInterlaceScale = 2;
}
// Set up CSI width and height configuration parameters and
// CSI sensor and actual frame size from the output resolution.
// Note: Subtract one from frame height and width values
// before writing to CSI registers.
switch (outResolution)
{
case csiSensorOutputResolution_QXGA:
// Set up CSI sensor frame and actual frame for QXGA resolution.
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, QXGA_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, QXGA_Height - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, QXGA_Width - 1 );
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, QXGA_Height - 1 );
break;
case csiSensorOutputResolution_UXGA:
// Set up CSI sensor frame and actual frame for UXGA resolution.
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, UXGA_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, UXGA_Height - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, UXGA_Width - 1 );
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, UXGA_Height - 1 );
break;
case csiSensorOutputResolution_SXGA:
// Set up CSI sensor frame and actual frame for SXGA resolution.
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, SXGA_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, SXGA_Height - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, SXGA_Width - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, SXGA_Height - 1);
break;
case csiSensorOutputResolution_XGA:
// Set up CSI sensor frame and actual frame for XGA resolution.
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, XGA_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, XGA_Height - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, XGA_Width - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, XGA_Height - 1);
break;
case csiSensorOutputResolution_SVGA:
// Set up CSI sensor frame and actual frame for SVGA resolution.
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, SVGA_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, SVGA_Height - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, SVGA_Width - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, SVGA_Height - 1);
break;
case csiSensorOutputResolution_VGA:
// Set up CSI sensor frame and actual frame for VGA resolution
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, VGA_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, VGA_Height - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, VGA_Width - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, VGA_Height - 1);
break;
case csiSensorOutputResolution_QVGA:
// Set up CSI sensor frame and actual frame for QVGA resolution
INSREG32(&csi_regs->CSI_SENS_FRM_SIZE,
CSP_BITFMASK(IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH),
CSP_BITFVAL(IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, QVGA_Width - 1));
INSREG32(&csi_regs->CSI_SENS_FRM_SIZE,
CSP_BITFMASK(IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT),
CSP_BITFVAL(IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, QVGA_Height - 1));
INSREG32(&csi_regs->CSI_ACT_FRM_SIZE,
CSP_BITFMASK(IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH),
CSP_BITFVAL(IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, QVGA_Width - 1));
INSREG32(&csi_regs->CSI_ACT_FRM_SIZE,
CSP_BITFMASK(IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT),
CSP_BITFVAL(IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, QVGA_Height - 1));
break;
case csiSensorOutputResolution_CIF:
// Set up CSI sensor frame and actual frame for CIF resolution
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, CIF_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, CIF_Height - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, CIF_Width - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, CIF_Height - 1);
break;
case csiSensorOutputResolution_QCIF:
// Set up CSI sensor frame and actual frame for QCIF resolution
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, QCIF_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, QCIF_Height - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, QCIF_Width - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, QCIF_Height - 1);
break;
case csiSensorOutputResolution_QQVGA:
// Set up CSI sensor frame and actual frame for QQVGA resolution
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, QQVGA_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, QQVGA_Height - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, QQVGA_Width - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, QQVGA_Height - 1);
break;
case csiSensorOutputResolution_D1_PAL:
// Set up CSI sensor frame and actual frame for QQVGA resolution
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, D1_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, D1_PAL_Height/iInterlaceScale - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, D1_Width - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, D1_PAL_Height/iInterlaceScale - 1);
break;
case csiSensorOutputResolution_D1_NTSC:
// Set up CSI sensor frame and actual frame for QQVGA resolution
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_WIDTH, D1_Width - 1);
INSREG32BF(&csi_regs->CSI_SENS_FRM_SIZE,
IPU_CSI_SENS_FRM_SIZE_SENS_FRM_HEIGHT, D1_NTSC_Height/iInterlaceScale - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_WIDTH, D1_Width - 1);
INSREG32BF(&csi_regs->CSI_ACT_FRM_SIZE,
IPU_CSI_ACT_FRM_SIZE_ACT_FRM_HEIGHT, D1_NTSC_Height/iInterlaceScale - 1);
break;
default:
return FALSE;
}
return TRUE;
}
//-----------------------------------------------------------------------------
//
// Function: CSISetVscHscSkip
//
// This function set vertical or Horizontal skip.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to config.
// dwVscSkip
// [in] The vertical skipped number of rows.
// dwHscSkip
// [in] The horizontal skipped number of columns.
//
// Returns:
// TRUE if success
// FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL CSISetVscHscSkip(CSI_SELECT csi_sel,DWORD dwVscSkip, DWORD dwHscSkip)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
//Vertical skip dwVscSkip number of rows
INSREG32BF(&csi_regs->CSI_OUT_FRM_CTRL, IPU_CSI_OUT_FRM_CTRL_VSC,
dwVscSkip);
//Horizontal skip dwHscSkip number of columns
INSREG32BF(&csi_regs->CSI_OUT_FRM_CTRL, IPU_CSI_OUT_FRM_CTRL_HSC,
dwHscSkip);
return TRUE;
}
//-----------------------------------------------------------------------------
//
// Function: CSISetDownSize
//
// This function set CSI downsize for horizotal or vertical.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to config.
// bVert
// [in] TRUE for enable vertical downsize by 2.FALSE for disable.
// bHorz
// [in] TRUE for enable horz downsize by 2.FALSE for disable.
//
// Returns:
// TRUE if success
// FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL CSISetVscHscDownSize(CSI_SELECT csi_sel,BOOL bVert, BOOL bHorz)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
// Vertical
if(bVert)
{
INSREG32BF(&csi_regs->CSI_OUT_FRM_CTRL, IPU_CSI_OUT_FRM_CTRL_HORZ_DWNS,
IPU_CSI_OUT_FRM_CTRL_HORZ_DWNS_ENABLE);
}
else
{
INSREG32BF(&csi_regs->CSI_OUT_FRM_CTRL, IPU_CSI_OUT_FRM_CTRL_HORZ_DWNS,
IPU_CSI_OUT_FRM_CTRL_HORZ_DWNS_DISABLE);
}
// horizontal
if(bHorz)
{
INSREG32BF(&csi_regs->CSI_OUT_FRM_CTRL, IPU_CSI_OUT_FRM_CTRL_VERT_DWNS,
IPU_CSI_OUT_FRM_CTRL_VERT_DWNS_ENABLE);
}
else
{
INSREG32BF(&csi_regs->CSI_OUT_FRM_CTRL, IPU_CSI_OUT_FRM_CTRL_VERT_DWNS,
IPU_CSI_OUT_FRM_CTRL_VERT_DWNS_DISABLE);
}
return TRUE;
}
//-----------------------------------------------------------------------------
//
// Function: CSISelectDI
//
// This function configure the Data Identifier handled by CSI.
//
// Parameters:
// csi_sel
// [in] Selects either the CSI0 or CSI1 to config.
// iDI
// [in] The data identifier:0~3.
// iDIValue
// [in] The data identifier value.
//
// Returns:
// TRUE if success
// FALSE if failure
//
//-----------------------------------------------------------------------------
BOOL CSISelectDI(CSI_SELECT csi_sel,UINT8 iDI,UINT8 iDIValue)
{
PCSP_IPU_CSI_REGS csi_regs = (csi_sel == CSI_SELECT_CSI0) ? g_pIPUV3_CSI0 : g_pIPUV3_CSI1;
switch(iDI)
{
case CSI_MIPI_DI0:
INSREG32BF(&csi_regs->CSI_DI, IPU_CSI_DI_MIPI_DI0,
iDIValue);
break;
case CSI_MIPI_DI1:
INSREG32BF(&csi_regs->CSI_DI, IPU_CSI_DI_MIPI_DI1,
iDIValue);
break;
case CSI_MIPI_DI2:
INSREG32BF(&csi_regs->CSI_DI, IPU_CSI_DI_MIPI_DI2,
iDIValue);
break;
case CSI_MIPI_DI3:
INSREG32BF(&csi_regs->CSI_DI, IPU_CSI_DI_MIPI_DI3,
iDIValue);
break;
default:
ERRORMSG(TRUE,(TEXT("%s:CSI Set Data identifier failed\r\n"),__WFUNCTION__));
return FALSE;
}
return TRUE;
}
void CSIDumpRegs(CSI_SELECT csi_sel)
{
int i,num;
UINT32* ptr;
if (csi_sel == CSI_SELECT_CSI0)
{
ptr = (UINT32 *)&g_pIPUV3_CSI0->CSI_SENS_CONF;
num = 0;
}
else
{
ptr = (UINT32 *)&g_pIPUV3_CSI1->CSI_SENS_CONF;
num = 1;
}
RETAILMSG (1, (TEXT("\n\nCSI %d Registers\n"),num));
for (i = 0; i <= (sizeof(CSP_IPU_CSI_REGS) / 16); i++)
{
RETAILMSG (1, (TEXT("Address %08x %08x %08x %08x %08x\n"), (UINT32)ptr, INREG32(ptr), INREG32(ptr+1), INREG32(ptr+2), INREG32(ptr+3)));
ptr += 4;
}
}
| [
"lqk.sch@gmail.com@9677f95b-f147-b01e-6ec8-0db75aaa1bab"
] | lqk.sch@gmail.com@9677f95b-f147-b01e-6ec8-0db75aaa1bab |
b60f9cb7b83c69396af47cb213251abba19586d5 | f1bd83e9dc0266c10f43a1648d798f5efd189e6a | /main.cpp | 8818cfcc689f073b42bba15806349f2a6b9723ae | [
"MIT"
] | permissive | gshep/SceneSample | c4697de648ee11e37e1f2b582edf43defa48ab82 | df414805899a4ef7e76d62840c2173934bcc6dd6 | refs/heads/master | 2020-11-28T07:12:49.221246 | 2019-12-23T11:32:16 | 2019-12-23T11:32:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,594 | cpp | #include <QApplication>
#include <QQuickView>
#include <QQmlEngine>
#include "Scene.hpp"
#include "LogTrackSceneCameraManipulator.hpp"
#include "LineStrip.hpp"
class Helper : public QObject
{
Q_OBJECT
public:
enum Direction
{
Horizontal = 0x1,
Vertical = 0x2
};
Q_DECLARE_FLAGS(Directions, Direction)
public:
Helper(rogii::qt_quick::Scene * scene)
: QObject(scene)
, mScene(scene)
, mFlags(Directions().setFlag(Horizontal).setFlag(Vertical))
{
}
Directions & getFlags()
{
return mFlags;
}
public Q_SLOTS:
void onShift(double dx, double dy)
{
rogii::qt_quick::LogTrackSceneCameraManipulator m(mScene->getSceneCamera());
const double trueDx = (mFlags.testFlag(Horizontal) ? dx : 0);
const double trueDy = (mFlags.testFlag(Vertical) ? dy : 0);
m.shift(trueDx, trueDy);
}
void onZoom(double step, QPointF pivot)
{
rogii::qt_quick::LogTrackSceneCameraManipulator m(mScene->getSceneCamera());
const double trueX = (mFlags.testFlag(Horizontal) ? pivot.x() : 0);
const double trueY = (mFlags.testFlag(Vertical) ? pivot.y() : 0);
m.zoom(step, QPoint(trueX, trueY));
}
private:
rogii::qt_quick::Scene * mScene;
Directions mFlags;
};
int main(int argc, char * argv[])
{
QApplication::setAttribute(Qt::AA_UseOpenGLES);
QApplication::setAttribute(Qt::AA_DisableHighDpiScaling);
QApplication app(argc, argv);
qmlRegisterType<rogii::qt_quick::Scene>("ROGII.QtQuick", 1, 0, "Scene");
qmlRegisterType<LineStrip>("ROGII.QtQuick", 1, 0, "LineStrip");
QQuickView view;
view.engine()->addImportPath(QCoreApplication::applicationDirPath() + QStringLiteral("/qml"));
view.resize(800, 400);
view.setResizeMode(QQuickView::SizeRootObjectToView);
view.setSource(QUrl("qrc:///SceneSample/main.qml"));
view.show();
{
auto * scene1 = view.rootObject()->findChild<rogii::qt_quick::Scene *>(QLatin1String("scene1"));
auto * shiftArea = scene1->findChild<QQuickItem *>(QLatin1String("sceneMouseArea"));
auto * h = new Helper(scene1);
QObject::connect(shiftArea, SIGNAL(shift(double, double)),
h, SLOT(onShift(double, double)));
QObject::connect(shiftArea, SIGNAL(zoom(double, QPointF)),
h, SLOT(onZoom(double, QPointF)));
h->getFlags().setFlag(Helper::Horizontal, false);
}
{
auto * scene = view.rootObject()->findChild<rogii::qt_quick::Scene *>(QLatin1String("scene2"));
auto * shiftArea = scene->findChild<QQuickItem *>(QLatin1String("sceneMouseArea"));
auto * h = new Helper(scene);
QObject::connect(shiftArea, SIGNAL(shift(double, double)),
h, SLOT(onShift(double, double)));
QObject::connect(shiftArea, SIGNAL(zoom(double, QPointF)),
h, SLOT(onZoom(double, QPointF)));
h->getFlags().setFlag(Helper::Vertical, false);
}
{
auto * scene = view.rootObject()->findChild<rogii::qt_quick::Scene *>(QLatin1String("scene3"));
auto * shiftArea = scene->findChild<QQuickItem *>(QLatin1String("sceneMouseArea"));
auto * h = new Helper(scene);
QObject::connect(shiftArea, SIGNAL(shift(double, double)),
h, SLOT(onShift(double, double)));
QObject::connect(shiftArea, SIGNAL(zoom(double, QPointF)),
h, SLOT(onZoom(double, QPointF)));
}
return app.exec();
}
#include "main.moc"
| [
"g.shepelev@rogii.com"
] | g.shepelev@rogii.com |
5865f9ff74c46f117f11e06d67430383c5d5408a | 084a60f0bb0285e62f83d75a0dfbfa651d17c6d7 | /7 reverse.cpp | 9b5b84253a9d71bae57688f70da78cb8f57454d2 | [] | no_license | rogerzhu0710/leetcode | 7094605e90ea3134d4284aed5b3b0baea6d5ddd4 | 3f01f50ea4e03011e2cbc79148294e83715ebe6a | refs/heads/master | 2021-01-20T06:25:23.078105 | 2015-08-12T05:20:37 | 2015-08-12T05:20:37 | 40,573,689 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 495 | cpp | int reverse(int x)
{
int c=0;
while(x!=0)
{
int tmp = x%10;
// inspire by the Internet knowledge
if(c>0)
{
if( c > INT_MAX/10 ) return 0;
else if(c == INT_MAX/10 && tmp>INT_MAX%10) return 0;
}
else
{
if( c < INT_MIN/10 ) return 0;
else if(c == INT_MIN/10 && tmp<INT_MIN%10) return 0;
}
c = c*10 +tmp;
x=x/10;
}
return c;
} | [
"rogerzhu0710@126.com"
] | rogerzhu0710@126.com |
6d1ed247ec700614fd1fce9cf27517505343109f | da8c15523d81c47882adfe11f3d7846dcb1a5acd | /include/stx/panic/hook.h | 023ab06a8ff95cb86a5655b9e8a5c1de1453da18 | [
"MIT"
] | permissive | frankfan007/STX | 7a8b9cf0f849c91da90512245df7947f4c4f8971 | 03ee6533944b5719e05ef65d920559084fd722a1 | refs/heads/master | 2022-09-17T09:58:15.917771 | 2020-06-03T05:56:58 | 2020-06-03T05:56:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,792 | h | /**
* @file hook.h
* @author Basit Ayantunde <rlamarrr@gmail.com>
* @brief
* @version 0.1
* @date 2020-05-08
*
* @copyright Copyright (c) 2020
*
*/
#pragma once
#include <atomic>
#include "stx/panic.h"
//! @file
//!
//! Hooks are useful for writing device drivers where you load the drivers at
//! runtime as a DLL. As the default behaviour is to log to stderr and abort, In
//! drivers and safety-critical software, You often don't want a driver failure
//! to cause the whole program to immediately cause the whole program to abort
//! due to a panic from the drivers. Hooks allow you to control the panic
//! behaviour at runtime.
//!
//!
//! # NOTE
//!
//! You might have to do some extra demangling as it is not exposed via a
//! C ABI for consistency and internal reasons.
//!
//! Process:
//! - Check if hooks are available for attaching: `has_panic_hook()`
//! - If hooks are available, attach a panic hook:
//! `attach_panic_hook(my_handler)` or reset the exisiting panic hook back to
//! the default: `take_panic_hook()`
//!
//!
namespace stx {
#if defined(STX_VISIBLE_PANIC_HOOK)
constexpr bool kVisiblePanicHook = true;
#else
constexpr bool kVisiblePanicHook = false;
#endif
// multiple threads can try to modify/read the hook at once.
using PanicHook = decltype(panic_handler)*;
using AtomicPanicHook = std::atomic<PanicHook>;
namespace this_thread {
/// Checks if the current thread is panicking.
///
/// # THREAD-SAFETY
/// thread-safe.
[[nodiscard]] STX_EXPORT bool is_panicking() noexcept;
}; // namespace this_thread
/// Checks if panic hooks are visible to be attached-to when loaded as a dynamic
/// library. This should be called before calling any of `attach_panic_hook` or
/// `take_panic_hook` when loaded as a dynamic library.
///
/// # THREAD-SAFETY
///
/// thread-safe.
[[nodiscard]] STX_EXPORT bool panic_hook_visible() noexcept;
/// Attaches a new panic hook, the attached panic hook is called in place of the
/// default panic hook.
///
/// Returns `true` if the thread is not panicking and the panic hook was
/// successfully attached, else returns `false`.
///
/// # THREAD-SAFETY
///
/// thread-safe.
[[nodiscard]]
#if defined(STX_VISIBLE_PANIC_HOOK)
STX_EXPORT
#else
STX_LOCAL
#endif
bool
attach_panic_hook(PanicHook hook) noexcept;
/// Removes the registered panic hook (if any) and resets it to the
/// default panic hook.
/// `hook` is set to the last-registered panic hook or the default.
///
/// Returns `true` if the thread is not panicking and the panic hook was
/// successfully taken, else returns `false`.
///
/// # THREAD-SAFETY
///
/// thread-safe.
[[nodiscard]]
#if defined(STX_VISIBLE_PANIC_HOOK)
STX_EXPORT
#else
STX_LOCAL
#endif
bool
take_panic_hook(PanicHook* hook) noexcept;
}; // namespace stx
| [
"rlamarrr@gmail.com"
] | rlamarrr@gmail.com |
55b82d6f7d83309b010cf62538ce118a03e88f95 | ddd70b6df257a2cb3be8b468f355744965bf740e | /src/slg/film/sampleresult.cpp | dc9edba27d1fddb347ba2059b9a839f8d40b33f8 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | MetaRabbit/LuxCore | 2e0e1c4cfc6865dc03d2750c26cca6281cfa541c | ee4d881d7ccf64fb6bb29845d7af0409ef8fd3b9 | refs/heads/master | 2020-05-17T18:44:07.182847 | 2019-04-28T09:10:50 | 2019-04-28T09:10:50 | 183,893,762 | 1 | 0 | Apache-2.0 | 2019-04-28T10:31:30 | 2019-04-28T10:31:29 | null | UTF-8 | C++ | false | false | 4,675 | cpp | /***************************************************************************
* Copyright 1998-2018 by authors (see AUTHORS.txt) *
* *
* This file is part of LuxCoreRender. *
* *
* 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 "slg/film/film.h"
#include "slg/film/sampleresult.h"
using namespace std;
using namespace luxrays;
using namespace slg;
//------------------------------------------------------------------------------
// SampleResult
//------------------------------------------------------------------------------
void SampleResult::Init(const u_int channelTypes, const u_int radianceGroupCount) {
channels = channelTypes;
if ((channels & Film::RADIANCE_PER_PIXEL_NORMALIZED) && (channels & Film::RADIANCE_PER_SCREEN_NORMALIZED))
throw runtime_error("RADIANCE_PER_PIXEL_NORMALIZED and RADIANCE_PER_SCREEN_NORMALIZED, both used in SampleResult");
else if ((channels & Film::RADIANCE_PER_PIXEL_NORMALIZED) || (channels & Film::RADIANCE_PER_SCREEN_NORMALIZED))
radiance.resize(radianceGroupCount);
else
radiance.resize(0);
firstPathVertexEvent = NONE;
firstPathVertex = true;
// lastPathVertex can not be really initialized here without knowing
// the max. path depth.
lastPathVertex = false;
passThroughPath = true;
}
Spectrum SampleResult::GetSpectrum(const vector<RadianceChannelScale> &radianceChannelScales) const {
Spectrum s = 0.f;
for (u_int i = 0; i < radiance.size(); ++i)
s += radianceChannelScales[i].Scale(radiance[i]);
return s;
}
float SampleResult::GetY(const vector<RadianceChannelScale> &radianceChannelScales) const {
return GetSpectrum(radianceChannelScales).Y();
}
void SampleResult::AddEmission(const u_int lightID, const Spectrum &pathThroughput,
const Spectrum &incomingRadiance) {
const Spectrum r = pathThroughput * incomingRadiance;
radiance[lightID] += r;
if (firstPathVertex)
emission += r;
else {
indirectShadowMask = 0.f;
if (firstPathVertexEvent & DIFFUSE)
indirectDiffuse += r;
else if (firstPathVertexEvent & GLOSSY)
indirectGlossy += r;
else if (firstPathVertexEvent & SPECULAR)
indirectSpecular += r;
}
}
void SampleResult::AddDirectLight(const u_int lightID, const BSDFEvent bsdfEvent,
const Spectrum &pathThroughput, const Spectrum &incomingRadiance, const float lightScale) {
const Spectrum r = pathThroughput * incomingRadiance;
radiance[lightID] += r;
if (firstPathVertex) {
// directShadowMask is supposed to be initialized to 1.0
directShadowMask = Max(0.f, directShadowMask - lightScale);
if (bsdfEvent & DIFFUSE)
directDiffuse += r;
else
directGlossy += r;
} else {
// indirectShadowMask is supposed to be initialized to 1.0
indirectShadowMask = Max(0.f, indirectShadowMask - lightScale);
if (firstPathVertexEvent & DIFFUSE)
indirectDiffuse += r;
else if (firstPathVertexEvent & GLOSSY)
indirectGlossy += r;
else if (firstPathVertexEvent & SPECULAR)
indirectSpecular += r;
irradiance += irradiancePathThroughput * incomingRadiance;
}
}
void SampleResult::ClampRadiance(const float minRadiance, const float maxRadiance) {
for (u_int i = 0; i < radiance.size(); ++i)
radiance[i] = radiance[i].ScaledClamp(minRadiance, maxRadiance);
}
bool SampleResult::IsValid() const {
for (u_int i = 0; i < radiance.size(); ++i)
if (radiance[i].IsNaN() || radiance[i].IsInf() || radiance[i].IsNeg())
return false;
return true;
}
bool SampleResult::IsAllValid(const vector<SampleResult> &sampleResults) {
for (u_int i = 0; i < sampleResults.size(); ++i)
if (!sampleResults[i].IsValid())
return false;
return true;
}
| [
"dade916@gmail.com"
] | dade916@gmail.com |
fcbe7d7f24cffbe39d022ccebd4e85db24da015c | f83ef53177180ebfeb5a3e230aa29794f52ce1fc | /ACE/ACE_wrappers/TAO/tests/RTCORBA/check_supported_priorities.cpp | 11ff3473e08d110c9dc70733c99781ab05944c6f | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-sun-iiop"
] | permissive | msrLi/portingSources | fe7528b3fd08eed4a1b41383c88ee5c09c2294ef | 57d561730ab27804a3172b33807f2bffbc9e52ae | refs/heads/master | 2021-07-08T01:22:29.604203 | 2019-07-10T13:07:06 | 2019-07-10T13:07:06 | 196,183,165 | 2 | 1 | Apache-2.0 | 2020-10-13T14:30:53 | 2019-07-10T10:16:46 | null | UTF-8 | C++ | false | false | 2,142 | cpp | #include "ace/Sched_Params.h"
#include "tao/ORB_Core.h"
#include "tao/ORB.h"
#include "tao/RTCORBA/Priority_Mapping_Manager.h"
#include "tao/Protocols_Hooks.h"
const char *
sched_policy_name (int sched_policy)
{
const char *name = 0;
switch (sched_policy)
{
case ACE_SCHED_OTHER:
name = "SCHED_OTHER";
break;
case ACE_SCHED_RR:
name = "SCHED_RR";
break;
case ACE_SCHED_FIFO:
name = "SCHED_FIFO";
break;
}
return name;
}
bool
check_supported_priorities (CORBA::ORB_ptr orb)
{
int sched_policy =
orb->orb_core ()->orb_params ()->ace_sched_policy ();
// Check that we have sufficient priority range to run this test,
// i.e., more than 1 priority level.
int max_priority =
ACE_Sched_Params::priority_max (sched_policy);
int min_priority =
ACE_Sched_Params::priority_min (sched_policy);
if (max_priority == min_priority)
{
ACE_DEBUG ((LM_DEBUG,
"Not enough priority levels with the %C scheduling policy\n"
"on this platform to run the test, terminating program....\n"
"Check svc.conf options\n",
sched_policy_name (sched_policy)));
return false;
}
return true;
}
CORBA::Short
get_implicit_thread_CORBA_priority (CORBA::ORB_ptr orb)
{
CORBA::Object_var obj =
orb->resolve_initial_references (TAO_OBJID_PRIORITYMAPPINGMANAGER);
TAO_Priority_Mapping_Manager_var mapping_manager =
TAO_Priority_Mapping_Manager::_narrow (obj.in ());
if (CORBA::is_nil (mapping_manager.in ()))
throw CORBA::INTERNAL ();
RTCORBA::PriorityMapping *pm =
mapping_manager.in ()->mapping ();
TAO_Protocols_Hooks *tph =
orb->orb_core ()->get_protocols_hooks ();
CORBA::Short corba_priority;
CORBA::Short native_priority;
if (tph->get_thread_native_priority (native_priority) == 0 &&
pm->to_CORBA (native_priority, corba_priority))
{
return corba_priority;
}
ACE_DEBUG ((LM_DEBUG, "get_implicit_thread_CORBA_priority - failed to access priority\n"));
throw CORBA::DATA_CONVERSION (CORBA::OMGVMCID | 2, CORBA::COMPLETED_NO);
}
| [
"lihuibin705@163.com"
] | lihuibin705@163.com |
84096a62389c78994ade1992ed18dfc66fe0d58a | 1eee2028c8168a8c249688a45931dc4febf1cf99 | /Triturador/CodeBlocks Triturador/src/Robot.cpp | 4747d0781ede725d48ea22c1fe74ad65c433236b | [] | no_license | aaronR221/Est_OO | a0288b18786f12735e4e163ee544c209bda8a82e | 06ddd00091855aef1d851798e851651d73879ec0 | refs/heads/master | 2020-09-06T02:10:54.448635 | 2019-11-08T15:06:15 | 2019-11-08T15:06:15 | 220,283,385 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 265 | cpp | #include "Robot.h"
#include <iostream>
using namespace std;
Robot::Robot()
{
cout<<"nasce um robo"<<endl;
}
Robot::~Robot()
{
cout<< "Aposenta um Robo" << endl;
}
int Robot::getNumeroMotores()
int Robot::getNumeroSensores()
int Robot::getNivelBateria()
| [
"aaron.ramires2@hotmail.com"
] | aaron.ramires2@hotmail.com |
1e56e9eae26b9fe27721445bf813eb3bb1f89d0a | 3ca1087b5dad5577fd6fcf072c195579b36d9fe8 | /06Polymorphism_Classes/LISTING.cpp | fd97c19170fc762e18fcbfe52fd98811eeec54b5 | [] | no_license | CS-Pacific-University/06polymorphism-jcorey1313 | e29a2358222adb2cd04a349be7b02dbc22bc19ef | aad349319cd223f0f80b8d5a04412c1531b6dd0b | refs/heads/master | 2023-04-23T14:19:17.550120 | 2021-05-03T10:25:27 | 2021-05-03T10:25:27 | 362,276,859 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 21,551 | cpp | //############################################################################
//Letter.h
//############################################################################
//****************************************************************************
// File name: Letter.h
// Author: James Corey
// Date: 05/03/2021
// Class: CS250
// Assignment: Polymorphism
// Purpose: header for class that represents a letter
//****************************************************************************
#pragma once
#include "Parcel.h"
class Letter : public Parcel {
public:
Letter ();
int getDeliveryDay () const;
void setCost ();
double addInsurance ();
double addRush ();
};
//############################################################################
//Overnight.h
//############################################################################
//****************************************************************************
// File name: Overnight.h
// Author: James Corey
// Date: 05/03/2021
// Class: CS250
// Assignment: Polymorphism
// Purpose: header for class that represents an overnight package
//****************************************************************************
#pragma once
#include "Parcel.h"
class Overnight : public Parcel {
public:
Overnight ();
bool read (istream&);
void print (ostream&) const;
int getDeliveryDay () const;
void setCost ();
double addInsurance ();
double addRush ();
private:
double mVolume;
};
//############################################################################
//Parcel.h
//############################################################################
//****************************************************************************
// File name: Parcel.h
// Author: James Corey
// Date: 05/03/2021
// Class: CS250
// Assignment: Polymorphism
// Purpose: header that represents a parcel to be mailed
//****************************************************************************
#pragma once
#include <iostream>
using namespace std;
class Parcel {
public:
Parcel ();
virtual bool read (istream& rcIn);
virtual void print (ostream& rcOut) const;
double getCost () const;
virtual int getDeliveryDay () const = 0;
virtual void setCost () = 0;
virtual double addInsurance() = 0;
virtual double addRush() = 0;
protected:
int mWeight;
int mDistance;
int mTrackingID;
bool mbInsured = false;
bool mbRushed = false;
bool mbDelivered = false;
string mFrom;
string mTo;
double mCost;
};
//############################################################################
//Postcard.h
//############################################################################
//****************************************************************************
// File name: Postcard.h
// Author: James Corey
// Date: 05/03/2021
// Class: CS250
// Assignment: Polymorphism
// Purpose: header for class that represents a postcard
//****************************************************************************
#pragma once
#include "Parcel.h"
class Postcard : public Parcel {
public:
Postcard ();
bool read (istream&);
void print (ostream&) const;
int getDeliveryDay () const;
void setCost ();
double addInsurance ();
double addRush ();
private:
string mMessage;
};
//############################################################################
//Letter.cpp
//############################################################################
//****************************************************************************
// File name: Letter.cpp
// Author: James Corey
// Date: 05/03/2021
// Class: CS250
// Assignment: Polymorphism
// Purpose: defines the letter class
//****************************************************************************
#include "Letter.h"
#include <iostream>
Letter::Letter () : Parcel () {
}
//****************************************************************************
// Function: getDeliveryDay
//
// Description: calculates the number of days until the letter is delivered
//
// Parameters: none
//
// Returned: number of days until the letter is delivered
//****************************************************************************
int Letter::getDeliveryDay () const {
const int MIN_DAYS = 1;
const int MILES_PER_DAY = 100;
int numDays = mDistance / MILES_PER_DAY;
if (mDistance % MILES_PER_DAY != 0) {
numDays++;
}
if (mbRushed) {
if (numDays != MIN_DAYS) {
numDays--;
}
}
return numDays;
}
//****************************************************************************
// Function: setCost
//
// Description: sets the cost of the letter to the base cost
//
// Parameters: none
//
// Returned: none
//****************************************************************************
void Letter::setCost () {
const double DOLLAR_PER_OUNCE = 0.45;
mCost = mWeight * DOLLAR_PER_OUNCE;
}
//****************************************************************************
// Function: addInsurance
//
// Description: calculates the cost of adding insurance to a letter, adds
// the cost to the total cost
//
// Parameters: None
//
// Returned: The cost of adding insurance
//****************************************************************************
double Letter::addInsurance () {
double insuranceCost = 0;
const double INSURANCE_COST = 0.45;
if (!mbInsured) {
mCost += INSURANCE_COST;
mbInsured = true;
insuranceCost = INSURANCE_COST;
}
return insuranceCost;
}
//****************************************************************************
// Function: addRush
//
// Description: calculates the cost of rushing a letter, adds the cost to
// the total cost
//
// Parameters: None
//
// Returned: The cost of adding rush
//****************************************************************************
double Letter::addRush () {
double rushCost = 0;
double originalCost = mCost;
const double RUSH_MULTIPLIER = 0.1;
if (!mbRushed) {
mCost *= RUSH_MULTIPLIER;
mbRushed = true;
rushCost = mCost - originalCost;
}
return rushCost;
}
//############################################################################
//Overnight.cpp
//############################################################################
//****************************************************************************
// File name: Overnight.cpp
// Author: James Corey
// Date: 05/03/2021
// Class: CS250
// Assignment: Polymorphism
// Purpose: defines the Overnight class
//****************************************************************************
#include "Overnight.h"
//****************************************************************************
// Constructor: Overnight
//
// Description: Default constructor for Overnight class, sets ints to 0 and
// strings to ""
//
// Parameters: none
//
// Returned: none
//****************************************************************************
Overnight::Overnight () : Parcel () {
mVolume = 0;
}
//****************************************************************************
// Function: read
//
// Description: reads in the data from an Overnight Package to a stream
//
// Parameters: rcIn - the stream to read from
//
// Returned: true if the data is read in, or else false
//****************************************************************************
bool Overnight::read (istream& rcInput) {
bool bIsRead = Parcel::read (rcInput);
if (bIsRead && rcInput >> mVolume) {
bIsRead = true;
}
return bIsRead;
}
//****************************************************************************
// Function: Print
//
// Description: prints the overnight parcel to a stream
//
// Parameters: rcOut - stream to be output to
//
// Returned: None
//****************************************************************************
void Overnight::print (ostream& rcOutput) const {
Parcel::print (rcOutput);
rcOutput << "\t OVERNIGHT!";
}
//****************************************************************************
// Function: getDeliveryDay
//
// Description: calculates the number of days until the overnight package is
// delivered
//
// Parameters: none
//
// Returned: number of days until the package is delivered
//****************************************************************************
int Overnight::getDeliveryDay () const {
const int MIN_DAYS = 1;
const int MAX_DAYS = 2;
const int MILES_PER_DAY = 1000;
int numDays;
if (mDistance <= MILES_PER_DAY || mbRushed) {
numDays = MIN_DAYS;
}
else {
numDays = MAX_DAYS;
}
return numDays;
}
//****************************************************************************
// Function: setCost
//
// Description: sets the cost of the overnight package to the base cost
//
// Parameters: none
//
// Returned: none
//****************************************************************************
void Overnight::setCost () {
const int MIN_COST = 12;
const int MAX_COST = 20;
const int VOLUME_CUTOFF = 100;
if (mVolume > VOLUME_CUTOFF) {
mCost = MAX_COST;
}
else {
mCost = MIN_COST;
}
}
//****************************************************************************
// Function: addInsurance
//
// Description: calculates the cost of adding insurance to a package, adds
// the cost to the total cost
//
// Parameters: None
//
// Returned: The cost of adding insurance
//****************************************************************************
double Overnight::addInsurance () {
double insuranceCost = 0;
double originalCost = mCost;
const double INSURANCE_MULTIPLIER = 0.25;
if (!mbInsured) {
mCost *= INSURANCE_MULTIPLIER;
mbInsured = true;
insuranceCost = mCost - originalCost;
}
return insuranceCost;
}
//****************************************************************************
// Function: addRush
//
// Description: calculates the cost of rushing an overnight package, adds
// the cost to the total cost
//
// Parameters: None
//
// Returned: The cost of adding rush
//****************************************************************************
double Overnight::addRush () {
double rushCost = 0;
double originalCost = mCost;
const double RUSH_MULTIPLIER = 1.75;
if (!mbRushed) {
mCost *= RUSH_MULTIPLIER;
mbRushed = true;
rushCost = mCost - originalCost;
}
return rushCost;
}
//############################################################################
//Parcel.cpp
//############################################################################
//****************************************************************************
// File name: Parcel.cpp
// Author: James Corey
// Date: 05/03/2021
// Class: CS250
// Assignment: Polymorphism
// Purpose: defines the parcel parent class
//****************************************************************************
#pragma once
#include "Parcel.h"
//****************************************************************************
// Constructor: Parcel
//
// Description: Default constructor for Parcel class, sets ints to 0 and
// strings to "" for the variables that all 3 classes use
//
// Parameters: none
//
// Returned: none
//****************************************************************************
Parcel::Parcel () {
mTrackingID = mWeight = mDistance = 0;
mTo = mFrom = "null";
}
//****************************************************************************
// Function: read
//
// Description: reads in the data to a stream, format that all 3 child classes
// use
//
// Parameters: rcIn - the stream to read from
//
// Returned: true if the data is read in, or else false
//****************************************************************************
bool Parcel::read (istream& rcIn) {
bool bIsRead = false;
if (rcIn >> mTrackingID >> mTo >> mFrom >> mWeight >> mDistance) {
bIsRead = true;
}
return bIsRead;
}
//****************************************************************************
// Function: Print
//
// Description: format of printing the data that all 3 child classes use
//
// Parameters: rcOut - stream to be output to
//
// Returned: None
//****************************************************************************
void Parcel::print (ostream& rcOut) const {
rcOut << "TID: " << mTrackingID << " From: " << mFrom << " To: " << mTo;
if (mbInsured) {
cout << "\t INSURED";
}
if (mbRushed) {
cout << "\t RUSH";
}
}
//****************************************************************************
// Function: getCost
//
// Description: returns the cost of the parcel
//
// Parameters: None
//
// Returned: mCost, the cost of the parcel
//****************************************************************************
double Parcel::getCost () const {
return mCost;
}
//############################################################################
//Postcard.cpp
//############################################################################
//****************************************************************************
// File name: Postcard.cpp
// Author: James Corey
// Date: 05/03/2021
// Class: CS250
// Assignment: Polymorphism
// Purpose: defines the postcard class
//****************************************************************************
#include "Postcard.h"
//****************************************************************************
// Constructor: Postcard
//
// Description: Default constructor for Postcard class, sets ints to 0 and
// strings to ""
//
// Parameters: none
//
// Returned: none
//****************************************************************************
Postcard::Postcard () : Parcel () {
mMessage = "null";
}
//****************************************************************************
// Function: read
//
// Description: reads in the data from a Postcard to a stream
//
// Parameters: rcIn - the stream to read from
//
// Returned: true if the data is read in, or else false
//****************************************************************************
bool Postcard::read (istream& rcIn) {
bool bIsRead = Parcel::read (rcIn);
if (bIsRead && rcIn >> mMessage) {
bIsRead = true;
}
else {
bIsRead = false;
}
return (bIsRead);
}
//****************************************************************************
// Function: Print
//
// Description: prints the postcard to a stream
//
// Parameters: rcOut - stream to be output to
//
// Returned: None
//****************************************************************************
void Postcard::print (ostream& rcOut) const{
Parcel::print (rcOut);
rcOut << "\t" << mMessage;
}
//****************************************************************************
// Function: setCost
//
// Description: sets the cost of the postcard to the base cost
//
// Parameters: none
//
// Returned: none
//****************************************************************************
void Postcard::setCost () {
const double BASE_COST = 0.15;
mCost = BASE_COST;
}
//****************************************************************************
// Function: getDeliveryDay
//
// Description: calculates the number of days until the postcard is
// delivered
//
// Parameters: none
//
// Returned: number of days until the letter is delivered
//****************************************************************************
int Postcard::getDeliveryDay () const {
const int MILES_PER_DAY = 10;
const int DAYS_RUSHED = 2;
const int MIN_DAYS = 1;
int numDays = mDistance / MILES_PER_DAY;
if (mDistance % MILES_PER_DAY != 0) {
numDays++;
}
if (mbRushed) {
numDays -= DAYS_RUSHED;
if (numDays < MIN_DAYS) {
numDays = MIN_DAYS;
}
}
return numDays;
}
//****************************************************************************
// Function: addInsurance
//
// Description: calculates the cost of adding insurance to a postcard, adds
// the cost to the total cost
//
// Parameters: None
//
// Returned: The cost of adding insurance
//****************************************************************************
double Postcard::addInsurance () {
double insuranceCost = 0;
const double INSURANCE_COST = 0.15;
if (!mbInsured) {
mCost += INSURANCE_COST;
mbInsured = true;
insuranceCost = INSURANCE_COST;
}
return insuranceCost;
}
//****************************************************************************
// Function: addRush
//
// Description: calculates the cost of rushing a postcard, adds the cost to
// the total cost
//
// Parameters: None
//
// Returned: The cost of adding rush
//****************************************************************************
double Postcard::addRush () {
double rushCost = 0;
const double RUSH_COST = 0.25;
if (!mbRushed) {
mCost += RUSH_COST;
mbRushed = true;
rushCost = RUSH_COST;
}
return rushCost;
}
//############################################################################
//Source.cpp
//############################################################################
//****************************************************************************
// File name: Source.cpp
// Author: James Corey
// Date: 05/03/2021
// Class: CS250
// Assignment: Polymorphism
// Purpose: Using polymorphism to create a simulation of a mail service
// Hours: 9
//****************************************************************************
#include "Letter.h"
#include "Postcard.h"
#include "Overnight.h"
#include <iomanip>
#include <fstream>
void printMenu ();
int main () {
const int PRINT = 1;
const int INSURANCE = 2;
const int RUSH = 3;
const int DELIVER = 4;
const int QUIT = 5;
const int MAX_PARCELS = 25;
const int TID_ADJUSTMENT = 1;
const int DECIMAL_SPOTS = 2;
const char LETTER = 'L';
const char OVERNIGHT_PACKAGE = 'O';
const char POSTCARD = 'P';
const string INPUT_FILE = "Parcel.txt";
ifstream inputFile;
char whichParcel;
Parcel* apcParcels [MAX_PARCELS] = { nullptr };
int numParcels = 0;
int tID, menuChoice;
double insuranceCost, rushCost;
cout << "Mail Simulator!" << endl;
inputFile.open (INPUT_FILE);
if (!inputFile.is_open ()) {
cout << "Could not open file.";
return EXIT_FAILURE;
}
else {
while (inputFile >> whichParcel) {
if (whichParcel == LETTER) {
apcParcels [numParcels] = new Letter;
}
else if (whichParcel == OVERNIGHT_PACKAGE) {
apcParcels [numParcels] = new Overnight;
}
else if (whichParcel == POSTCARD) {
apcParcels [numParcels] = new Postcard;
}
apcParcels [numParcels]->read (inputFile);
apcParcels [numParcels]->setCost ();
numParcels++;
}
do {
printMenu ();
do {
cout << "Choice> ";
cin >> menuChoice;
cout << endl;
}
while (menuChoice != PRINT && menuChoice != INSURANCE
&& menuChoice != RUSH && menuChoice != DELIVER
&& menuChoice != QUIT);
if (menuChoice == PRINT) {
for (int i = 0; i < numParcels; i++) {
if (apcParcels [i] != nullptr) {
apcParcels [i]->print (cout);
cout << endl;
}
}
}
else if (menuChoice == INSURANCE) {
cout << "TID> ";
cin >> tID;
if (tID > 0 && tID <= numParcels) {
insuranceCost = apcParcels [tID - TID_ADJUSTMENT]->addInsurance ();
cout << "Added Insurance for $" << fixed
<< setprecision (DECIMAL_SPOTS) << insuranceCost << endl;
apcParcels [tID - TID_ADJUSTMENT]->print (cout);
cout << endl;
}
}
else if (menuChoice == RUSH) {
cout << "TID> ";
cin >> tID;
if (tID > 0 && tID <= numParcels) {
rushCost = apcParcels [tID - TID_ADJUSTMENT]->addRush ();
cout << "Added Rush for $ " << fixed
<< setprecision (DECIMAL_SPOTS) << rushCost << endl;
apcParcels [tID - TID_ADJUSTMENT]->print (cout);
cout << endl;
}
}
else if (menuChoice == DELIVER) {
cout << "TID> ";
cin >> tID;
if (tID > 0 && tID <= numParcels) {
cout << "Delivered!" << endl;
cout << apcParcels [tID - TID_ADJUSTMENT]->getDeliveryDay ()
<< " Day, $" << fixed << setprecision (DECIMAL_SPOTS)
<< apcParcels [tID - TID_ADJUSTMENT]->getCost () << endl;
apcParcels [tID - TID_ADJUSTMENT]->print (cout);
delete apcParcels [tID - TID_ADJUSTMENT];
apcParcels [tID - TID_ADJUSTMENT] = nullptr;
cout << endl;
}
}
}
while (menuChoice != QUIT);
for (int i = 0; i < numParcels; i++) {
delete apcParcels [i];
}
inputFile.close();
return EXIT_SUCCESS;
}
}
void printMenu() {
const string OPTION_1_PRINT = "1. Print All";
const string OPTION_2_INSURANCE = "2. Add Insurance";
const string OPTION_3_RUSH = "3. Add Rush";
const string OPTION_4_DELIVER = "4. Deliver";
const string OPTION_5_QUIT = "5. Quit";
cout << endl << OPTION_1_PRINT << endl << OPTION_2_INSURANCE << endl
<< OPTION_3_RUSH << endl << OPTION_4_DELIVER << endl << OPTION_5_QUIT
<< endl << endl;
}
| [
"core9711@pacificu.edu"
] | core9711@pacificu.edu |
fba8eeb0297f68350f93361720d6ef792494b4f7 | 90c95fd7a5687b1095bf499892b8c9ba40f59533 | /sprout/weed/parser/directive/as_tuple.hpp | 4262b3de5bf945b6ce4a5547c1387ca9ae43ed02 | [
"BSL-1.0"
] | permissive | CreativeLabs0X3CF/Sprout | af60a938fd12e8439a831d4d538c4c48011ca54f | f08464943fbe2ac2030060e6ff20e4bb9782cd8e | refs/heads/master | 2021-01-20T17:03:24.630813 | 2016-08-15T04:44:46 | 2016-08-15T04:44:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,351 | hpp | /*=============================================================================
Copyright (c) 2011-2016 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_WEED_PARSER_DIRECTIVE_AS_TUPLE_HPP
#define SPROUT_WEED_PARSER_DIRECTIVE_AS_TUPLE_HPP
#include <sprout/config.hpp>
#include <sprout/workaround/std/cstddef.hpp>
#include <sprout/tuple/tuple.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/parser_result.hpp>
#include <sprout/weed/expr/make_terminal_or_expr.hpp>
#include <sprout/weed/expr/eval.hpp>
#include <sprout/weed/parser/parser_base.hpp>
#include <sprout/weed/traits/type/is_unused.hpp>
#include <sprout/weed/traits/expr/terminal_or_expr_of.hpp>
#include <sprout/weed/traits/parser/attribute_of.hpp>
namespace sprout {
namespace weed {
//
// as_tuple_p
//
template<typename Parser>
struct as_tuple_p
: public sprout::weed::parser_base
{
public:
template<typename Context, typename Iterator>
struct attribute {
private:
typedef typename sprout::weed::traits::attribute_of<Parser, Iterator, Context>::type attr_type;
private:
static_assert(!sprout::weed::traits::is_unused<attr_type>::value, "invalid attribute : unused");
public:
typedef sprout::tuples::tuple<attr_type> type;
};
template<typename Context, typename Iterator>
struct result
: public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
{};
private:
typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type;
private:
expr_type expr_;
private:
template<typename Context, typename Iterator, typename Result>
SPROUT_CONSTEXPR typename result<Context, Iterator>::type call(
Iterator first,
Result const& res
) const
{
typedef typename result<Context, Iterator>::type result_type;
typedef typename attribute<Context, Iterator>::type attribute_type;
return res.success()
? result_type(true, res.current(), attribute_type(res.attr()))
: result_type(false, first, attribute_type())
;
}
public:
SPROUT_CONSTEXPR as_tuple_p() SPROUT_DEFAULTED_DEFAULT_CONSTRUCTOR_DECL
explicit SPROUT_CONSTEXPR as_tuple_p(
Parser const& p
)
: expr_(sprout::weed::make_terminal_or_expr(p))
{}
template<typename Context, typename Iterator>
SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()(
Iterator first, Iterator,
Context const& ctx
) const
{
return call<Context>(first, sprout::weed::eval(expr_, ctx));
}
};
//
// as_tuple_d
//
struct as_tuple_d {
public:
template<typename Parser>
SPROUT_CONSTEXPR sprout::weed::as_tuple_p<Parser> operator[](Parser const& p) const {
return sprout::weed::as_tuple_p<Parser>(p);
}
};
//
// as_tuple
//
SPROUT_CONSTEXPR sprout::weed::as_tuple_d as_tuple = sprout::weed::as_tuple_d();
} // namespace weed
} // namespace sprout
#endif // #ifndef SPROUT_WEED_PARSER_DIRECTIVE_AS_TUPLE_HPP
| [
"bolero.murakami@gmail.com"
] | bolero.murakami@gmail.com |
8df3d0af4ebacdb638ebab4d92ec91631bafd65d | a9e308c81c27a80c53c899ce806d6d7b4a9bbbf3 | /engine/xray/editor/world/sources/command_drop_objects.cpp | af6fb81b956e909e24176c1ba92b843de5556883 | [] | no_license | NikitaNikson/xray-2_0 | 00d8e78112d7b3d5ec1cb790c90f614dc732f633 | 82b049d2d177aac15e1317cbe281e8c167b8f8d1 | refs/heads/master | 2023-06-25T16:51:26.243019 | 2020-09-29T15:49:23 | 2020-09-29T15:49:23 | 390,966,305 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,531 | cpp | ////////////////////////////////////////////////////////////////////////////
// Created : 02.04.2009
// Author : Armen Abroyan
// Copyright (C) GSC Game World - 2009
////////////////////////////////////////////////////////////////////////////
#include "pch.h"
#include "command_drop_objects.h"
#include "object_base.h"
#include "level_editor.h"
#include "picker.h"
#include "project.h"
#include "transform_control_base.h"
#include "collision_object_dynamic.h"
namespace xray {
namespace editor {
command_drop_objects::command_drop_objects ( level_editor^ le, bool drop_from_top ):
m_level_editor (le),
m_first_pass (true),
m_drop_from_top (drop_from_top)
{
object_list^ selection = m_level_editor->get_project()->selection_list();
// Sorting objects by height to drop them starting from the lower objects
object_list objects_sorted = selection;
objects_sorted.Sort (gcnew object_height_predicate);
for each(object_base^ o in objects_sorted)
{
id_matrix itm;
itm.id = o->id();
itm.matrix = NEW (math::float4x4)(o->get_transform());
m_obj_matrices.Add(itm);
}
}
command_drop_objects::~command_drop_objects( )
{
for each(id_matrix^ itm in m_obj_matrices)
DELETE ( itm->matrix );
m_obj_matrices.Clear( );
}
bool command_drop_objects::commit ()
{
object_list objects;
// Dropping direction: straight down.
float3 const direction ( 0, -1, 0 );
math::float4x4 tmp_mat;
// If we are in first execution then calculating collision to drom the objects
// else just replace old/new matrices of the objects.
if( m_first_pass )
{
// Get corresponding objects to their ids
for each(id_matrix^ idm in m_obj_matrices)
{
object_base^ object = object_base::object_by_id(idm->id);
ASSERT ( object != nullptr );
objects.Add (object);
}
for each (object_base^ o in objects)
{
float4x4 transform = o->get_transform();
float distance;
collision::ray_objects_type collision_results( g_allocator );
float3 origin;
// If dropping objects from very top than just assigning ray pick origin to a constant
// height else keep the current height of the object by just lifting it up a bit to
// be sure that the object will not drop from the plane on which it is placed before.
if( m_drop_from_top )
origin = float3( 1, 0, 1 )*transform.c.xyz() + float3( 0, 500.f, 0 );
else
origin = transform.c.xyz() + float3( 0, 0.1f, 0 );
// Picking down to find the place for the object
m_level_editor->get_picker( ).ray_query(collision_type_dynamic, origin, direction, collision_results );
// Pass picking result by a object filter to exclude objects from picking results
// that are not placed yet.
int idx_of = objects.IndexOf(o);
if( get_valid_collision ( collision_results, objects.GetRange(idx_of, objects.Count-idx_of), distance ) )
{
transform.c.xyz() = origin + direction*distance;
o->set_transform ( transform );
}
else
{
transform.c.xyz() = float3( 1, 0, 1 )*origin;
o->set_transform ( transform );
}
}
}else // first_pass
{
// Just replace old/new matrices of the objects.
for each(id_matrix^ idm in m_obj_matrices)
{
object_base^ object = object_base::object_by_id(idm->id);
tmp_mat = object->get_transform();
object->set_transform( *idm->matrix );
*idm->matrix = tmp_mat;
}
}
m_first_pass = false;
return true;
}
void command_drop_objects::rollback ()
{
// Just switch old/new matrices.
commit ( );
}
} // namespace editor
} // namespace xray
| [
"loxotron@bk.ru"
] | loxotron@bk.ru |
f99a32047359ec9d6264b8faa09da63f9acb2c86 | 841a9def845ae35edd5cb8446b0dccf19d7bbc71 | /include/Car.h | 453d981700f7a0389990f0f05fcc69920ac9dad2 | [] | no_license | gustavo-ren/GetSet | 4a69ab52a247ab684fd0b6d867babfe8aef4218c | bd7404af804f8d989ffc8a4dbee3f38cf1bc5901 | refs/heads/master | 2021-08-19T04:46:54.371833 | 2017-11-24T20:56:52 | 2017-11-24T20:56:52 | 111,873,104 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 454 | h | #ifndef CAR_H
#define CAR_H
#include <iostream>
using namespace std;
class Car
{
public:
Car();
virtual ~Car();
string show();
void setModel(string m);
void setColor(string c);
void setBrand(string b);
string getModel();
string getBrand();
string getColor();
protected:
private:
string color;
string model;
string brand;
};
#endif // CAR_H
| [
"exemplo@exemplo.com"
] | exemplo@exemplo.com |
09c97c85d4a30bf93e585aa67e2669c6fcf67ec1 | 332515cb827e57f3359cfe0562c5b91d711752df | /Application_UWP_WinRT/Generated Files/winrt/Windows.UI.Notifications.h | 54a4b86eae89a153a5e89a8349c39e5246f01395 | [
"MIT"
] | permissive | GCourtney27/DX12-Simple-Xbox-Win32-Application | 7c1f09abbfb768a1d5c2ab0d7ee9621f66ad85d5 | 4f0bc4a52aa67c90376f05146f2ebea92db1ec57 | refs/heads/master | 2023-02-19T06:54:18.923600 | 2021-01-24T08:18:19 | 2021-01-24T08:18:19 | 312,744,674 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 230,576 | h | // WARNING: Please don't edit this file. It was generated by C++/WinRT v2.0.201113.7
#ifndef WINRT_Windows_UI_Notifications_H
#define WINRT_Windows_UI_Notifications_H
#include "winrt/base.h"
static_assert(winrt::check_version(CPPWINRT_VERSION, "2.0.201113.7"), "Mismatched C++/WinRT headers.");
#define CPPWINRT_VERSION "2.0.201113.7"
#include "winrt/Windows.UI.h"
#include "winrt/impl/Windows.ApplicationModel.2.h"
#include "winrt/impl/Windows.Data.Xml.Dom.2.h"
#include "winrt/impl/Windows.Foundation.2.h"
#include "winrt/impl/Windows.Foundation.Collections.2.h"
#include "winrt/impl/Windows.System.2.h"
#include "winrt/impl/Windows.UI.Notifications.2.h"
namespace winrt::impl
{
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::AdaptiveNotificationContentKind) consume_Windows_UI_Notifications_IAdaptiveNotificationContent<D>::Kind() const
{
Windows::UI::Notifications::AdaptiveNotificationContentKind value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IAdaptiveNotificationContent)->get_Kind(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::IMap<hstring, hstring>) consume_Windows_UI_Notifications_IAdaptiveNotificationContent<D>::Hints() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IAdaptiveNotificationContent)->get_Hints(&value));
return Windows::Foundation::Collections::IMap<hstring, hstring>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IAdaptiveNotificationText<D>::Text() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IAdaptiveNotificationText)->get_Text(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IAdaptiveNotificationText<D>::Text(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IAdaptiveNotificationText)->put_Text(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IAdaptiveNotificationText<D>::Language() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IAdaptiveNotificationText)->get_Language(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IAdaptiveNotificationText<D>::Language(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IAdaptiveNotificationText)->put_Language(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_IBadgeNotification<D>::Content() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeNotification)->get_Content(&value));
return Windows::Data::Xml::Dom::XmlDocument{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IBadgeNotification<D>::ExpirationTime(Windows::Foundation::IReference<Windows::Foundation::DateTime> const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeNotification)->put_ExpirationTime(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IReference<Windows::Foundation::DateTime>) consume_Windows_UI_Notifications_IBadgeNotification<D>::ExpirationTime() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeNotification)->get_ExpirationTime(&value));
return Windows::Foundation::IReference<Windows::Foundation::DateTime>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::BadgeNotification) consume_Windows_UI_Notifications_IBadgeNotificationFactory<D>::CreateBadgeNotification(Windows::Data::Xml::Dom::XmlDocument const& content) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeNotificationFactory)->CreateBadgeNotification(*(void**)(&content), &value));
return Windows::UI::Notifications::BadgeNotification{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::BadgeUpdater) consume_Windows_UI_Notifications_IBadgeUpdateManagerForUser<D>::CreateBadgeUpdaterForApplication() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdateManagerForUser)->CreateBadgeUpdaterForApplication(&result));
return Windows::UI::Notifications::BadgeUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::BadgeUpdater) consume_Windows_UI_Notifications_IBadgeUpdateManagerForUser<D>::CreateBadgeUpdaterForApplication(param::hstring const& applicationId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdateManagerForUser)->CreateBadgeUpdaterForApplicationWithId(*(void**)(&applicationId), &result));
return Windows::UI::Notifications::BadgeUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::BadgeUpdater) consume_Windows_UI_Notifications_IBadgeUpdateManagerForUser<D>::CreateBadgeUpdaterForSecondaryTile(param::hstring const& tileId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdateManagerForUser)->CreateBadgeUpdaterForSecondaryTile(*(void**)(&tileId), &result));
return Windows::UI::Notifications::BadgeUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::System::User) consume_Windows_UI_Notifications_IBadgeUpdateManagerForUser<D>::User() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdateManagerForUser)->get_User(&value));
return Windows::System::User{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::BadgeUpdater) consume_Windows_UI_Notifications_IBadgeUpdateManagerStatics<D>::CreateBadgeUpdaterForApplication() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdateManagerStatics)->CreateBadgeUpdaterForApplication(&result));
return Windows::UI::Notifications::BadgeUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::BadgeUpdater) consume_Windows_UI_Notifications_IBadgeUpdateManagerStatics<D>::CreateBadgeUpdaterForApplication(param::hstring const& applicationId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdateManagerStatics)->CreateBadgeUpdaterForApplicationWithId(*(void**)(&applicationId), &result));
return Windows::UI::Notifications::BadgeUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::BadgeUpdater) consume_Windows_UI_Notifications_IBadgeUpdateManagerStatics<D>::CreateBadgeUpdaterForSecondaryTile(param::hstring const& tileId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdateManagerStatics)->CreateBadgeUpdaterForSecondaryTile(*(void**)(&tileId), &result));
return Windows::UI::Notifications::BadgeUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_IBadgeUpdateManagerStatics<D>::GetTemplateContent(Windows::UI::Notifications::BadgeTemplateType const& type) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdateManagerStatics)->GetTemplateContent(static_cast<int32_t>(type), &result));
return Windows::Data::Xml::Dom::XmlDocument{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::BadgeUpdateManagerForUser) consume_Windows_UI_Notifications_IBadgeUpdateManagerStatics2<D>::GetForUser(Windows::System::User const& user) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdateManagerStatics2)->GetForUser(*(void**)(&user), &result));
return Windows::UI::Notifications::BadgeUpdateManagerForUser{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IBadgeUpdater<D>::Update(Windows::UI::Notifications::BadgeNotification const& notification) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdater)->Update(*(void**)(¬ification)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IBadgeUpdater<D>::Clear() const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdater)->Clear());
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IBadgeUpdater<D>::StartPeriodicUpdate(Windows::Foundation::Uri const& badgeContent, Windows::UI::Notifications::PeriodicUpdateRecurrence const& requestedInterval) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdater)->StartPeriodicUpdate(*(void**)(&badgeContent), static_cast<int32_t>(requestedInterval)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IBadgeUpdater<D>::StartPeriodicUpdate(Windows::Foundation::Uri const& badgeContent, Windows::Foundation::DateTime const& startTime, Windows::UI::Notifications::PeriodicUpdateRecurrence const& requestedInterval) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdater)->StartPeriodicUpdateAtTime(*(void**)(&badgeContent), impl::bind_in(startTime), static_cast<int32_t>(requestedInterval)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IBadgeUpdater<D>::StopPeriodicUpdate() const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IBadgeUpdater)->StopPeriodicUpdate());
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationHintsStatics<D>::Style() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationHintsStatics)->get_Style(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationHintsStatics<D>::Wrap() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationHintsStatics)->get_Wrap(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationHintsStatics<D>::MaxLines() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationHintsStatics)->get_MaxLines(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationHintsStatics<D>::MinLines() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationHintsStatics)->get_MinLines(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationHintsStatics<D>::TextStacking() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationHintsStatics)->get_TextStacking(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationHintsStatics<D>::Align() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationHintsStatics)->get_Align(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::Caption() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_Caption(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::Body() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_Body(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::Base() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_Base(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::Subtitle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_Subtitle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::Title() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_Title(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::Subheader() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_Subheader(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::Header() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_Header(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::TitleNumeral() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_TitleNumeral(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::SubheaderNumeral() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_SubheaderNumeral(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::HeaderNumeral() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_HeaderNumeral(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::CaptionSubtle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_CaptionSubtle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::BodySubtle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_BodySubtle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::BaseSubtle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_BaseSubtle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::SubtitleSubtle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_SubtitleSubtle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::TitleSubtle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_TitleSubtle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::SubheaderSubtle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_SubheaderSubtle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::SubheaderNumeralSubtle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_SubheaderNumeralSubtle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::HeaderSubtle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_HeaderSubtle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownAdaptiveNotificationTextStylesStatics<D>::HeaderNumeralSubtle() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics)->get_HeaderNumeralSubtle(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IKnownNotificationBindingsStatics<D>::ToastGeneric() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IKnownNotificationBindingsStatics)->get_ToastGeneric(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IReference<Windows::Foundation::DateTime>) consume_Windows_UI_Notifications_INotification<D>::ExpirationTime() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotification)->get_ExpirationTime(&value));
return Windows::Foundation::IReference<Windows::Foundation::DateTime>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_INotification<D>::ExpirationTime(Windows::Foundation::IReference<Windows::Foundation::DateTime> const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotification)->put_ExpirationTime(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationVisual) consume_Windows_UI_Notifications_INotification<D>::Visual() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotification)->get_Visual(&value));
return Windows::UI::Notifications::NotificationVisual{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_INotification<D>::Visual(Windows::UI::Notifications::NotificationVisual const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotification)->put_Visual(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_INotificationBinding<D>::Template() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationBinding)->get_Template(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_INotificationBinding<D>::Template(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationBinding)->put_Template(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_INotificationBinding<D>::Language() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationBinding)->get_Language(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_INotificationBinding<D>::Language(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationBinding)->put_Language(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::IMap<hstring, hstring>) consume_Windows_UI_Notifications_INotificationBinding<D>::Hints() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationBinding)->get_Hints(&value));
return Windows::Foundation::Collections::IMap<hstring, hstring>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::AdaptiveNotificationText>) consume_Windows_UI_Notifications_INotificationBinding<D>::GetTextElements() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationBinding)->GetTextElements(&result));
return Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::AdaptiveNotificationText>{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::IMap<hstring, hstring>) consume_Windows_UI_Notifications_INotificationData<D>::Values() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationData)->get_Values(&value));
return Windows::Foundation::Collections::IMap<hstring, hstring>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(uint32_t) consume_Windows_UI_Notifications_INotificationData<D>::SequenceNumber() const
{
uint32_t value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationData)->get_SequenceNumber(&value));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_INotificationData<D>::SequenceNumber(uint32_t value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationData)->put_SequenceNumber(value));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationData) consume_Windows_UI_Notifications_INotificationDataFactory<D>::CreateNotificationData(param::iterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> const& initialValues, uint32_t sequenceNumber) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationDataFactory)->CreateNotificationDataWithValuesAndSequenceNumber(*(void**)(&initialValues), sequenceNumber, &value));
return Windows::UI::Notifications::NotificationData{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationData) consume_Windows_UI_Notifications_INotificationDataFactory<D>::CreateNotificationData(param::iterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> const& initialValues) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationDataFactory)->CreateNotificationDataWithValues(*(void**)(&initialValues), &value));
return Windows::UI::Notifications::NotificationData{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_INotificationVisual<D>::Language() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationVisual)->get_Language(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_INotificationVisual<D>::Language(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationVisual)->put_Language(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::IVector<Windows::UI::Notifications::NotificationBinding>) consume_Windows_UI_Notifications_INotificationVisual<D>::Bindings() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationVisual)->get_Bindings(&value));
return Windows::Foundation::Collections::IVector<Windows::UI::Notifications::NotificationBinding>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationBinding) consume_Windows_UI_Notifications_INotificationVisual<D>::GetBinding(param::hstring const& templateName) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::INotificationVisual)->GetBinding(*(void**)(&templateName), &result));
return Windows::UI::Notifications::NotificationBinding{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_IScheduledTileNotification<D>::Content() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledTileNotification)->get_Content(&value));
return Windows::Data::Xml::Dom::XmlDocument{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::DateTime) consume_Windows_UI_Notifications_IScheduledTileNotification<D>::DeliveryTime() const
{
Windows::Foundation::DateTime value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledTileNotification)->get_DeliveryTime(put_abi(value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledTileNotification<D>::ExpirationTime(Windows::Foundation::IReference<Windows::Foundation::DateTime> const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledTileNotification)->put_ExpirationTime(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IReference<Windows::Foundation::DateTime>) consume_Windows_UI_Notifications_IScheduledTileNotification<D>::ExpirationTime() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledTileNotification)->get_ExpirationTime(&value));
return Windows::Foundation::IReference<Windows::Foundation::DateTime>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledTileNotification<D>::Tag(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledTileNotification)->put_Tag(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IScheduledTileNotification<D>::Tag() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledTileNotification)->get_Tag(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledTileNotification<D>::Id(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledTileNotification)->put_Id(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IScheduledTileNotification<D>::Id() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledTileNotification)->get_Id(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ScheduledTileNotification) consume_Windows_UI_Notifications_IScheduledTileNotificationFactory<D>::CreateScheduledTileNotification(Windows::Data::Xml::Dom::XmlDocument const& content, Windows::Foundation::DateTime const& deliveryTime) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledTileNotificationFactory)->CreateScheduledTileNotification(*(void**)(&content), impl::bind_in(deliveryTime), &value));
return Windows::UI::Notifications::ScheduledTileNotification{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_IScheduledToastNotification<D>::Content() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification)->get_Content(&value));
return Windows::Data::Xml::Dom::XmlDocument{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::DateTime) consume_Windows_UI_Notifications_IScheduledToastNotification<D>::DeliveryTime() const
{
Windows::Foundation::DateTime value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification)->get_DeliveryTime(put_abi(value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IReference<Windows::Foundation::TimeSpan>) consume_Windows_UI_Notifications_IScheduledToastNotification<D>::SnoozeInterval() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification)->get_SnoozeInterval(&value));
return Windows::Foundation::IReference<Windows::Foundation::TimeSpan>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(uint32_t) consume_Windows_UI_Notifications_IScheduledToastNotification<D>::MaximumSnoozeCount() const
{
uint32_t value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification)->get_MaximumSnoozeCount(&value));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledToastNotification<D>::Id(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification)->put_Id(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IScheduledToastNotification<D>::Id() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification)->get_Id(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledToastNotification2<D>::Tag(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification2)->put_Tag(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IScheduledToastNotification2<D>::Tag() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification2)->get_Tag(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledToastNotification2<D>::Group(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification2)->put_Group(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IScheduledToastNotification2<D>::Group() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification2)->get_Group(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledToastNotification2<D>::SuppressPopup(bool value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification2)->put_SuppressPopup(value));
}
template <typename D> WINRT_IMPL_AUTO(bool) consume_Windows_UI_Notifications_IScheduledToastNotification2<D>::SuppressPopup() const
{
bool value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification2)->get_SuppressPopup(&value));
return value;
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationMirroring) consume_Windows_UI_Notifications_IScheduledToastNotification3<D>::NotificationMirroring() const
{
Windows::UI::Notifications::NotificationMirroring value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification3)->get_NotificationMirroring(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledToastNotification3<D>::NotificationMirroring(Windows::UI::Notifications::NotificationMirroring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification3)->put_NotificationMirroring(static_cast<int32_t>(value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IScheduledToastNotification3<D>::RemoteId() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification3)->get_RemoteId(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledToastNotification3<D>::RemoteId(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification3)->put_RemoteId(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IReference<Windows::Foundation::DateTime>) consume_Windows_UI_Notifications_IScheduledToastNotification4<D>::ExpirationTime() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification4)->get_ExpirationTime(&value));
return Windows::Foundation::IReference<Windows::Foundation::DateTime>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledToastNotification4<D>::ExpirationTime(Windows::Foundation::IReference<Windows::Foundation::DateTime> const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotification4)->put_ExpirationTime(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ScheduledToastNotification) consume_Windows_UI_Notifications_IScheduledToastNotificationFactory<D>::CreateScheduledToastNotification(Windows::Data::Xml::Dom::XmlDocument const& content, Windows::Foundation::DateTime const& deliveryTime) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotificationFactory)->CreateScheduledToastNotification(*(void**)(&content), impl::bind_in(deliveryTime), &value));
return Windows::UI::Notifications::ScheduledToastNotification{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ScheduledToastNotification) consume_Windows_UI_Notifications_IScheduledToastNotificationFactory<D>::CreateScheduledToastNotificationRecurring(Windows::Data::Xml::Dom::XmlDocument const& content, Windows::Foundation::DateTime const& deliveryTime, Windows::Foundation::TimeSpan const& snoozeInterval, uint32_t maximumSnoozeCount) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotificationFactory)->CreateScheduledToastNotificationRecurring(*(void**)(&content), impl::bind_in(deliveryTime), impl::bind_in(snoozeInterval), maximumSnoozeCount, &value));
return Windows::UI::Notifications::ScheduledToastNotification{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(bool) consume_Windows_UI_Notifications_IScheduledToastNotificationShowingEventArgs<D>::Cancel() const
{
bool value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotificationShowingEventArgs)->get_Cancel(&value));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IScheduledToastNotificationShowingEventArgs<D>::Cancel(bool value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotificationShowingEventArgs)->put_Cancel(value));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ScheduledToastNotification) consume_Windows_UI_Notifications_IScheduledToastNotificationShowingEventArgs<D>::ScheduledToastNotification() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotificationShowingEventArgs)->get_ScheduledToastNotification(&value));
return Windows::UI::Notifications::ScheduledToastNotification{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Deferral) consume_Windows_UI_Notifications_IScheduledToastNotificationShowingEventArgs<D>::GetDeferral() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IScheduledToastNotificationShowingEventArgs)->GetDeferral(&result));
return Windows::Foundation::Deferral{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IShownTileNotification<D>::Arguments() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IShownTileNotification)->get_Arguments(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_ITileFlyoutNotification<D>::Content() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutNotification)->get_Content(&value));
return Windows::Data::Xml::Dom::XmlDocument{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileFlyoutNotification<D>::ExpirationTime(Windows::Foundation::IReference<Windows::Foundation::DateTime> const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutNotification)->put_ExpirationTime(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IReference<Windows::Foundation::DateTime>) consume_Windows_UI_Notifications_ITileFlyoutNotification<D>::ExpirationTime() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutNotification)->get_ExpirationTime(&value));
return Windows::Foundation::IReference<Windows::Foundation::DateTime>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileFlyoutNotification) consume_Windows_UI_Notifications_ITileFlyoutNotificationFactory<D>::CreateTileFlyoutNotification(Windows::Data::Xml::Dom::XmlDocument const& content) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutNotificationFactory)->CreateTileFlyoutNotification(*(void**)(&content), &value));
return Windows::UI::Notifications::TileFlyoutNotification{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileFlyoutUpdater) consume_Windows_UI_Notifications_ITileFlyoutUpdateManagerStatics<D>::CreateTileFlyoutUpdaterForApplication() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdateManagerStatics)->CreateTileFlyoutUpdaterForApplication(&result));
return Windows::UI::Notifications::TileFlyoutUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileFlyoutUpdater) consume_Windows_UI_Notifications_ITileFlyoutUpdateManagerStatics<D>::CreateTileFlyoutUpdaterForApplication(param::hstring const& applicationId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdateManagerStatics)->CreateTileFlyoutUpdaterForApplicationWithId(*(void**)(&applicationId), &result));
return Windows::UI::Notifications::TileFlyoutUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileFlyoutUpdater) consume_Windows_UI_Notifications_ITileFlyoutUpdateManagerStatics<D>::CreateTileFlyoutUpdaterForSecondaryTile(param::hstring const& tileId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdateManagerStatics)->CreateTileFlyoutUpdaterForSecondaryTile(*(void**)(&tileId), &result));
return Windows::UI::Notifications::TileFlyoutUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_ITileFlyoutUpdateManagerStatics<D>::GetTemplateContent(Windows::UI::Notifications::TileFlyoutTemplateType const& type) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdateManagerStatics)->GetTemplateContent(static_cast<int32_t>(type), &result));
return Windows::Data::Xml::Dom::XmlDocument{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileFlyoutUpdater<D>::Update(Windows::UI::Notifications::TileFlyoutNotification const& notification) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdater)->Update(*(void**)(¬ification)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileFlyoutUpdater<D>::Clear() const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdater)->Clear());
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileFlyoutUpdater<D>::StartPeriodicUpdate(Windows::Foundation::Uri const& tileFlyoutContent, Windows::UI::Notifications::PeriodicUpdateRecurrence const& requestedInterval) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdater)->StartPeriodicUpdate(*(void**)(&tileFlyoutContent), static_cast<int32_t>(requestedInterval)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileFlyoutUpdater<D>::StartPeriodicUpdate(Windows::Foundation::Uri const& tileFlyoutContent, Windows::Foundation::DateTime const& startTime, Windows::UI::Notifications::PeriodicUpdateRecurrence const& requestedInterval) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdater)->StartPeriodicUpdateAtTime(*(void**)(&tileFlyoutContent), impl::bind_in(startTime), static_cast<int32_t>(requestedInterval)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileFlyoutUpdater<D>::StopPeriodicUpdate() const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdater)->StopPeriodicUpdate());
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationSetting) consume_Windows_UI_Notifications_ITileFlyoutUpdater<D>::Setting() const
{
Windows::UI::Notifications::NotificationSetting value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileFlyoutUpdater)->get_Setting(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_ITileNotification<D>::Content() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileNotification)->get_Content(&value));
return Windows::Data::Xml::Dom::XmlDocument{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileNotification<D>::ExpirationTime(Windows::Foundation::IReference<Windows::Foundation::DateTime> const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileNotification)->put_ExpirationTime(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IReference<Windows::Foundation::DateTime>) consume_Windows_UI_Notifications_ITileNotification<D>::ExpirationTime() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileNotification)->get_ExpirationTime(&value));
return Windows::Foundation::IReference<Windows::Foundation::DateTime>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileNotification<D>::Tag(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileNotification)->put_Tag(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_ITileNotification<D>::Tag() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileNotification)->get_Tag(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileNotification) consume_Windows_UI_Notifications_ITileNotificationFactory<D>::CreateTileNotification(Windows::Data::Xml::Dom::XmlDocument const& content) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileNotificationFactory)->CreateTileNotification(*(void**)(&content), &value));
return Windows::UI::Notifications::TileNotification{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileUpdater) consume_Windows_UI_Notifications_ITileUpdateManagerForUser<D>::CreateTileUpdaterForApplicationForUser() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdateManagerForUser)->CreateTileUpdaterForApplication(&result));
return Windows::UI::Notifications::TileUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileUpdater) consume_Windows_UI_Notifications_ITileUpdateManagerForUser<D>::CreateTileUpdaterForApplication(param::hstring const& applicationId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdateManagerForUser)->CreateTileUpdaterForApplicationWithId(*(void**)(&applicationId), &result));
return Windows::UI::Notifications::TileUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileUpdater) consume_Windows_UI_Notifications_ITileUpdateManagerForUser<D>::CreateTileUpdaterForSecondaryTile(param::hstring const& tileId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdateManagerForUser)->CreateTileUpdaterForSecondaryTile(*(void**)(&tileId), &result));
return Windows::UI::Notifications::TileUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::System::User) consume_Windows_UI_Notifications_ITileUpdateManagerForUser<D>::User() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdateManagerForUser)->get_User(&value));
return Windows::System::User{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileUpdater) consume_Windows_UI_Notifications_ITileUpdateManagerStatics<D>::CreateTileUpdaterForApplication() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdateManagerStatics)->CreateTileUpdaterForApplication(&result));
return Windows::UI::Notifications::TileUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileUpdater) consume_Windows_UI_Notifications_ITileUpdateManagerStatics<D>::CreateTileUpdaterForApplication(param::hstring const& applicationId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdateManagerStatics)->CreateTileUpdaterForApplicationWithId(*(void**)(&applicationId), &result));
return Windows::UI::Notifications::TileUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileUpdater) consume_Windows_UI_Notifications_ITileUpdateManagerStatics<D>::CreateTileUpdaterForSecondaryTile(param::hstring const& tileId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdateManagerStatics)->CreateTileUpdaterForSecondaryTile(*(void**)(&tileId), &result));
return Windows::UI::Notifications::TileUpdater{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_ITileUpdateManagerStatics<D>::GetTemplateContent(Windows::UI::Notifications::TileTemplateType const& type) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdateManagerStatics)->GetTemplateContent(static_cast<int32_t>(type), &result));
return Windows::Data::Xml::Dom::XmlDocument{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::TileUpdateManagerForUser) consume_Windows_UI_Notifications_ITileUpdateManagerStatics2<D>::GetForUser(Windows::System::User const& user) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdateManagerStatics2)->GetForUser(*(void**)(&user), &result));
return Windows::UI::Notifications::TileUpdateManagerForUser{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::Update(Windows::UI::Notifications::TileNotification const& notification) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->Update(*(void**)(¬ification)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::Clear() const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->Clear());
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::EnableNotificationQueue(bool enable) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->EnableNotificationQueue(enable));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationSetting) consume_Windows_UI_Notifications_ITileUpdater<D>::Setting() const
{
Windows::UI::Notifications::NotificationSetting value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->get_Setting(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::AddToSchedule(Windows::UI::Notifications::ScheduledTileNotification const& scheduledTile) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->AddToSchedule(*(void**)(&scheduledTile)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::RemoveFromSchedule(Windows::UI::Notifications::ScheduledTileNotification const& scheduledTile) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->RemoveFromSchedule(*(void**)(&scheduledTile)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ScheduledTileNotification>) consume_Windows_UI_Notifications_ITileUpdater<D>::GetScheduledTileNotifications() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->GetScheduledTileNotifications(&result));
return Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ScheduledTileNotification>{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::StartPeriodicUpdate(Windows::Foundation::Uri const& tileContent, Windows::UI::Notifications::PeriodicUpdateRecurrence const& requestedInterval) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->StartPeriodicUpdate(*(void**)(&tileContent), static_cast<int32_t>(requestedInterval)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::StartPeriodicUpdate(Windows::Foundation::Uri const& tileContent, Windows::Foundation::DateTime const& startTime, Windows::UI::Notifications::PeriodicUpdateRecurrence const& requestedInterval) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->StartPeriodicUpdateAtTime(*(void**)(&tileContent), impl::bind_in(startTime), static_cast<int32_t>(requestedInterval)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::StopPeriodicUpdate() const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->StopPeriodicUpdate());
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::StartPeriodicUpdateBatch(param::iterable<Windows::Foundation::Uri> const& tileContents, Windows::UI::Notifications::PeriodicUpdateRecurrence const& requestedInterval) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->StartPeriodicUpdateBatch(*(void**)(&tileContents), static_cast<int32_t>(requestedInterval)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater<D>::StartPeriodicUpdateBatch(param::iterable<Windows::Foundation::Uri> const& tileContents, Windows::Foundation::DateTime const& startTime, Windows::UI::Notifications::PeriodicUpdateRecurrence const& requestedInterval) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater)->StartPeriodicUpdateBatchAtTime(*(void**)(&tileContents), impl::bind_in(startTime), static_cast<int32_t>(requestedInterval)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater2<D>::EnableNotificationQueueForSquare150x150(bool enable) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater2)->EnableNotificationQueueForSquare150x150(enable));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater2<D>::EnableNotificationQueueForWide310x150(bool enable) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater2)->EnableNotificationQueueForWide310x150(enable));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_ITileUpdater2<D>::EnableNotificationQueueForSquare310x310(bool enable) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::ITileUpdater2)->EnableNotificationQueueForSquare310x310(enable));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastActivatedEventArgs<D>::Arguments() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastActivatedEventArgs)->get_Arguments(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::ValueSet) consume_Windows_UI_Notifications_IToastActivatedEventArgs2<D>::UserInput() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastActivatedEventArgs2)->get_UserInput(&value));
return Windows::Foundation::Collections::ValueSet{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastCollection<D>::Id() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollection)->get_Id(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastCollection<D>::DisplayName() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollection)->get_DisplayName(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastCollection<D>::DisplayName(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollection)->put_DisplayName(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastCollection<D>::LaunchArgs() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollection)->get_LaunchArgs(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastCollection<D>::LaunchArgs(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollection)->put_LaunchArgs(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Uri) consume_Windows_UI_Notifications_IToastCollection<D>::Icon() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollection)->get_Icon(&value));
return Windows::Foundation::Uri{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastCollection<D>::Icon(Windows::Foundation::Uri const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollection)->put_Icon(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastCollection) consume_Windows_UI_Notifications_IToastCollectionFactory<D>::CreateInstance(param::hstring const& collectionId, param::hstring const& displayName, param::hstring const& launchArgs, Windows::Foundation::Uri const& iconUri) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollectionFactory)->CreateInstance(*(void**)(&collectionId), *(void**)(&displayName), *(void**)(&launchArgs), *(void**)(&iconUri), &value));
return Windows::UI::Notifications::ToastCollection{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IAsyncAction) consume_Windows_UI_Notifications_IToastCollectionManager<D>::SaveToastCollectionAsync(Windows::UI::Notifications::ToastCollection const& collection) const
{
void* operation{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollectionManager)->SaveToastCollectionAsync(*(void**)(&collection), &operation));
return Windows::Foundation::IAsyncAction{ operation, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IAsyncOperation<Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ToastCollection>>) consume_Windows_UI_Notifications_IToastCollectionManager<D>::FindAllToastCollectionsAsync() const
{
void* operation{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollectionManager)->FindAllToastCollectionsAsync(&operation));
return Windows::Foundation::IAsyncOperation<Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ToastCollection>>{ operation, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IAsyncOperation<Windows::UI::Notifications::ToastCollection>) consume_Windows_UI_Notifications_IToastCollectionManager<D>::GetToastCollectionAsync(param::hstring const& collectionId) const
{
void* operation{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollectionManager)->GetToastCollectionAsync(*(void**)(&collectionId), &operation));
return Windows::Foundation::IAsyncOperation<Windows::UI::Notifications::ToastCollection>{ operation, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IAsyncAction) consume_Windows_UI_Notifications_IToastCollectionManager<D>::RemoveToastCollectionAsync(param::hstring const& collectionId) const
{
void* operation{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollectionManager)->RemoveToastCollectionAsync(*(void**)(&collectionId), &operation));
return Windows::Foundation::IAsyncAction{ operation, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IAsyncAction) consume_Windows_UI_Notifications_IToastCollectionManager<D>::RemoveAllToastCollectionsAsync() const
{
void* operation{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollectionManager)->RemoveAllToastCollectionsAsync(&operation));
return Windows::Foundation::IAsyncAction{ operation, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::System::User) consume_Windows_UI_Notifications_IToastCollectionManager<D>::User() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollectionManager)->get_User(&value));
return Windows::System::User{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastCollectionManager<D>::AppId() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastCollectionManager)->get_AppId(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastDismissalReason) consume_Windows_UI_Notifications_IToastDismissedEventArgs<D>::Reason() const
{
Windows::UI::Notifications::ToastDismissalReason value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastDismissedEventArgs)->get_Reason(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(winrt::hresult) consume_Windows_UI_Notifications_IToastFailedEventArgs<D>::ErrorCode() const
{
winrt::hresult value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastFailedEventArgs)->get_ErrorCode(put_abi(value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_IToastNotification<D>::Content() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification)->get_Content(&value));
return Windows::Data::Xml::Dom::XmlDocument{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification<D>::ExpirationTime(Windows::Foundation::IReference<Windows::Foundation::DateTime> const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification)->put_ExpirationTime(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IReference<Windows::Foundation::DateTime>) consume_Windows_UI_Notifications_IToastNotification<D>::ExpirationTime() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification)->get_ExpirationTime(&value));
return Windows::Foundation::IReference<Windows::Foundation::DateTime>{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(winrt::event_token) consume_Windows_UI_Notifications_IToastNotification<D>::Dismissed(Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotification, Windows::UI::Notifications::ToastDismissedEventArgs> const& handler) const
{
winrt::event_token token{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification)->add_Dismissed(*(void**)(&handler), put_abi(token)));
return token;
}
template <typename D> typename consume_Windows_UI_Notifications_IToastNotification<D>::Dismissed_revoker consume_Windows_UI_Notifications_IToastNotification<D>::Dismissed(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotification, Windows::UI::Notifications::ToastDismissedEventArgs> const& handler) const
{
return impl::make_event_revoker<D, Dismissed_revoker>(this, Dismissed(handler));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification<D>::Dismissed(winrt::event_token const& token) const noexcept
{
WINRT_VERIFY_(0, WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification)->remove_Dismissed(impl::bind_in(token)));
}
template <typename D> WINRT_IMPL_AUTO(winrt::event_token) consume_Windows_UI_Notifications_IToastNotification<D>::Activated(Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotification, Windows::Foundation::IInspectable> const& handler) const
{
winrt::event_token token{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification)->add_Activated(*(void**)(&handler), put_abi(token)));
return token;
}
template <typename D> typename consume_Windows_UI_Notifications_IToastNotification<D>::Activated_revoker consume_Windows_UI_Notifications_IToastNotification<D>::Activated(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotification, Windows::Foundation::IInspectable> const& handler) const
{
return impl::make_event_revoker<D, Activated_revoker>(this, Activated(handler));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification<D>::Activated(winrt::event_token const& token) const noexcept
{
WINRT_VERIFY_(0, WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification)->remove_Activated(impl::bind_in(token)));
}
template <typename D> WINRT_IMPL_AUTO(winrt::event_token) consume_Windows_UI_Notifications_IToastNotification<D>::Failed(Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotification, Windows::UI::Notifications::ToastFailedEventArgs> const& handler) const
{
winrt::event_token token{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification)->add_Failed(*(void**)(&handler), put_abi(token)));
return token;
}
template <typename D> typename consume_Windows_UI_Notifications_IToastNotification<D>::Failed_revoker consume_Windows_UI_Notifications_IToastNotification<D>::Failed(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotification, Windows::UI::Notifications::ToastFailedEventArgs> const& handler) const
{
return impl::make_event_revoker<D, Failed_revoker>(this, Failed(handler));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification<D>::Failed(winrt::event_token const& token) const noexcept
{
WINRT_VERIFY_(0, WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification)->remove_Failed(impl::bind_in(token)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification2<D>::Tag(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification2)->put_Tag(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastNotification2<D>::Tag() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification2)->get_Tag(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification2<D>::Group(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification2)->put_Group(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastNotification2<D>::Group() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification2)->get_Group(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification2<D>::SuppressPopup(bool value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification2)->put_SuppressPopup(value));
}
template <typename D> WINRT_IMPL_AUTO(bool) consume_Windows_UI_Notifications_IToastNotification2<D>::SuppressPopup() const
{
bool value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification2)->get_SuppressPopup(&value));
return value;
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationMirroring) consume_Windows_UI_Notifications_IToastNotification3<D>::NotificationMirroring() const
{
Windows::UI::Notifications::NotificationMirroring value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification3)->get_NotificationMirroring(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification3<D>::NotificationMirroring(Windows::UI::Notifications::NotificationMirroring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification3)->put_NotificationMirroring(static_cast<int32_t>(value)));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastNotification3<D>::RemoteId() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification3)->get_RemoteId(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification3<D>::RemoteId(param::hstring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification3)->put_RemoteId(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationData) consume_Windows_UI_Notifications_IToastNotification4<D>::Data() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification4)->get_Data(&value));
return Windows::UI::Notifications::NotificationData{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification4<D>::Data(Windows::UI::Notifications::NotificationData const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification4)->put_Data(*(void**)(&value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotificationPriority) consume_Windows_UI_Notifications_IToastNotification4<D>::Priority() const
{
Windows::UI::Notifications::ToastNotificationPriority value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification4)->get_Priority(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification4<D>::Priority(Windows::UI::Notifications::ToastNotificationPriority const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification4)->put_Priority(static_cast<int32_t>(value)));
}
template <typename D> WINRT_IMPL_AUTO(bool) consume_Windows_UI_Notifications_IToastNotification6<D>::ExpiresOnReboot() const
{
bool value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification6)->get_ExpiresOnReboot(&value));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotification6<D>::ExpiresOnReboot(bool value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotification6)->put_ExpiresOnReboot(value));
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastNotificationActionTriggerDetail<D>::Argument() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationActionTriggerDetail)->get_Argument(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::ValueSet) consume_Windows_UI_Notifications_IToastNotificationActionTriggerDetail<D>::UserInput() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationActionTriggerDetail)->get_UserInput(&value));
return Windows::Foundation::Collections::ValueSet{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotification) consume_Windows_UI_Notifications_IToastNotificationFactory<D>::CreateToastNotification(Windows::Data::Xml::Dom::XmlDocument const& content) const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationFactory)->CreateToastNotification(*(void**)(&content), &value));
return Windows::UI::Notifications::ToastNotification{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotificationHistory<D>::RemoveGroup(param::hstring const& group) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistory)->RemoveGroup(*(void**)(&group)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotificationHistory<D>::RemoveGroup(param::hstring const& group, param::hstring const& applicationId) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistory)->RemoveGroupWithId(*(void**)(&group), *(void**)(&applicationId)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotificationHistory<D>::Remove(param::hstring const& tag, param::hstring const& group, param::hstring const& applicationId) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistory)->RemoveGroupedTagWithId(*(void**)(&tag), *(void**)(&group), *(void**)(&applicationId)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotificationHistory<D>::Remove(param::hstring const& tag, param::hstring const& group) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistory)->RemoveGroupedTag(*(void**)(&tag), *(void**)(&group)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotificationHistory<D>::Remove(param::hstring const& tag) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistory)->Remove(*(void**)(&tag)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotificationHistory<D>::Clear() const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistory)->Clear());
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotificationHistory<D>::Clear(param::hstring const& applicationId) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistory)->ClearWithId(*(void**)(&applicationId)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ToastNotification>) consume_Windows_UI_Notifications_IToastNotificationHistory2<D>::GetHistory() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistory2)->GetHistory(&result));
return Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ToastNotification>{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ToastNotification>) consume_Windows_UI_Notifications_IToastNotificationHistory2<D>::GetHistory(param::hstring const& applicationId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistory2)->GetHistoryWithId(*(void**)(&applicationId), &result));
return Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ToastNotification>{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastHistoryChangedType) consume_Windows_UI_Notifications_IToastNotificationHistoryChangedTriggerDetail<D>::ChangeType() const
{
Windows::UI::Notifications::ToastHistoryChangedType value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail)->get_ChangeType(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(hstring) consume_Windows_UI_Notifications_IToastNotificationHistoryChangedTriggerDetail2<D>::CollectionId() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail2)->get_CollectionId(&value));
return hstring{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotifier) consume_Windows_UI_Notifications_IToastNotificationManagerForUser<D>::CreateToastNotifier() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerForUser)->CreateToastNotifier(&result));
return Windows::UI::Notifications::ToastNotifier{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotifier) consume_Windows_UI_Notifications_IToastNotificationManagerForUser<D>::CreateToastNotifier(param::hstring const& applicationId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerForUser)->CreateToastNotifierWithId(*(void**)(&applicationId), &result));
return Windows::UI::Notifications::ToastNotifier{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotificationHistory) consume_Windows_UI_Notifications_IToastNotificationManagerForUser<D>::History() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerForUser)->get_History(&value));
return Windows::UI::Notifications::ToastNotificationHistory{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::System::User) consume_Windows_UI_Notifications_IToastNotificationManagerForUser<D>::User() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerForUser)->get_User(&value));
return Windows::System::User{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IAsyncOperation<Windows::UI::Notifications::ToastNotifier>) consume_Windows_UI_Notifications_IToastNotificationManagerForUser2<D>::GetToastNotifierForToastCollectionIdAsync(param::hstring const& collectionId) const
{
void* operation{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerForUser2)->GetToastNotifierForToastCollectionIdAsync(*(void**)(&collectionId), &operation));
return Windows::Foundation::IAsyncOperation<Windows::UI::Notifications::ToastNotifier>{ operation, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::IAsyncOperation<Windows::UI::Notifications::ToastNotificationHistory>) consume_Windows_UI_Notifications_IToastNotificationManagerForUser2<D>::GetHistoryForToastCollectionIdAsync(param::hstring const& collectionId) const
{
void* operation{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerForUser2)->GetHistoryForToastCollectionIdAsync(*(void**)(&collectionId), &operation));
return Windows::Foundation::IAsyncOperation<Windows::UI::Notifications::ToastNotificationHistory>{ operation, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastCollectionManager) consume_Windows_UI_Notifications_IToastNotificationManagerForUser2<D>::GetToastCollectionManager() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerForUser2)->GetToastCollectionManager(&result));
return Windows::UI::Notifications::ToastCollectionManager{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastCollectionManager) consume_Windows_UI_Notifications_IToastNotificationManagerForUser2<D>::GetToastCollectionManager(param::hstring const& appId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerForUser2)->GetToastCollectionManagerWithAppId(*(void**)(&appId), &result));
return Windows::UI::Notifications::ToastCollectionManager{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotifier) consume_Windows_UI_Notifications_IToastNotificationManagerStatics<D>::CreateToastNotifier() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerStatics)->CreateToastNotifier(&result));
return Windows::UI::Notifications::ToastNotifier{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotifier) consume_Windows_UI_Notifications_IToastNotificationManagerStatics<D>::CreateToastNotifier(param::hstring const& applicationId) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerStatics)->CreateToastNotifierWithId(*(void**)(&applicationId), &result));
return Windows::UI::Notifications::ToastNotifier{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::Data::Xml::Dom::XmlDocument) consume_Windows_UI_Notifications_IToastNotificationManagerStatics<D>::GetTemplateContent(Windows::UI::Notifications::ToastTemplateType const& type) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerStatics)->GetTemplateContent(static_cast<int32_t>(type), &result));
return Windows::Data::Xml::Dom::XmlDocument{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotificationHistory) consume_Windows_UI_Notifications_IToastNotificationManagerStatics2<D>::History() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerStatics2)->get_History(&value));
return Windows::UI::Notifications::ToastNotificationHistory{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotificationManagerForUser) consume_Windows_UI_Notifications_IToastNotificationManagerStatics4<D>::GetForUser(Windows::System::User const& user) const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerStatics4)->GetForUser(*(void**)(&user), &result));
return Windows::UI::Notifications::ToastNotificationManagerForUser{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotificationManagerStatics4<D>::ConfigureNotificationMirroring(Windows::UI::Notifications::NotificationMirroring const& value) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerStatics4)->ConfigureNotificationMirroring(static_cast<int32_t>(value)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::ToastNotificationManagerForUser) consume_Windows_UI_Notifications_IToastNotificationManagerStatics5<D>::GetDefault() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotificationManagerStatics5)->GetDefault(&result));
return Windows::UI::Notifications::ToastNotificationManagerForUser{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotifier<D>::Show(Windows::UI::Notifications::ToastNotification const& notification) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier)->Show(*(void**)(¬ification)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotifier<D>::Hide(Windows::UI::Notifications::ToastNotification const& notification) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier)->Hide(*(void**)(¬ification)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationSetting) consume_Windows_UI_Notifications_IToastNotifier<D>::Setting() const
{
Windows::UI::Notifications::NotificationSetting value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier)->get_Setting(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotifier<D>::AddToSchedule(Windows::UI::Notifications::ScheduledToastNotification const& scheduledToast) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier)->AddToSchedule(*(void**)(&scheduledToast)));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotifier<D>::RemoveFromSchedule(Windows::UI::Notifications::ScheduledToastNotification const& scheduledToast) const
{
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier)->RemoveFromSchedule(*(void**)(&scheduledToast)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ScheduledToastNotification>) consume_Windows_UI_Notifications_IToastNotifier<D>::GetScheduledToastNotifications() const
{
void* result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier)->GetScheduledToastNotifications(&result));
return Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ScheduledToastNotification>{ result, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationUpdateResult) consume_Windows_UI_Notifications_IToastNotifier2<D>::Update(Windows::UI::Notifications::NotificationData const& data, param::hstring const& tag, param::hstring const& group) const
{
Windows::UI::Notifications::NotificationUpdateResult result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier2)->UpdateWithTagAndGroup(*(void**)(&data), *(void**)(&tag), *(void**)(&group), reinterpret_cast<int32_t*>(&result)));
return result;
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::NotificationUpdateResult) consume_Windows_UI_Notifications_IToastNotifier2<D>::Update(Windows::UI::Notifications::NotificationData const& data, param::hstring const& tag) const
{
Windows::UI::Notifications::NotificationUpdateResult result{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier2)->UpdateWithTag(*(void**)(&data), *(void**)(&tag), reinterpret_cast<int32_t*>(&result)));
return result;
}
template <typename D> WINRT_IMPL_AUTO(winrt::event_token) consume_Windows_UI_Notifications_IToastNotifier3<D>::ScheduledToastNotificationShowing(Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotifier, Windows::UI::Notifications::ScheduledToastNotificationShowingEventArgs> const& handler) const
{
winrt::event_token token{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier3)->add_ScheduledToastNotificationShowing(*(void**)(&handler), put_abi(token)));
return token;
}
template <typename D> typename consume_Windows_UI_Notifications_IToastNotifier3<D>::ScheduledToastNotificationShowing_revoker consume_Windows_UI_Notifications_IToastNotifier3<D>::ScheduledToastNotificationShowing(auto_revoke_t, Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotifier, Windows::UI::Notifications::ScheduledToastNotificationShowingEventArgs> const& handler) const
{
return impl::make_event_revoker<D, ScheduledToastNotificationShowing_revoker>(this, ScheduledToastNotificationShowing(handler));
}
template <typename D> WINRT_IMPL_AUTO(void) consume_Windows_UI_Notifications_IToastNotifier3<D>::ScheduledToastNotificationShowing(winrt::event_token const& token) const noexcept
{
WINRT_VERIFY_(0, WINRT_IMPL_SHIM(Windows::UI::Notifications::IToastNotifier3)->remove_ScheduledToastNotificationShowing(impl::bind_in(token)));
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::Notification) consume_Windows_UI_Notifications_IUserNotification<D>::Notification() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IUserNotification)->get_Notification(&value));
return Windows::UI::Notifications::Notification{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(Windows::ApplicationModel::AppInfo) consume_Windows_UI_Notifications_IUserNotification<D>::AppInfo() const
{
void* value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IUserNotification)->get_AppInfo(&value));
return Windows::ApplicationModel::AppInfo{ value, take_ownership_from_abi };
}
template <typename D> WINRT_IMPL_AUTO(uint32_t) consume_Windows_UI_Notifications_IUserNotification<D>::Id() const
{
uint32_t value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IUserNotification)->get_Id(&value));
return value;
}
template <typename D> WINRT_IMPL_AUTO(Windows::Foundation::DateTime) consume_Windows_UI_Notifications_IUserNotification<D>::CreationTime() const
{
Windows::Foundation::DateTime value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IUserNotification)->get_CreationTime(put_abi(value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(Windows::UI::Notifications::UserNotificationChangedKind) consume_Windows_UI_Notifications_IUserNotificationChangedEventArgs<D>::ChangeKind() const
{
Windows::UI::Notifications::UserNotificationChangedKind value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IUserNotificationChangedEventArgs)->get_ChangeKind(reinterpret_cast<int32_t*>(&value)));
return value;
}
template <typename D> WINRT_IMPL_AUTO(uint32_t) consume_Windows_UI_Notifications_IUserNotificationChangedEventArgs<D>::UserNotificationId() const
{
uint32_t value{};
check_hresult(WINRT_IMPL_SHIM(Windows::UI::Notifications::IUserNotificationChangedEventArgs)->get_UserNotificationId(&value));
return value;
}
template <typename D>
struct produce<D, Windows::UI::Notifications::IAdaptiveNotificationContent> : produce_base<D, Windows::UI::Notifications::IAdaptiveNotificationContent>
{
int32_t __stdcall get_Kind(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::AdaptiveNotificationContentKind>(this->shim().Kind());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Hints(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::Collections::IMap<hstring, hstring>>(this->shim().Hints());
return 0;
}
catch (...) { return to_hresult(); }
};
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IAdaptiveNotificationText> : produce_base<D, Windows::UI::Notifications::IAdaptiveNotificationText>
{
int32_t __stdcall get_Text(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Text());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Text(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Text(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Language(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Language());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Language(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Language(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IBadgeNotification> : produce_base<D, Windows::UI::Notifications::IBadgeNotification>
{
int32_t __stdcall get_Content(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().Content());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_ExpirationTime(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().ExpirationTime(*reinterpret_cast<Windows::Foundation::IReference<Windows::Foundation::DateTime> const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_ExpirationTime(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::IReference<Windows::Foundation::DateTime>>(this->shim().ExpirationTime());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IBadgeNotificationFactory> : produce_base<D, Windows::UI::Notifications::IBadgeNotificationFactory>
{
int32_t __stdcall CreateBadgeNotification(void* content, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::BadgeNotification>(this->shim().CreateBadgeNotification(*reinterpret_cast<Windows::Data::Xml::Dom::XmlDocument const*>(&content)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IBadgeUpdateManagerForUser> : produce_base<D, Windows::UI::Notifications::IBadgeUpdateManagerForUser>
{
int32_t __stdcall CreateBadgeUpdaterForApplication(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::BadgeUpdater>(this->shim().CreateBadgeUpdaterForApplication());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateBadgeUpdaterForApplicationWithId(void* applicationId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::BadgeUpdater>(this->shim().CreateBadgeUpdaterForApplication(*reinterpret_cast<hstring const*>(&applicationId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateBadgeUpdaterForSecondaryTile(void* tileId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::BadgeUpdater>(this->shim().CreateBadgeUpdaterForSecondaryTile(*reinterpret_cast<hstring const*>(&tileId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_User(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::System::User>(this->shim().User());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IBadgeUpdateManagerStatics> : produce_base<D, Windows::UI::Notifications::IBadgeUpdateManagerStatics>
{
int32_t __stdcall CreateBadgeUpdaterForApplication(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::BadgeUpdater>(this->shim().CreateBadgeUpdaterForApplication());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateBadgeUpdaterForApplicationWithId(void* applicationId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::BadgeUpdater>(this->shim().CreateBadgeUpdaterForApplication(*reinterpret_cast<hstring const*>(&applicationId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateBadgeUpdaterForSecondaryTile(void* tileId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::BadgeUpdater>(this->shim().CreateBadgeUpdaterForSecondaryTile(*reinterpret_cast<hstring const*>(&tileId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetTemplateContent(int32_t type, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().GetTemplateContent(*reinterpret_cast<Windows::UI::Notifications::BadgeTemplateType const*>(&type)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IBadgeUpdateManagerStatics2> : produce_base<D, Windows::UI::Notifications::IBadgeUpdateManagerStatics2>
{
int32_t __stdcall GetForUser(void* user, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::BadgeUpdateManagerForUser>(this->shim().GetForUser(*reinterpret_cast<Windows::System::User const*>(&user)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IBadgeUpdater> : produce_base<D, Windows::UI::Notifications::IBadgeUpdater>
{
int32_t __stdcall Update(void* notification) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Update(*reinterpret_cast<Windows::UI::Notifications::BadgeNotification const*>(¬ification));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall Clear() noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Clear();
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StartPeriodicUpdate(void* badgeContent, int32_t requestedInterval) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StartPeriodicUpdate(*reinterpret_cast<Windows::Foundation::Uri const*>(&badgeContent), *reinterpret_cast<Windows::UI::Notifications::PeriodicUpdateRecurrence const*>(&requestedInterval));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StartPeriodicUpdateAtTime(void* badgeContent, int64_t startTime, int32_t requestedInterval) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StartPeriodicUpdate(*reinterpret_cast<Windows::Foundation::Uri const*>(&badgeContent), *reinterpret_cast<Windows::Foundation::DateTime const*>(&startTime), *reinterpret_cast<Windows::UI::Notifications::PeriodicUpdateRecurrence const*>(&requestedInterval));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StopPeriodicUpdate() noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StopPeriodicUpdate();
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IKnownAdaptiveNotificationHintsStatics> : produce_base<D, Windows::UI::Notifications::IKnownAdaptiveNotificationHintsStatics>
{
int32_t __stdcall get_Style(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Style());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Wrap(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Wrap());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_MaxLines(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().MaxLines());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_MinLines(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().MinLines());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_TextStacking(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().TextStacking());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Align(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Align());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics> : produce_base<D, Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics>
{
int32_t __stdcall get_Caption(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Caption());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Body(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Body());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Base(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Base());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Subtitle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Subtitle());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Title(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Title());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Subheader(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Subheader());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Header(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Header());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_TitleNumeral(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().TitleNumeral());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_SubheaderNumeral(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().SubheaderNumeral());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_HeaderNumeral(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().HeaderNumeral());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_CaptionSubtle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().CaptionSubtle());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_BodySubtle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().BodySubtle());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_BaseSubtle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().BaseSubtle());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_SubtitleSubtle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().SubtitleSubtle());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_TitleSubtle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().TitleSubtle());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_SubheaderSubtle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().SubheaderSubtle());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_SubheaderNumeralSubtle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().SubheaderNumeralSubtle());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_HeaderSubtle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().HeaderSubtle());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_HeaderNumeralSubtle(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().HeaderNumeralSubtle());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IKnownNotificationBindingsStatics> : produce_base<D, Windows::UI::Notifications::IKnownNotificationBindingsStatics>
{
int32_t __stdcall get_ToastGeneric(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().ToastGeneric());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::INotification> : produce_base<D, Windows::UI::Notifications::INotification>
{
int32_t __stdcall get_ExpirationTime(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::IReference<Windows::Foundation::DateTime>>(this->shim().ExpirationTime());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_ExpirationTime(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().ExpirationTime(*reinterpret_cast<Windows::Foundation::IReference<Windows::Foundation::DateTime> const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Visual(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::NotificationVisual>(this->shim().Visual());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Visual(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Visual(*reinterpret_cast<Windows::UI::Notifications::NotificationVisual const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::INotificationBinding> : produce_base<D, Windows::UI::Notifications::INotificationBinding>
{
int32_t __stdcall get_Template(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Template());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Template(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Template(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Language(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Language());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Language(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Language(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Hints(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::Collections::IMap<hstring, hstring>>(this->shim().Hints());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetTextElements(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::AdaptiveNotificationText>>(this->shim().GetTextElements());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::INotificationData> : produce_base<D, Windows::UI::Notifications::INotificationData>
{
int32_t __stdcall get_Values(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::Collections::IMap<hstring, hstring>>(this->shim().Values());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_SequenceNumber(uint32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<uint32_t>(this->shim().SequenceNumber());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_SequenceNumber(uint32_t value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().SequenceNumber(value);
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::INotificationDataFactory> : produce_base<D, Windows::UI::Notifications::INotificationDataFactory>
{
int32_t __stdcall CreateNotificationDataWithValuesAndSequenceNumber(void* initialValues, uint32_t sequenceNumber, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::NotificationData>(this->shim().CreateNotificationData(*reinterpret_cast<Windows::Foundation::Collections::IIterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> const*>(&initialValues), sequenceNumber));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateNotificationDataWithValues(void* initialValues, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::NotificationData>(this->shim().CreateNotificationData(*reinterpret_cast<Windows::Foundation::Collections::IIterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> const*>(&initialValues)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::INotificationVisual> : produce_base<D, Windows::UI::Notifications::INotificationVisual>
{
int32_t __stdcall get_Language(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Language());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Language(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Language(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Bindings(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::Collections::IVector<Windows::UI::Notifications::NotificationBinding>>(this->shim().Bindings());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetBinding(void* templateName, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::NotificationBinding>(this->shim().GetBinding(*reinterpret_cast<hstring const*>(&templateName)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IScheduledTileNotification> : produce_base<D, Windows::UI::Notifications::IScheduledTileNotification>
{
int32_t __stdcall get_Content(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().Content());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_DeliveryTime(int64_t* value) noexcept final try
{
zero_abi<Windows::Foundation::DateTime>(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::DateTime>(this->shim().DeliveryTime());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_ExpirationTime(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().ExpirationTime(*reinterpret_cast<Windows::Foundation::IReference<Windows::Foundation::DateTime> const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_ExpirationTime(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::IReference<Windows::Foundation::DateTime>>(this->shim().ExpirationTime());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Tag(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Tag(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Tag(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Tag());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Id(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Id(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Id(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Id());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IScheduledTileNotificationFactory> : produce_base<D, Windows::UI::Notifications::IScheduledTileNotificationFactory>
{
int32_t __stdcall CreateScheduledTileNotification(void* content, int64_t deliveryTime, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ScheduledTileNotification>(this->shim().CreateScheduledTileNotification(*reinterpret_cast<Windows::Data::Xml::Dom::XmlDocument const*>(&content), *reinterpret_cast<Windows::Foundation::DateTime const*>(&deliveryTime)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IScheduledToastNotification> : produce_base<D, Windows::UI::Notifications::IScheduledToastNotification>
{
int32_t __stdcall get_Content(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().Content());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_DeliveryTime(int64_t* value) noexcept final try
{
zero_abi<Windows::Foundation::DateTime>(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::DateTime>(this->shim().DeliveryTime());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_SnoozeInterval(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::IReference<Windows::Foundation::TimeSpan>>(this->shim().SnoozeInterval());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_MaximumSnoozeCount(uint32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<uint32_t>(this->shim().MaximumSnoozeCount());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Id(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Id(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Id(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Id());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IScheduledToastNotification2> : produce_base<D, Windows::UI::Notifications::IScheduledToastNotification2>
{
int32_t __stdcall put_Tag(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Tag(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Tag(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Tag());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Group(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Group(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Group(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Group());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_SuppressPopup(bool value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().SuppressPopup(value);
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_SuppressPopup(bool* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<bool>(this->shim().SuppressPopup());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IScheduledToastNotification3> : produce_base<D, Windows::UI::Notifications::IScheduledToastNotification3>
{
int32_t __stdcall get_NotificationMirroring(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::NotificationMirroring>(this->shim().NotificationMirroring());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_NotificationMirroring(int32_t value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().NotificationMirroring(*reinterpret_cast<Windows::UI::Notifications::NotificationMirroring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_RemoteId(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().RemoteId());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_RemoteId(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().RemoteId(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IScheduledToastNotification4> : produce_base<D, Windows::UI::Notifications::IScheduledToastNotification4>
{
int32_t __stdcall get_ExpirationTime(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::IReference<Windows::Foundation::DateTime>>(this->shim().ExpirationTime());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_ExpirationTime(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().ExpirationTime(*reinterpret_cast<Windows::Foundation::IReference<Windows::Foundation::DateTime> const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IScheduledToastNotificationFactory> : produce_base<D, Windows::UI::Notifications::IScheduledToastNotificationFactory>
{
int32_t __stdcall CreateScheduledToastNotification(void* content, int64_t deliveryTime, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ScheduledToastNotification>(this->shim().CreateScheduledToastNotification(*reinterpret_cast<Windows::Data::Xml::Dom::XmlDocument const*>(&content), *reinterpret_cast<Windows::Foundation::DateTime const*>(&deliveryTime)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateScheduledToastNotificationRecurring(void* content, int64_t deliveryTime, int64_t snoozeInterval, uint32_t maximumSnoozeCount, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ScheduledToastNotification>(this->shim().CreateScheduledToastNotificationRecurring(*reinterpret_cast<Windows::Data::Xml::Dom::XmlDocument const*>(&content), *reinterpret_cast<Windows::Foundation::DateTime const*>(&deliveryTime), *reinterpret_cast<Windows::Foundation::TimeSpan const*>(&snoozeInterval), maximumSnoozeCount));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IScheduledToastNotificationShowingEventArgs> : produce_base<D, Windows::UI::Notifications::IScheduledToastNotificationShowingEventArgs>
{
int32_t __stdcall get_Cancel(bool* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<bool>(this->shim().Cancel());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Cancel(bool value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Cancel(value);
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_ScheduledToastNotification(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ScheduledToastNotification>(this->shim().ScheduledToastNotification());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetDeferral(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Foundation::Deferral>(this->shim().GetDeferral());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IShownTileNotification> : produce_base<D, Windows::UI::Notifications::IShownTileNotification>
{
int32_t __stdcall get_Arguments(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Arguments());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileFlyoutNotification> : produce_base<D, Windows::UI::Notifications::ITileFlyoutNotification>
{
int32_t __stdcall get_Content(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().Content());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_ExpirationTime(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().ExpirationTime(*reinterpret_cast<Windows::Foundation::IReference<Windows::Foundation::DateTime> const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_ExpirationTime(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::IReference<Windows::Foundation::DateTime>>(this->shim().ExpirationTime());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileFlyoutNotificationFactory> : produce_base<D, Windows::UI::Notifications::ITileFlyoutNotificationFactory>
{
int32_t __stdcall CreateTileFlyoutNotification(void* content, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::TileFlyoutNotification>(this->shim().CreateTileFlyoutNotification(*reinterpret_cast<Windows::Data::Xml::Dom::XmlDocument const*>(&content)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileFlyoutUpdateManagerStatics> : produce_base<D, Windows::UI::Notifications::ITileFlyoutUpdateManagerStatics>
{
int32_t __stdcall CreateTileFlyoutUpdaterForApplication(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileFlyoutUpdater>(this->shim().CreateTileFlyoutUpdaterForApplication());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateTileFlyoutUpdaterForApplicationWithId(void* applicationId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileFlyoutUpdater>(this->shim().CreateTileFlyoutUpdaterForApplication(*reinterpret_cast<hstring const*>(&applicationId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateTileFlyoutUpdaterForSecondaryTile(void* tileId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileFlyoutUpdater>(this->shim().CreateTileFlyoutUpdaterForSecondaryTile(*reinterpret_cast<hstring const*>(&tileId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetTemplateContent(int32_t type, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().GetTemplateContent(*reinterpret_cast<Windows::UI::Notifications::TileFlyoutTemplateType const*>(&type)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileFlyoutUpdater> : produce_base<D, Windows::UI::Notifications::ITileFlyoutUpdater>
{
int32_t __stdcall Update(void* notification) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Update(*reinterpret_cast<Windows::UI::Notifications::TileFlyoutNotification const*>(¬ification));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall Clear() noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Clear();
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StartPeriodicUpdate(void* tileFlyoutContent, int32_t requestedInterval) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StartPeriodicUpdate(*reinterpret_cast<Windows::Foundation::Uri const*>(&tileFlyoutContent), *reinterpret_cast<Windows::UI::Notifications::PeriodicUpdateRecurrence const*>(&requestedInterval));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StartPeriodicUpdateAtTime(void* tileFlyoutContent, int64_t startTime, int32_t requestedInterval) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StartPeriodicUpdate(*reinterpret_cast<Windows::Foundation::Uri const*>(&tileFlyoutContent), *reinterpret_cast<Windows::Foundation::DateTime const*>(&startTime), *reinterpret_cast<Windows::UI::Notifications::PeriodicUpdateRecurrence const*>(&requestedInterval));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StopPeriodicUpdate() noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StopPeriodicUpdate();
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Setting(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::NotificationSetting>(this->shim().Setting());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileNotification> : produce_base<D, Windows::UI::Notifications::ITileNotification>
{
int32_t __stdcall get_Content(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().Content());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_ExpirationTime(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().ExpirationTime(*reinterpret_cast<Windows::Foundation::IReference<Windows::Foundation::DateTime> const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_ExpirationTime(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::IReference<Windows::Foundation::DateTime>>(this->shim().ExpirationTime());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Tag(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Tag(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Tag(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Tag());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileNotificationFactory> : produce_base<D, Windows::UI::Notifications::ITileNotificationFactory>
{
int32_t __stdcall CreateTileNotification(void* content, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::TileNotification>(this->shim().CreateTileNotification(*reinterpret_cast<Windows::Data::Xml::Dom::XmlDocument const*>(&content)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileUpdateManagerForUser> : produce_base<D, Windows::UI::Notifications::ITileUpdateManagerForUser>
{
int32_t __stdcall CreateTileUpdaterForApplication(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileUpdater>(this->shim().CreateTileUpdaterForApplicationForUser());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateTileUpdaterForApplicationWithId(void* applicationId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileUpdater>(this->shim().CreateTileUpdaterForApplication(*reinterpret_cast<hstring const*>(&applicationId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateTileUpdaterForSecondaryTile(void* tileId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileUpdater>(this->shim().CreateTileUpdaterForSecondaryTile(*reinterpret_cast<hstring const*>(&tileId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_User(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::System::User>(this->shim().User());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileUpdateManagerStatics> : produce_base<D, Windows::UI::Notifications::ITileUpdateManagerStatics>
{
int32_t __stdcall CreateTileUpdaterForApplication(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileUpdater>(this->shim().CreateTileUpdaterForApplication());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateTileUpdaterForApplicationWithId(void* applicationId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileUpdater>(this->shim().CreateTileUpdaterForApplication(*reinterpret_cast<hstring const*>(&applicationId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateTileUpdaterForSecondaryTile(void* tileId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileUpdater>(this->shim().CreateTileUpdaterForSecondaryTile(*reinterpret_cast<hstring const*>(&tileId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetTemplateContent(int32_t type, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().GetTemplateContent(*reinterpret_cast<Windows::UI::Notifications::TileTemplateType const*>(&type)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileUpdateManagerStatics2> : produce_base<D, Windows::UI::Notifications::ITileUpdateManagerStatics2>
{
int32_t __stdcall GetForUser(void* user, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::TileUpdateManagerForUser>(this->shim().GetForUser(*reinterpret_cast<Windows::System::User const*>(&user)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileUpdater> : produce_base<D, Windows::UI::Notifications::ITileUpdater>
{
int32_t __stdcall Update(void* notification) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Update(*reinterpret_cast<Windows::UI::Notifications::TileNotification const*>(¬ification));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall Clear() noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Clear();
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall EnableNotificationQueue(bool enable) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().EnableNotificationQueue(enable);
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Setting(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::NotificationSetting>(this->shim().Setting());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall AddToSchedule(void* scheduledTile) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().AddToSchedule(*reinterpret_cast<Windows::UI::Notifications::ScheduledTileNotification const*>(&scheduledTile));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall RemoveFromSchedule(void* scheduledTile) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().RemoveFromSchedule(*reinterpret_cast<Windows::UI::Notifications::ScheduledTileNotification const*>(&scheduledTile));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetScheduledTileNotifications(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ScheduledTileNotification>>(this->shim().GetScheduledTileNotifications());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StartPeriodicUpdate(void* tileContent, int32_t requestedInterval) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StartPeriodicUpdate(*reinterpret_cast<Windows::Foundation::Uri const*>(&tileContent), *reinterpret_cast<Windows::UI::Notifications::PeriodicUpdateRecurrence const*>(&requestedInterval));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StartPeriodicUpdateAtTime(void* tileContent, int64_t startTime, int32_t requestedInterval) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StartPeriodicUpdate(*reinterpret_cast<Windows::Foundation::Uri const*>(&tileContent), *reinterpret_cast<Windows::Foundation::DateTime const*>(&startTime), *reinterpret_cast<Windows::UI::Notifications::PeriodicUpdateRecurrence const*>(&requestedInterval));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StopPeriodicUpdate() noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StopPeriodicUpdate();
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StartPeriodicUpdateBatch(void* tileContents, int32_t requestedInterval) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StartPeriodicUpdateBatch(*reinterpret_cast<Windows::Foundation::Collections::IIterable<Windows::Foundation::Uri> const*>(&tileContents), *reinterpret_cast<Windows::UI::Notifications::PeriodicUpdateRecurrence const*>(&requestedInterval));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall StartPeriodicUpdateBatchAtTime(void* tileContents, int64_t startTime, int32_t requestedInterval) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().StartPeriodicUpdateBatch(*reinterpret_cast<Windows::Foundation::Collections::IIterable<Windows::Foundation::Uri> const*>(&tileContents), *reinterpret_cast<Windows::Foundation::DateTime const*>(&startTime), *reinterpret_cast<Windows::UI::Notifications::PeriodicUpdateRecurrence const*>(&requestedInterval));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::ITileUpdater2> : produce_base<D, Windows::UI::Notifications::ITileUpdater2>
{
int32_t __stdcall EnableNotificationQueueForSquare150x150(bool enable) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().EnableNotificationQueueForSquare150x150(enable);
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall EnableNotificationQueueForWide310x150(bool enable) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().EnableNotificationQueueForWide310x150(enable);
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall EnableNotificationQueueForSquare310x310(bool enable) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().EnableNotificationQueueForSquare310x310(enable);
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastActivatedEventArgs> : produce_base<D, Windows::UI::Notifications::IToastActivatedEventArgs>
{
int32_t __stdcall get_Arguments(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Arguments());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastActivatedEventArgs2> : produce_base<D, Windows::UI::Notifications::IToastActivatedEventArgs2>
{
int32_t __stdcall get_UserInput(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::Collections::ValueSet>(this->shim().UserInput());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastCollection> : produce_base<D, Windows::UI::Notifications::IToastCollection>
{
int32_t __stdcall get_Id(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Id());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_DisplayName(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().DisplayName());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_DisplayName(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().DisplayName(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_LaunchArgs(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().LaunchArgs());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_LaunchArgs(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().LaunchArgs(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Icon(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::Uri>(this->shim().Icon());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Icon(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Icon(*reinterpret_cast<Windows::Foundation::Uri const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastCollectionFactory> : produce_base<D, Windows::UI::Notifications::IToastCollectionFactory>
{
int32_t __stdcall CreateInstance(void* collectionId, void* displayName, void* launchArgs, void* iconUri, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ToastCollection>(this->shim().CreateInstance(*reinterpret_cast<hstring const*>(&collectionId), *reinterpret_cast<hstring const*>(&displayName), *reinterpret_cast<hstring const*>(&launchArgs), *reinterpret_cast<Windows::Foundation::Uri const*>(&iconUri)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastCollectionManager> : produce_base<D, Windows::UI::Notifications::IToastCollectionManager>
{
int32_t __stdcall SaveToastCollectionAsync(void* collection, void** operation) noexcept final try
{
clear_abi(operation);
typename D::abi_guard guard(this->shim());
*operation = detach_from<Windows::Foundation::IAsyncAction>(this->shim().SaveToastCollectionAsync(*reinterpret_cast<Windows::UI::Notifications::ToastCollection const*>(&collection)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall FindAllToastCollectionsAsync(void** operation) noexcept final try
{
clear_abi(operation);
typename D::abi_guard guard(this->shim());
*operation = detach_from<Windows::Foundation::IAsyncOperation<Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ToastCollection>>>(this->shim().FindAllToastCollectionsAsync());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetToastCollectionAsync(void* collectionId, void** operation) noexcept final try
{
clear_abi(operation);
typename D::abi_guard guard(this->shim());
*operation = detach_from<Windows::Foundation::IAsyncOperation<Windows::UI::Notifications::ToastCollection>>(this->shim().GetToastCollectionAsync(*reinterpret_cast<hstring const*>(&collectionId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall RemoveToastCollectionAsync(void* collectionId, void** operation) noexcept final try
{
clear_abi(operation);
typename D::abi_guard guard(this->shim());
*operation = detach_from<Windows::Foundation::IAsyncAction>(this->shim().RemoveToastCollectionAsync(*reinterpret_cast<hstring const*>(&collectionId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall RemoveAllToastCollectionsAsync(void** operation) noexcept final try
{
clear_abi(operation);
typename D::abi_guard guard(this->shim());
*operation = detach_from<Windows::Foundation::IAsyncAction>(this->shim().RemoveAllToastCollectionsAsync());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_User(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::System::User>(this->shim().User());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_AppId(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().AppId());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastDismissedEventArgs> : produce_base<D, Windows::UI::Notifications::IToastDismissedEventArgs>
{
int32_t __stdcall get_Reason(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ToastDismissalReason>(this->shim().Reason());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastFailedEventArgs> : produce_base<D, Windows::UI::Notifications::IToastFailedEventArgs>
{
int32_t __stdcall get_ErrorCode(winrt::hresult* value) noexcept final try
{
zero_abi<winrt::hresult>(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<winrt::hresult>(this->shim().ErrorCode());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotification> : produce_base<D, Windows::UI::Notifications::IToastNotification>
{
int32_t __stdcall get_Content(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().Content());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_ExpirationTime(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().ExpirationTime(*reinterpret_cast<Windows::Foundation::IReference<Windows::Foundation::DateTime> const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_ExpirationTime(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::IReference<Windows::Foundation::DateTime>>(this->shim().ExpirationTime());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall add_Dismissed(void* handler, winrt::event_token* token) noexcept final try
{
zero_abi<winrt::event_token>(token);
typename D::abi_guard guard(this->shim());
*token = detach_from<winrt::event_token>(this->shim().Dismissed(*reinterpret_cast<Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotification, Windows::UI::Notifications::ToastDismissedEventArgs> const*>(&handler)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall remove_Dismissed(winrt::event_token token) noexcept final
{
typename D::abi_guard guard(this->shim());
this->shim().Dismissed(*reinterpret_cast<winrt::event_token const*>(&token));
return 0;
}
int32_t __stdcall add_Activated(void* handler, winrt::event_token* token) noexcept final try
{
zero_abi<winrt::event_token>(token);
typename D::abi_guard guard(this->shim());
*token = detach_from<winrt::event_token>(this->shim().Activated(*reinterpret_cast<Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotification, Windows::Foundation::IInspectable> const*>(&handler)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall remove_Activated(winrt::event_token token) noexcept final
{
typename D::abi_guard guard(this->shim());
this->shim().Activated(*reinterpret_cast<winrt::event_token const*>(&token));
return 0;
}
int32_t __stdcall add_Failed(void* handler, winrt::event_token* token) noexcept final try
{
zero_abi<winrt::event_token>(token);
typename D::abi_guard guard(this->shim());
*token = detach_from<winrt::event_token>(this->shim().Failed(*reinterpret_cast<Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotification, Windows::UI::Notifications::ToastFailedEventArgs> const*>(&handler)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall remove_Failed(winrt::event_token token) noexcept final
{
typename D::abi_guard guard(this->shim());
this->shim().Failed(*reinterpret_cast<winrt::event_token const*>(&token));
return 0;
}
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotification2> : produce_base<D, Windows::UI::Notifications::IToastNotification2>
{
int32_t __stdcall put_Tag(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Tag(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Tag(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Tag());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Group(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Group(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Group(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Group());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_SuppressPopup(bool value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().SuppressPopup(value);
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_SuppressPopup(bool* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<bool>(this->shim().SuppressPopup());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotification3> : produce_base<D, Windows::UI::Notifications::IToastNotification3>
{
int32_t __stdcall get_NotificationMirroring(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::NotificationMirroring>(this->shim().NotificationMirroring());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_NotificationMirroring(int32_t value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().NotificationMirroring(*reinterpret_cast<Windows::UI::Notifications::NotificationMirroring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_RemoteId(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().RemoteId());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_RemoteId(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().RemoteId(*reinterpret_cast<hstring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotification4> : produce_base<D, Windows::UI::Notifications::IToastNotification4>
{
int32_t __stdcall get_Data(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::NotificationData>(this->shim().Data());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Data(void* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Data(*reinterpret_cast<Windows::UI::Notifications::NotificationData const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Priority(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ToastNotificationPriority>(this->shim().Priority());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_Priority(int32_t value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Priority(*reinterpret_cast<Windows::UI::Notifications::ToastNotificationPriority const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotification6> : produce_base<D, Windows::UI::Notifications::IToastNotification6>
{
int32_t __stdcall get_ExpiresOnReboot(bool* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<bool>(this->shim().ExpiresOnReboot());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall put_ExpiresOnReboot(bool value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().ExpiresOnReboot(value);
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationActionTriggerDetail> : produce_base<D, Windows::UI::Notifications::IToastNotificationActionTriggerDetail>
{
int32_t __stdcall get_Argument(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().Argument());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_UserInput(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::Collections::ValueSet>(this->shim().UserInput());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationFactory> : produce_base<D, Windows::UI::Notifications::IToastNotificationFactory>
{
int32_t __stdcall CreateToastNotification(void* content, void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ToastNotification>(this->shim().CreateToastNotification(*reinterpret_cast<Windows::Data::Xml::Dom::XmlDocument const*>(&content)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationHistory> : produce_base<D, Windows::UI::Notifications::IToastNotificationHistory>
{
int32_t __stdcall RemoveGroup(void* group) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().RemoveGroup(*reinterpret_cast<hstring const*>(&group));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall RemoveGroupWithId(void* group, void* applicationId) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().RemoveGroup(*reinterpret_cast<hstring const*>(&group), *reinterpret_cast<hstring const*>(&applicationId));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall RemoveGroupedTagWithId(void* tag, void* group, void* applicationId) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Remove(*reinterpret_cast<hstring const*>(&tag), *reinterpret_cast<hstring const*>(&group), *reinterpret_cast<hstring const*>(&applicationId));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall RemoveGroupedTag(void* tag, void* group) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Remove(*reinterpret_cast<hstring const*>(&tag), *reinterpret_cast<hstring const*>(&group));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall Remove(void* tag) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Remove(*reinterpret_cast<hstring const*>(&tag));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall Clear() noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Clear();
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall ClearWithId(void* applicationId) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Clear(*reinterpret_cast<hstring const*>(&applicationId));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationHistory2> : produce_base<D, Windows::UI::Notifications::IToastNotificationHistory2>
{
int32_t __stdcall GetHistory(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ToastNotification>>(this->shim().GetHistory());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetHistoryWithId(void* applicationId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ToastNotification>>(this->shim().GetHistory(*reinterpret_cast<hstring const*>(&applicationId)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail> : produce_base<D, Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail>
{
int32_t __stdcall get_ChangeType(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ToastHistoryChangedType>(this->shim().ChangeType());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail2> : produce_base<D, Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail2>
{
int32_t __stdcall get_CollectionId(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<hstring>(this->shim().CollectionId());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationManagerForUser> : produce_base<D, Windows::UI::Notifications::IToastNotificationManagerForUser>
{
int32_t __stdcall CreateToastNotifier(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::ToastNotifier>(this->shim().CreateToastNotifier());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateToastNotifierWithId(void* applicationId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::ToastNotifier>(this->shim().CreateToastNotifier(*reinterpret_cast<hstring const*>(&applicationId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_History(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ToastNotificationHistory>(this->shim().History());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_User(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::System::User>(this->shim().User());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationManagerForUser2> : produce_base<D, Windows::UI::Notifications::IToastNotificationManagerForUser2>
{
int32_t __stdcall GetToastNotifierForToastCollectionIdAsync(void* collectionId, void** operation) noexcept final try
{
clear_abi(operation);
typename D::abi_guard guard(this->shim());
*operation = detach_from<Windows::Foundation::IAsyncOperation<Windows::UI::Notifications::ToastNotifier>>(this->shim().GetToastNotifierForToastCollectionIdAsync(*reinterpret_cast<hstring const*>(&collectionId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetHistoryForToastCollectionIdAsync(void* collectionId, void** operation) noexcept final try
{
clear_abi(operation);
typename D::abi_guard guard(this->shim());
*operation = detach_from<Windows::Foundation::IAsyncOperation<Windows::UI::Notifications::ToastNotificationHistory>>(this->shim().GetHistoryForToastCollectionIdAsync(*reinterpret_cast<hstring const*>(&collectionId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetToastCollectionManager(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::ToastCollectionManager>(this->shim().GetToastCollectionManager());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetToastCollectionManagerWithAppId(void* appId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::ToastCollectionManager>(this->shim().GetToastCollectionManager(*reinterpret_cast<hstring const*>(&appId)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationManagerStatics> : produce_base<D, Windows::UI::Notifications::IToastNotificationManagerStatics>
{
int32_t __stdcall CreateToastNotifier(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::ToastNotifier>(this->shim().CreateToastNotifier());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall CreateToastNotifierWithId(void* applicationId, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::ToastNotifier>(this->shim().CreateToastNotifier(*reinterpret_cast<hstring const*>(&applicationId)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetTemplateContent(int32_t type, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Data::Xml::Dom::XmlDocument>(this->shim().GetTemplateContent(*reinterpret_cast<Windows::UI::Notifications::ToastTemplateType const*>(&type)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationManagerStatics2> : produce_base<D, Windows::UI::Notifications::IToastNotificationManagerStatics2>
{
int32_t __stdcall get_History(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::ToastNotificationHistory>(this->shim().History());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationManagerStatics4> : produce_base<D, Windows::UI::Notifications::IToastNotificationManagerStatics4>
{
int32_t __stdcall GetForUser(void* user, void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::ToastNotificationManagerForUser>(this->shim().GetForUser(*reinterpret_cast<Windows::System::User const*>(&user)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall ConfigureNotificationMirroring(int32_t value) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().ConfigureNotificationMirroring(*reinterpret_cast<Windows::UI::Notifications::NotificationMirroring const*>(&value));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotificationManagerStatics5> : produce_base<D, Windows::UI::Notifications::IToastNotificationManagerStatics5>
{
int32_t __stdcall GetDefault(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::ToastNotificationManagerForUser>(this->shim().GetDefault());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotifier> : produce_base<D, Windows::UI::Notifications::IToastNotifier>
{
int32_t __stdcall Show(void* notification) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Show(*reinterpret_cast<Windows::UI::Notifications::ToastNotification const*>(¬ification));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall Hide(void* notification) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().Hide(*reinterpret_cast<Windows::UI::Notifications::ToastNotification const*>(¬ification));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Setting(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::NotificationSetting>(this->shim().Setting());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall AddToSchedule(void* scheduledToast) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().AddToSchedule(*reinterpret_cast<Windows::UI::Notifications::ScheduledToastNotification const*>(&scheduledToast));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall RemoveFromSchedule(void* scheduledToast) noexcept final try
{
typename D::abi_guard guard(this->shim());
this->shim().RemoveFromSchedule(*reinterpret_cast<Windows::UI::Notifications::ScheduledToastNotification const*>(&scheduledToast));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall GetScheduledToastNotifications(void** result) noexcept final try
{
clear_abi(result);
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::Foundation::Collections::IVectorView<Windows::UI::Notifications::ScheduledToastNotification>>(this->shim().GetScheduledToastNotifications());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotifier2> : produce_base<D, Windows::UI::Notifications::IToastNotifier2>
{
int32_t __stdcall UpdateWithTagAndGroup(void* data, void* tag, void* group, int32_t* result) noexcept final try
{
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::NotificationUpdateResult>(this->shim().Update(*reinterpret_cast<Windows::UI::Notifications::NotificationData const*>(&data), *reinterpret_cast<hstring const*>(&tag), *reinterpret_cast<hstring const*>(&group)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall UpdateWithTag(void* data, void* tag, int32_t* result) noexcept final try
{
typename D::abi_guard guard(this->shim());
*result = detach_from<Windows::UI::Notifications::NotificationUpdateResult>(this->shim().Update(*reinterpret_cast<Windows::UI::Notifications::NotificationData const*>(&data), *reinterpret_cast<hstring const*>(&tag)));
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IToastNotifier3> : produce_base<D, Windows::UI::Notifications::IToastNotifier3>
{
int32_t __stdcall add_ScheduledToastNotificationShowing(void* handler, winrt::event_token* token) noexcept final try
{
zero_abi<winrt::event_token>(token);
typename D::abi_guard guard(this->shim());
*token = detach_from<winrt::event_token>(this->shim().ScheduledToastNotificationShowing(*reinterpret_cast<Windows::Foundation::TypedEventHandler<Windows::UI::Notifications::ToastNotifier, Windows::UI::Notifications::ScheduledToastNotificationShowingEventArgs> const*>(&handler)));
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall remove_ScheduledToastNotificationShowing(winrt::event_token token) noexcept final
{
typename D::abi_guard guard(this->shim());
this->shim().ScheduledToastNotificationShowing(*reinterpret_cast<winrt::event_token const*>(&token));
return 0;
}
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IUserNotification> : produce_base<D, Windows::UI::Notifications::IUserNotification>
{
int32_t __stdcall get_Notification(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::Notification>(this->shim().Notification());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_AppInfo(void** value) noexcept final try
{
clear_abi(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::ApplicationModel::AppInfo>(this->shim().AppInfo());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_Id(uint32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<uint32_t>(this->shim().Id());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_CreationTime(int64_t* value) noexcept final try
{
zero_abi<Windows::Foundation::DateTime>(value);
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::Foundation::DateTime>(this->shim().CreationTime());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
#ifndef WINRT_LEAN_AND_MEAN
template <typename D>
struct produce<D, Windows::UI::Notifications::IUserNotificationChangedEventArgs> : produce_base<D, Windows::UI::Notifications::IUserNotificationChangedEventArgs>
{
int32_t __stdcall get_ChangeKind(int32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<Windows::UI::Notifications::UserNotificationChangedKind>(this->shim().ChangeKind());
return 0;
}
catch (...) { return to_hresult(); }
int32_t __stdcall get_UserNotificationId(uint32_t* value) noexcept final try
{
typename D::abi_guard guard(this->shim());
*value = detach_from<uint32_t>(this->shim().UserNotificationId());
return 0;
}
catch (...) { return to_hresult(); }
};
#endif
}
WINRT_EXPORT namespace winrt::Windows::UI::Notifications
{
constexpr auto operator|(NotificationKinds const left, NotificationKinds const right) noexcept
{
return static_cast<NotificationKinds>(impl::to_underlying_type(left) | impl::to_underlying_type(right));
}
constexpr auto operator|=(NotificationKinds& left, NotificationKinds const right) noexcept
{
left = left | right;
return left;
}
constexpr auto operator&(NotificationKinds const left, NotificationKinds const right) noexcept
{
return static_cast<NotificationKinds>(impl::to_underlying_type(left) & impl::to_underlying_type(right));
}
constexpr auto operator&=(NotificationKinds& left, NotificationKinds const right) noexcept
{
left = left & right;
return left;
}
constexpr auto operator~(NotificationKinds const value) noexcept
{
return static_cast<NotificationKinds>(~impl::to_underlying_type(value));
}
constexpr auto operator^(NotificationKinds const left, NotificationKinds const right) noexcept
{
return static_cast<NotificationKinds>(impl::to_underlying_type(left) ^ impl::to_underlying_type(right));
}
constexpr auto operator^=(NotificationKinds& left, NotificationKinds const right) noexcept
{
left = left ^ right;
return left;
}
inline AdaptiveNotificationText::AdaptiveNotificationText() :
AdaptiveNotificationText(impl::call_factory_cast<AdaptiveNotificationText(*)(Windows::Foundation::IActivationFactory const&), AdaptiveNotificationText>([](Windows::Foundation::IActivationFactory const& f) { return f.template ActivateInstance<AdaptiveNotificationText>(); }))
{
}
inline BadgeNotification::BadgeNotification(Windows::Data::Xml::Dom::XmlDocument const& content) :
BadgeNotification(impl::call_factory<BadgeNotification, IBadgeNotificationFactory>([&](IBadgeNotificationFactory const& f) { return f.CreateBadgeNotification(content); }))
{
}
inline auto BadgeUpdateManager::CreateBadgeUpdaterForApplication()
{
return impl::call_factory_cast<Windows::UI::Notifications::BadgeUpdater(*)(IBadgeUpdateManagerStatics const&), BadgeUpdateManager, IBadgeUpdateManagerStatics>([](IBadgeUpdateManagerStatics const& f) { return f.CreateBadgeUpdaterForApplication(); });
}
inline auto BadgeUpdateManager::CreateBadgeUpdaterForApplication(param::hstring const& applicationId)
{
return impl::call_factory<BadgeUpdateManager, IBadgeUpdateManagerStatics>([&](IBadgeUpdateManagerStatics const& f) { return f.CreateBadgeUpdaterForApplication(applicationId); });
}
inline auto BadgeUpdateManager::CreateBadgeUpdaterForSecondaryTile(param::hstring const& tileId)
{
return impl::call_factory<BadgeUpdateManager, IBadgeUpdateManagerStatics>([&](IBadgeUpdateManagerStatics const& f) { return f.CreateBadgeUpdaterForSecondaryTile(tileId); });
}
inline auto BadgeUpdateManager::GetTemplateContent(Windows::UI::Notifications::BadgeTemplateType const& type)
{
return impl::call_factory<BadgeUpdateManager, IBadgeUpdateManagerStatics>([&](IBadgeUpdateManagerStatics const& f) { return f.GetTemplateContent(type); });
}
inline auto BadgeUpdateManager::GetForUser(Windows::System::User const& user)
{
return impl::call_factory<BadgeUpdateManager, IBadgeUpdateManagerStatics2>([&](IBadgeUpdateManagerStatics2 const& f) { return f.GetForUser(user); });
}
inline auto KnownAdaptiveNotificationHints::Style()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationHintsStatics const&), KnownAdaptiveNotificationHints, IKnownAdaptiveNotificationHintsStatics>([](IKnownAdaptiveNotificationHintsStatics const& f) { return f.Style(); });
}
inline auto KnownAdaptiveNotificationHints::Wrap()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationHintsStatics const&), KnownAdaptiveNotificationHints, IKnownAdaptiveNotificationHintsStatics>([](IKnownAdaptiveNotificationHintsStatics const& f) { return f.Wrap(); });
}
inline auto KnownAdaptiveNotificationHints::MaxLines()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationHintsStatics const&), KnownAdaptiveNotificationHints, IKnownAdaptiveNotificationHintsStatics>([](IKnownAdaptiveNotificationHintsStatics const& f) { return f.MaxLines(); });
}
inline auto KnownAdaptiveNotificationHints::MinLines()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationHintsStatics const&), KnownAdaptiveNotificationHints, IKnownAdaptiveNotificationHintsStatics>([](IKnownAdaptiveNotificationHintsStatics const& f) { return f.MinLines(); });
}
inline auto KnownAdaptiveNotificationHints::TextStacking()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationHintsStatics const&), KnownAdaptiveNotificationHints, IKnownAdaptiveNotificationHintsStatics>([](IKnownAdaptiveNotificationHintsStatics const& f) { return f.TextStacking(); });
}
inline auto KnownAdaptiveNotificationHints::Align()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationHintsStatics const&), KnownAdaptiveNotificationHints, IKnownAdaptiveNotificationHintsStatics>([](IKnownAdaptiveNotificationHintsStatics const& f) { return f.Align(); });
}
inline auto KnownAdaptiveNotificationTextStyles::Caption()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.Caption(); });
}
inline auto KnownAdaptiveNotificationTextStyles::Body()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.Body(); });
}
inline auto KnownAdaptiveNotificationTextStyles::Base()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.Base(); });
}
inline auto KnownAdaptiveNotificationTextStyles::Subtitle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.Subtitle(); });
}
inline auto KnownAdaptiveNotificationTextStyles::Title()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.Title(); });
}
inline auto KnownAdaptiveNotificationTextStyles::Subheader()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.Subheader(); });
}
inline auto KnownAdaptiveNotificationTextStyles::Header()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.Header(); });
}
inline auto KnownAdaptiveNotificationTextStyles::TitleNumeral()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.TitleNumeral(); });
}
inline auto KnownAdaptiveNotificationTextStyles::SubheaderNumeral()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.SubheaderNumeral(); });
}
inline auto KnownAdaptiveNotificationTextStyles::HeaderNumeral()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.HeaderNumeral(); });
}
inline auto KnownAdaptiveNotificationTextStyles::CaptionSubtle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.CaptionSubtle(); });
}
inline auto KnownAdaptiveNotificationTextStyles::BodySubtle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.BodySubtle(); });
}
inline auto KnownAdaptiveNotificationTextStyles::BaseSubtle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.BaseSubtle(); });
}
inline auto KnownAdaptiveNotificationTextStyles::SubtitleSubtle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.SubtitleSubtle(); });
}
inline auto KnownAdaptiveNotificationTextStyles::TitleSubtle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.TitleSubtle(); });
}
inline auto KnownAdaptiveNotificationTextStyles::SubheaderSubtle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.SubheaderSubtle(); });
}
inline auto KnownAdaptiveNotificationTextStyles::SubheaderNumeralSubtle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.SubheaderNumeralSubtle(); });
}
inline auto KnownAdaptiveNotificationTextStyles::HeaderSubtle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.HeaderSubtle(); });
}
inline auto KnownAdaptiveNotificationTextStyles::HeaderNumeralSubtle()
{
return impl::call_factory_cast<hstring(*)(IKnownAdaptiveNotificationTextStylesStatics const&), KnownAdaptiveNotificationTextStyles, IKnownAdaptiveNotificationTextStylesStatics>([](IKnownAdaptiveNotificationTextStylesStatics const& f) { return f.HeaderNumeralSubtle(); });
}
inline auto KnownNotificationBindings::ToastGeneric()
{
return impl::call_factory_cast<hstring(*)(IKnownNotificationBindingsStatics const&), KnownNotificationBindings, IKnownNotificationBindingsStatics>([](IKnownNotificationBindingsStatics const& f) { return f.ToastGeneric(); });
}
inline Notification::Notification() :
Notification(impl::call_factory_cast<Notification(*)(Windows::Foundation::IActivationFactory const&), Notification>([](Windows::Foundation::IActivationFactory const& f) { return f.template ActivateInstance<Notification>(); }))
{
}
inline NotificationData::NotificationData() :
NotificationData(impl::call_factory_cast<NotificationData(*)(Windows::Foundation::IActivationFactory const&), NotificationData>([](Windows::Foundation::IActivationFactory const& f) { return f.template ActivateInstance<NotificationData>(); }))
{
}
inline NotificationData::NotificationData(param::iterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> const& initialValues, uint32_t sequenceNumber) :
NotificationData(impl::call_factory<NotificationData, INotificationDataFactory>([&](INotificationDataFactory const& f) { return f.CreateNotificationData(initialValues, sequenceNumber); }))
{
}
inline NotificationData::NotificationData(param::iterable<Windows::Foundation::Collections::IKeyValuePair<hstring, hstring>> const& initialValues) :
NotificationData(impl::call_factory<NotificationData, INotificationDataFactory>([&](INotificationDataFactory const& f) { return f.CreateNotificationData(initialValues); }))
{
}
inline ScheduledTileNotification::ScheduledTileNotification(Windows::Data::Xml::Dom::XmlDocument const& content, Windows::Foundation::DateTime const& deliveryTime) :
ScheduledTileNotification(impl::call_factory<ScheduledTileNotification, IScheduledTileNotificationFactory>([&](IScheduledTileNotificationFactory const& f) { return f.CreateScheduledTileNotification(content, deliveryTime); }))
{
}
inline ScheduledToastNotification::ScheduledToastNotification(Windows::Data::Xml::Dom::XmlDocument const& content, Windows::Foundation::DateTime const& deliveryTime) :
ScheduledToastNotification(impl::call_factory<ScheduledToastNotification, IScheduledToastNotificationFactory>([&](IScheduledToastNotificationFactory const& f) { return f.CreateScheduledToastNotification(content, deliveryTime); }))
{
}
inline ScheduledToastNotification::ScheduledToastNotification(Windows::Data::Xml::Dom::XmlDocument const& content, Windows::Foundation::DateTime const& deliveryTime, Windows::Foundation::TimeSpan const& snoozeInterval, uint32_t maximumSnoozeCount) :
ScheduledToastNotification(impl::call_factory<ScheduledToastNotification, IScheduledToastNotificationFactory>([&](IScheduledToastNotificationFactory const& f) { return f.CreateScheduledToastNotificationRecurring(content, deliveryTime, snoozeInterval, maximumSnoozeCount); }))
{
}
inline TileFlyoutNotification::TileFlyoutNotification(Windows::Data::Xml::Dom::XmlDocument const& content) :
TileFlyoutNotification(impl::call_factory<TileFlyoutNotification, ITileFlyoutNotificationFactory>([&](ITileFlyoutNotificationFactory const& f) { return f.CreateTileFlyoutNotification(content); }))
{
}
inline auto TileFlyoutUpdateManager::CreateTileFlyoutUpdaterForApplication()
{
return impl::call_factory_cast<Windows::UI::Notifications::TileFlyoutUpdater(*)(ITileFlyoutUpdateManagerStatics const&), TileFlyoutUpdateManager, ITileFlyoutUpdateManagerStatics>([](ITileFlyoutUpdateManagerStatics const& f) { return f.CreateTileFlyoutUpdaterForApplication(); });
}
inline auto TileFlyoutUpdateManager::CreateTileFlyoutUpdaterForApplication(param::hstring const& applicationId)
{
return impl::call_factory<TileFlyoutUpdateManager, ITileFlyoutUpdateManagerStatics>([&](ITileFlyoutUpdateManagerStatics const& f) { return f.CreateTileFlyoutUpdaterForApplication(applicationId); });
}
inline auto TileFlyoutUpdateManager::CreateTileFlyoutUpdaterForSecondaryTile(param::hstring const& tileId)
{
return impl::call_factory<TileFlyoutUpdateManager, ITileFlyoutUpdateManagerStatics>([&](ITileFlyoutUpdateManagerStatics const& f) { return f.CreateTileFlyoutUpdaterForSecondaryTile(tileId); });
}
inline auto TileFlyoutUpdateManager::GetTemplateContent(Windows::UI::Notifications::TileFlyoutTemplateType const& type)
{
return impl::call_factory<TileFlyoutUpdateManager, ITileFlyoutUpdateManagerStatics>([&](ITileFlyoutUpdateManagerStatics const& f) { return f.GetTemplateContent(type); });
}
inline TileNotification::TileNotification(Windows::Data::Xml::Dom::XmlDocument const& content) :
TileNotification(impl::call_factory<TileNotification, ITileNotificationFactory>([&](ITileNotificationFactory const& f) { return f.CreateTileNotification(content); }))
{
}
inline auto TileUpdateManager::CreateTileUpdaterForApplication()
{
return impl::call_factory_cast<Windows::UI::Notifications::TileUpdater(*)(ITileUpdateManagerStatics const&), TileUpdateManager, ITileUpdateManagerStatics>([](ITileUpdateManagerStatics const& f) { return f.CreateTileUpdaterForApplication(); });
}
inline auto TileUpdateManager::CreateTileUpdaterForApplication(param::hstring const& applicationId)
{
return impl::call_factory<TileUpdateManager, ITileUpdateManagerStatics>([&](ITileUpdateManagerStatics const& f) { return f.CreateTileUpdaterForApplication(applicationId); });
}
inline auto TileUpdateManager::CreateTileUpdaterForSecondaryTile(param::hstring const& tileId)
{
return impl::call_factory<TileUpdateManager, ITileUpdateManagerStatics>([&](ITileUpdateManagerStatics const& f) { return f.CreateTileUpdaterForSecondaryTile(tileId); });
}
inline auto TileUpdateManager::GetTemplateContent(Windows::UI::Notifications::TileTemplateType const& type)
{
return impl::call_factory<TileUpdateManager, ITileUpdateManagerStatics>([&](ITileUpdateManagerStatics const& f) { return f.GetTemplateContent(type); });
}
inline auto TileUpdateManager::GetForUser(Windows::System::User const& user)
{
return impl::call_factory<TileUpdateManager, ITileUpdateManagerStatics2>([&](ITileUpdateManagerStatics2 const& f) { return f.GetForUser(user); });
}
inline ToastCollection::ToastCollection(param::hstring const& collectionId, param::hstring const& displayName, param::hstring const& launchArgs, Windows::Foundation::Uri const& iconUri) :
ToastCollection(impl::call_factory<ToastCollection, IToastCollectionFactory>([&](IToastCollectionFactory const& f) { return f.CreateInstance(collectionId, displayName, launchArgs, iconUri); }))
{
}
inline ToastNotification::ToastNotification(Windows::Data::Xml::Dom::XmlDocument const& content) :
ToastNotification(impl::call_factory<ToastNotification, IToastNotificationFactory>([&](IToastNotificationFactory const& f) { return f.CreateToastNotification(content); }))
{
}
inline auto ToastNotificationManager::CreateToastNotifier()
{
return impl::call_factory_cast<Windows::UI::Notifications::ToastNotifier(*)(IToastNotificationManagerStatics const&), ToastNotificationManager, IToastNotificationManagerStatics>([](IToastNotificationManagerStatics const& f) { return f.CreateToastNotifier(); });
}
inline auto ToastNotificationManager::CreateToastNotifier(param::hstring const& applicationId)
{
return impl::call_factory<ToastNotificationManager, IToastNotificationManagerStatics>([&](IToastNotificationManagerStatics const& f) { return f.CreateToastNotifier(applicationId); });
}
inline auto ToastNotificationManager::GetTemplateContent(Windows::UI::Notifications::ToastTemplateType const& type)
{
return impl::call_factory<ToastNotificationManager, IToastNotificationManagerStatics>([&](IToastNotificationManagerStatics const& f) { return f.GetTemplateContent(type); });
}
inline auto ToastNotificationManager::History()
{
return impl::call_factory_cast<Windows::UI::Notifications::ToastNotificationHistory(*)(IToastNotificationManagerStatics2 const&), ToastNotificationManager, IToastNotificationManagerStatics2>([](IToastNotificationManagerStatics2 const& f) { return f.History(); });
}
inline auto ToastNotificationManager::GetForUser(Windows::System::User const& user)
{
return impl::call_factory<ToastNotificationManager, IToastNotificationManagerStatics4>([&](IToastNotificationManagerStatics4 const& f) { return f.GetForUser(user); });
}
inline auto ToastNotificationManager::ConfigureNotificationMirroring(Windows::UI::Notifications::NotificationMirroring const& value)
{
impl::call_factory<ToastNotificationManager, IToastNotificationManagerStatics4>([&](IToastNotificationManagerStatics4 const& f) { return f.ConfigureNotificationMirroring(value); });
}
inline auto ToastNotificationManager::GetDefault()
{
return impl::call_factory_cast<Windows::UI::Notifications::ToastNotificationManagerForUser(*)(IToastNotificationManagerStatics5 const&), ToastNotificationManager, IToastNotificationManagerStatics5>([](IToastNotificationManagerStatics5 const& f) { return f.GetDefault(); });
}
}
namespace std
{
#ifndef WINRT_LEAN_AND_MEAN
template<> struct hash<winrt::Windows::UI::Notifications::IAdaptiveNotificationContent> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IAdaptiveNotificationText> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IBadgeNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IBadgeNotificationFactory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IBadgeUpdateManagerForUser> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IBadgeUpdateManagerStatics> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IBadgeUpdateManagerStatics2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IBadgeUpdater> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IKnownAdaptiveNotificationHintsStatics> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IKnownAdaptiveNotificationTextStylesStatics> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IKnownNotificationBindingsStatics> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::INotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::INotificationBinding> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::INotificationData> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::INotificationDataFactory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::INotificationVisual> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IScheduledTileNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IScheduledTileNotificationFactory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IScheduledToastNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IScheduledToastNotification2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IScheduledToastNotification3> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IScheduledToastNotification4> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IScheduledToastNotificationFactory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IScheduledToastNotificationShowingEventArgs> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IShownTileNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileFlyoutNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileFlyoutNotificationFactory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileFlyoutUpdateManagerStatics> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileFlyoutUpdater> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileNotificationFactory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileUpdateManagerForUser> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileUpdateManagerStatics> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileUpdateManagerStatics2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileUpdater> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ITileUpdater2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastActivatedEventArgs> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastActivatedEventArgs2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastCollection> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastCollectionFactory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastCollectionManager> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastDismissedEventArgs> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastFailedEventArgs> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotification2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotification3> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotification4> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotification6> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationActionTriggerDetail> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationFactory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationHistory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationHistory2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationHistoryChangedTriggerDetail2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationManagerForUser> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationManagerForUser2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationManagerStatics> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationManagerStatics2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationManagerStatics4> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotificationManagerStatics5> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotifier> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotifier2> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IToastNotifier3> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IUserNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::IUserNotificationChangedEventArgs> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::AdaptiveNotificationText> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::BadgeNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::BadgeUpdateManager> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::BadgeUpdateManagerForUser> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::BadgeUpdater> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::KnownAdaptiveNotificationHints> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::KnownAdaptiveNotificationTextStyles> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::KnownNotificationBindings> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::Notification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::NotificationBinding> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::NotificationData> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::NotificationVisual> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ScheduledTileNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ScheduledToastNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ScheduledToastNotificationShowingEventArgs> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ShownTileNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::TileFlyoutNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::TileFlyoutUpdateManager> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::TileFlyoutUpdater> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::TileNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::TileUpdateManager> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::TileUpdateManagerForUser> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::TileUpdater> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastActivatedEventArgs> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastCollection> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastCollectionManager> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastDismissedEventArgs> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastFailedEventArgs> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastNotificationActionTriggerDetail> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastNotificationHistory> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastNotificationHistoryChangedTriggerDetail> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastNotificationManager> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastNotificationManagerForUser> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::ToastNotifier> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::UserNotification> : winrt::impl::hash_base {};
template<> struct hash<winrt::Windows::UI::Notifications::UserNotificationChangedEventArgs> : winrt::impl::hash_base {};
#endif
}
#endif
| [
"garrett1168@outlook.com"
] | garrett1168@outlook.com |
ca56bd0040a25564afa63a751af5b203012f74b9 | 600df3590cce1fe49b9a96e9ca5b5242884a2a70 | /chromecast/common/platform_client_auth_simple.cc | 481b9a9ca5e0e0714a9b69f7b6f5592f32225ca1 | [
"BSD-3-Clause"
] | permissive | metux/chromium-suckless | efd087ba4f4070a6caac5bfbfb0f7a4e2f3c438a | 72a05af97787001756bae2511b7985e61498c965 | refs/heads/orig | 2022-12-04T23:53:58.681218 | 2017-04-30T10:59:06 | 2017-04-30T23:35:58 | 89,884,931 | 5 | 3 | BSD-3-Clause | 2022-11-23T20:52:53 | 2017-05-01T00:09:08 | null | UTF-8 | C++ | false | false | 419 | cc | // Copyright 2014 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 "chromecast/common/platform_client_auth.h"
namespace chromecast {
// static
bool PlatformClientAuth::initialized_ = false;
// static
bool PlatformClientAuth::Initialize() {
initialized_ = true;
return true;
}
} // namespace chromecast
| [
"enrico.weigelt@gr13.net"
] | enrico.weigelt@gr13.net |
f2133c18e1af71bb826395c4cd3eaf50f49b8c8b | 63257ae40607399c62e6d490af8852c5220ec411 | /leetcode/261.cpp | 8b2fa29c56cea76f1c5a02f93dbf97bec7a6048d | [] | no_license | doctoroyy/algorithm | 034040a2258a3bfad371357873022b25d7b7fa88 | 2d503450c78b310876063e09ca3375d77f600069 | refs/heads/master | 2021-08-30T13:15:13.819685 | 2021-08-30T12:02:13 | 2021-08-30T12:02:13 | 158,483,283 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,567 | cpp | // https://leetcode-cn.com/problems/graph-valid-tree/
#include<iostream>
#include<vector>
#include<cmath>
#include<set>
#include<algorithm>
using namespace std;
// Input: n = 5, edges = [[0,1],[0,2],[0,3],[1,4]]
// Output: true
// Input: n = 5, edges = [[0,1],[1,2],[2,3],[1,3],[1,4]]
// Output: false
const int maxN = 2010;
int pre[maxN];
int find(int x) {
return x == pre[x] ? x : pre[x] = find(pre[x]);
}
void _union(int x, int y) {
int fx = find(x), fy = find(y);
if (fx != fy) {
pre[y] = fx;
}
}
class Solution {
public:
bool validTree(int n, vector<vector<int> >& edges) {
for (int i = 0; i < n; i++) {
pre[i] = i;
}
for (int i = 0; i < edges.size(); i++) {
int a = edges[i][0], b = edges[i][1];
if (find(a) == find(b)) {
cout << 'enter' << endl;
return false;
}
_union(a, b);
}
set<int> preSet;
for (int i = 0; i < n; i++) {
int res = find(i);
cout << i << "'s pre is " << res << endl;
preSet.insert(res);
}
return preSet.size() == 1;
}
};
int main() {
int n;
cin >> n;
bool flag = true;
for (int i = 0; i < n; i++) pre[i] = i;
while (n--) {
int a, b;
cin >> a >> b;
if (find(a) == find(b)) {
cout << 'enter' << endl;
flag = false;
}
_union(a, b);
}
set<int> preSet;
for (int i = 0; i < n; i++) {
int res = find(i);
cout << i << "'s pre is " << res << endl;
preSet.insert(find(i));
}
cout << (preSet.size() == 1) << endl;
return 0;
} | [
"doctor.oyy@gmail.com"
] | doctor.oyy@gmail.com |
89f2623eaa66c40a34074f0c41e3ccb1ea2f3604 | 46ab745e21545738e89aa49dde86b9adc86d9b24 | /game_castlevania/game_castlevania/Monkey.h | 5130257831fb39414ba08e19a9444cd28ca5f135 | [] | no_license | hoangminh122/GameNhapMon_ADM | 8336e619a3ba3fbd19ead6040a6081b5ba9c627c | 974a383e6cef752e575a23577a5e526dc44c8963 | refs/heads/master | 2022-12-01T20:13:40.462500 | 2020-08-09T15:52:48 | 2020-08-09T15:52:48 | 259,587,629 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 905 | h | #pragma once
#include "GameObject.h"
#define MONKEY_BBOX_WIDTH 18
#define MONKEY_BBOX_HEIGHT 16
#define MONKEY_STATE_IDLE 0
#define MONKEY_STATE_WALK 1
#define MONKEY_STATE_JUMP 2
#define MONKEY_JUMP_SPEED_X 0.13f
#define MONKEY_JUMP_SPEED_Y 0.15f
#define MONKEY_WALK_SPEED_X 0.2f
#define MONKEY_WALK_SPEED_Y 0.12f
#define MONKEY_GRAVITY_SPEED 0.0012f
#define MONKEY_TIME_WAIT_ATTACK 380
class Monkey: public GameObject
{
bool isIdle = true;
bool isJump = false;
bool isDisableJump = false;
bool isHitted = false;
bool isHide = false;
public:
float xde, yde;
float start_x ;
float start_y ;
Monkey();
int isDied = 0;
void SetDied() { isDied = 1; };
virtual void Update(DWORD dt, vector<LPGAMEOBJECT>* coObjects = NULL);
virtual void Render();
virtual void GetBoundingBox(float& left, float& top, float& right, float& bottom);
void SetState(int state);
~Monkey();
};
| [
"hoangminh12297@gmail.com"
] | hoangminh12297@gmail.com |
005dd4c273d5f4fc8051176ff079496f9f8e0e59 | a1ceba428d5c1e9974e19d4b1d983b426d0fd27f | /symbol_list.h | dca9a3dcd5eb7dcebcfda530a58c986338f85fe1 | [] | no_license | josh-jacobson/Compiler | 87c9871bc471d4c9b0d9ca32fdd0f8833ec6c456 | fd8eb52716c0a5dcac3aad60d09abe074e92f7d8 | refs/heads/master | 2021-01-01T19:16:11.572473 | 2013-08-25T23:27:14 | 2013-08-25T23:27:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,193 | h | /**
EECS 211 Program 8
symbol_list.h
Author: Josh Jacobson
Contact: joshj@u.northwestern.edu
Due Date: June 4, 2012
*/
#ifndef symbol_list_h
#define symbol_list_h
#include "symbols.h"
#define LISTLEN 200
#define ALLOWDUPLICATES 1
#define DONTALLOWDUPLICATES 2
class symbolList {
public:
symbolList(int duplicates_allowed);
// ~symbolList();
void print();
int addSymbol(SYMBOL* n);
int getSymbol(char* name, SYMBOL** s);
int removeSymbol(char* name);
SYMBOL* retrieveElement(int j);
void setVariableValue(char *n, int v);
void getVariableValue(char *n, int *v, int *u);
int getNextOpenPositionNumber();
int getCurrentPosition();
void replaceSymbol(SYMBOL* s, int k);
protected:
SYMBOL* symbolarray[LISTLEN];
int number_of_symbols_in_list;
int duplicate_symbols_allowed;
};
class symbolStack {
private:
SYMBOL* stack[LISTLEN];
int number_of_elements;
public:
symbolStack();
void print();
int push(SYMBOL *n);
int copyTopLevel(SYMBOL **copyto);
int pop();
int isempty();
int getTopLevelValue(int *v);
void updateWhileJmpForwardRef(int forwardref);
};
#endif
| [
"joshjacobson14@gmail.com"
] | joshjacobson14@gmail.com |
439d1ae50377d34215a796bc7adb6ccdf863c2b1 | a8e5517df264ca12e84c377270574a3cc378f0c1 | /BOJ/11404/solution.cpp | 1adc9d3fd42fb4b1e2053e41b90dc56a33984f0b | [] | no_license | wowoto9772/Hungry-Algorithm | cb94edc0d8a4a3518dd1996feafada9774767ff0 | 4be3d0e2f07d01e55653c277870d93b73ec917de | refs/heads/master | 2021-05-04T23:28:12.443915 | 2019-08-11T08:11:39 | 2019-08-11T08:11:39 | 64,544,872 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 680 | cpp | #include <stdio.h>
#include <algorithm>
using namespace std;
#define Max 987654321
int d[103][103];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
d[i][j] = Max;
if (i == j)d[i][j] = 0;
}
}
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (d[a][b] > c)d[a][b] = c;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
printf("%d ", d[i][j]);
}printf("\n");
}
} | [
"csjaj9772@gmail.com"
] | csjaj9772@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.